MVP (#72)

* MVP and tests

Signed-off-by: Sam Batschelet <[email protected]>

Author: hexfusion

.github/workflows/test-and-release.yml

@@ -110,8 +110,13 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.x'
+      - name: Build plugin
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --release --bin mini-kvvm
       - name: Run e2e tests
-        run: scripts/tests.e2e.sh 1.7.14
+        run: VM_PLUGIN_PATH=/home/runner/work/mini-kvvm-rs/mini-kvvm-rs/target/release/mini-kvvm scripts/tests.e2e.sh
 
   release:
     name: Release ${{ matrix.job.target }} (${{ matrix.job.os }})

.gitignore

@@ -14,3 +14,6 @@ Cargo.lock
 
 # ignore dev tools
 .vscode
+
+# ignore private keys
+.*-pk

Cargo.toml

@@ -1,5 +1,10 @@
 [workspace]
 members = [
     "mini-kvvm",
-    "tests/e2e"
+    "tests/e2e",
+    "cli",
 ]
+
+[patch.crates-io]
+# TODO: replace
+eip-712 = {git="https://github.com/darioush/EIP-712.git"}

README.md

@@ -21,3 +21,4 @@ cp \
 ./target/x86_64-unknown-linux-musl/release/mini-kvvm-rs \
 ${HOME}/go/src/github.com/ava-labs/avalanchego/build/plugins/qBnAKUQ2mxjMHCneWjq5nFuhntoWrsKsCjaYSouFjpuCB2o5d
 ```
+##

cli/.gitignore

@@ -0,0 +1 @@
+.*-pk

cli/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "cli"
+version = "0.0.0"
+edition = "2021"
+rust-version = "1.65"
+publish = false
+description = "cli for issuing simple rpc commands to mini-kvvm"
+license = "BSD-3-Clause"
+homepage = "https://avax.network"
+
+[dependencies]
+avalanche-types = { version = "0.0.132", features = ["rpcchainvm"] }
+clap = { version = "4.0", features = ["derive"] }
+hex = "0.4.3"
+jsonrpc-core = "18.0.0"
+jsonrpc-core-client = { version = "18.0.0" }
+jsonrpc-client-transports = "18.0.0"
+jsonrpc-derive = "18.0"
+log = "0.4.17"
+mini-kvvm = {path = "../mini-kvvm"}
+serde = { version = "1.0.147", features = ["derive"] }
+serde_json = "1.0.87" 
+tokio = { version = "1.21.2", features = ["full"] }

cli/src/main.rs

@@ -0,0 +1,161 @@
+use avalanche_types::key;
+use clap::{Parser, Subcommand};
+use jsonrpc_client_transports::{transports, RpcError};
+use jsonrpc_core::futures;
+use mini_kvvm::api::ServiceClient as Client;
+use mini_kvvm::api::{DecodeTxArgs, IssueTxArgs, ResolveArgs};
+use mini_kvvm::chain::tx::{decoder, tx::TransactionType, unsigned::TransactionData};
+use std::error;
+use std::fs::File;
+use std::io::{Result, Write};
+use std::path::Path;
+
+#[derive(Parser)]
+#[command(version, about, long_about = None)]
+struct Cli {
+    /// Endpoint for RPC calls.
+    #[clap(long)]
+    endpoint: String,
+
+    /// Private key file.
+    #[clap(long, default_value = ".mini-kvvm-cli-pk")]
+    private_key_file: String,
+
+    /// Which subcommand to call.
+    #[command(subcommand)]
+    command: Command,
+}
+
+#[derive(Subcommand, Debug)]
+enum Command {
+    Bucket {
+        bucket: String,
+    },
+    Set {
+        bucket: String,
+        key: String,
+        value: String,
+    },
+    Delete {
+        bucket: String,
+        key: String,
+    },
+    Get {
+        bucket: String,
+        key: String,
+    },
+}
+
+#[tokio::main]
+async fn main() -> std::result::Result<(), Box<dyn error::Error>> {
+    let cli = Cli::parse();
+
+    let secret_key = get_or_create_pk(&cli.private_key_file)?;
+    let connection = transports::http::connect::<Client>(&cli.endpoint);
+    let client = futures::executor::block_on(connection)?;
+    ping(&client).await?;
+
+    if let Command::Get { bucket, key } = &cli.command {
+        futures::executor::block_on(client.resolve(ResolveArgs {
+            bucket: bucket.as_bytes().to_vec(),
+            key: key.as_bytes().to_vec(),
+        }))
+        .map_err(|e| e.to_string())?;
+    }
+
+    let tx = command_to_tx(cli.command)?;
+
+    futures::executor::block_on(sign_and_submit(&client, &secret_key, tx))
+        .map_err(|e| e.to_string().into())
+}
+
+fn command_to_tx(command: Command) -> Result<TransactionData> {
+    match command {
+        Command::Bucket { bucket } => Ok(bucket_tx(bucket)),
+        Command::Set { bucket, key, value } => Ok(set_tx(bucket, key, value.as_bytes().to_vec())),
+        Command::Delete { bucket, key } => Ok(delete_tx(bucket, key)),
+        _ => Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            "not a supported tx",
+        )),
+    }
+}
+
+fn get_or_create_pk(path: &str) -> Result<key::secp256k1::private_key::Key> {
+    if !Path::new(path).try_exists()? {
+        let secret_key = key::secp256k1::private_key::Key::generate().unwrap();
+        let mut f = File::create(path)?;
+        let hex = hex::encode(&secret_key.to_bytes());
+        f.write_all(hex.as_bytes())?;
+        return Ok(secret_key);
+    }
+    let contents = std::fs::read_to_string(path)?;
+    let parsed = hex::decode(contents)
+        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+    key::secp256k1::private_key::Key::from_bytes(&parsed)
+        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
+}
+
+fn bucket_tx(bucket: String) -> TransactionData {
+    TransactionData {
+        typ: TransactionType::Bucket,
+        bucket,
+        key: "".to_string(),
+        value: vec![],
+    }
+}
+
+fn set_tx(bucket: String, key: String, value: Vec<u8>) -> TransactionData {
+    TransactionData {
+        typ: TransactionType::Set,
+        bucket,
+        key,
+        value,
+    }
+}
+
+fn delete_tx(bucket: String, key: String) -> TransactionData {
+    TransactionData {
+        typ: TransactionType::Delete,
+        bucket,
+        key,
+        value: vec![],
+    }
+}
+
+async fn ping(client: &Client) -> Result<()> {
+    let error_handling =
+        |e: RpcError| std::io::Error::new(std::io::ErrorKind::Other, e.to_string());
+    let resp = client.ping().await.map_err(error_handling);
+    dbg!(resp.is_ok());
+    dbg!(&resp);
+    Ok(())
+}
+
+async fn sign_and_submit(
+    client: &Client,
+    pk: &key::secp256k1::private_key::Key,
+    tx_data: TransactionData,
+) -> Result<()> {
+    let error_handling =
+        |e: RpcError| std::io::Error::new(std::io::ErrorKind::Other, dbg!(e).to_string());
+    let resp = client
+        .decode_tx(DecodeTxArgs { tx_data })
+        .await
+        .map_err(error_handling)?;
+
+    let typed_data = &resp.typed_data;
+
+    let dh = decoder::hash_structured_data(typed_data)?;
+    let sig = pk.sign_digest(&dh.as_bytes())?;
+
+    let resp = client
+        .issue_tx(IssueTxArgs {
+            typed_data: resp.typed_data,
+            signature: sig.to_bytes().to_vec(),
+        })
+        .await
+        .map_err(error_handling)?;
+    println!("response: {:?}", resp);
+    Ok(())
+}

mini-kvvm/Cargo.toml

@@ -2,7 +2,7 @@
 name = "mini-kvvm"
 version = "0.0.0"
 edition = "2021"
-rust-version = "1.63"
+rust-version = "1.65"
 publish = false
 description = "Mini key-value store VM for Avalanche in Rust"
 license = "BSD-3-Clause"
@@ -14,39 +14,37 @@ name = "mini-kvvm"
 path = "src/bin/mini-kvvm/main.rs"
 
 [dependencies]
-avalanche-proto = { version = "0.16.0" }
-avalanche-types = { version = "0.0.38" }
+avalanche-proto = { version = "0.19.0" }
+avalanche-types = { version = "0.0.132", features = ["rpcchainvm"] }
 byteorder = "1.4.3"
-chan = "0.1.23"
 chrono = "0.4.19"
 crossbeam-channel = "0.5.6"
 derivative = "2.2.0"
 dyn-clone = "1.0.9"
 ethereum-types = { version = "0.14.0" }
-clap = { version = "3.1.17", features = ["cargo", "derive"] }
+clap = { version = "4.0.9", features = ["cargo", "derive"] }
+eip-712 = "0.1.0"
 env_logger = "0.9.0"
 hex = "0.4.3"
+http = "0.2.8"
 jsonrpc-core = "18.0.0"
 jsonrpc-core-client = { version = "18.0.0" }
 jsonrpc-derive = "18.0"
 log = "0.4.17"
 lru = "0.8.0"
 prost = "0.11.0"
+ripemd = "0.1.3"
 semver = "1.0.13"
 serde = { version = "1.0.144", features = ["derive"] }
 serde_json = "1.0.85"
 serde_yaml = "0.9.10"
 sha3 = "0.10.2"
-tokio = { version = "1.20.1", features = ["fs", "rt-multi-thread"] }
-tokio-stream = { version = "0.1.9", features = ["net"] }
-tonic = { version = "0.8.1", features = ["gzip"] }
+tokio = { version = "1.21.2", features = ["fs", "rt-multi-thread"] }
+tokio-stream = { version = "0.1.11", features = ["net"] }
+tonic = { version = "0.8.2", features = ["gzip"] }
 tonic-health = "0.7"
 typetag = "0.2"
 
-[[test]]
-name = "integration"
-path = "tests/integration_tests.rs"
-
-[dev-dependencies]
+[dev-dependencies] 
 jsonrpc-tcp-server = "18.0.0"
-futures-test = "0.3.24"
+futures-test = "0.3.24"

mini-kvvm/src/api/mod.rs

@@ -5,16 +5,17 @@ use jsonrpc_core::{BoxFuture, Error, ErrorCode, Result};
 use jsonrpc_derive::rpc;
 use serde::{Deserialize, Serialize};
 
-use crate::chain::{storage::ValueMeta, tx, tx::decoder::TypedData};
+use crate::chain::{
+    storage::ValueMeta,
+    tx::decoder::TypedData,
+    tx::{self},
+};
 
 #[rpc]
 pub trait Service {
     #[rpc(name = "ping")]
     fn ping(&self) -> BoxFuture<Result<PingResponse>>;
 
-    #[rpc(name = "issue_raw_tx")]
-    fn issue_raw_tx(&self, params: IssueRawTxArgs) -> BoxFuture<Result<IssueRawTxResponse>>;
-
     #[rpc(name = "issue_tx")]
     fn issue_tx(&self, params: IssueTxArgs) -> BoxFuture<Result<IssueTxResponse>>;
 
@@ -23,21 +24,6 @@ pub trait Service {
 
     #[rpc(name = "resolve")]
     fn resolve(&self, params: ResolveArgs) -> BoxFuture<Result<ResolveResponse>>;
-
-    #[rpc(name = "build_block")]
-    fn build_block(&self, params: BuildBlockArgs) -> BoxFuture<Result<BuildBlockResponse>>;
-
-    #[rpc(name = "get_block")]
-    fn get_block(&self, params: GetBlockArgs) -> BoxFuture<Result<GetBlockResponse>>;
-
-    #[rpc(name = "last_accepted")]
-    fn last_accepted(&self) -> BoxFuture<Result<LastAcceptedResponse>>;
-
-    #[rpc(name = "parse_block")]
-    fn parse_block(&self, params: ParseBlockArgs) -> BoxFuture<Result<ParseBlockResponse>>;
-
-    #[rpc(name = "put_block")]
-    fn put_block(&self, params: PutBlockArgs) -> BoxFuture<Result<PutBlockResponse>>;
 }
 
 #[derive(Deserialize, Serialize, Debug)]
@@ -59,6 +45,7 @@ pub struct IssueRawTxResponse {
 #[derive(Deserialize, Serialize, Debug)]
 pub struct IssueTxArgs {
     pub typed_data: TypedData,
+    pub signature: Vec<u8>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
@@ -90,51 +77,6 @@ pub struct ResolveResponse {
     pub meta: ValueMeta,
 }
 
-#[derive(Deserialize, Serialize, Debug)]
-pub struct BuildBlockArgs {}
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct BuildBlockResponse {
-    pub block: Vec<u8>,
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct GetBlockArgs {
-    #[serde(deserialize_with = "ids::must_deserialize_id")]
-    pub id: ids::Id,
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct GetBlockResponse {
-    pub block: Vec<u8>,
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct LastAcceptedResponse {
-    pub id: ids::Id,
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct ParseBlockArgs {
-    pub bytes: Vec<u8>,
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct ParseBlockResponse {
-    pub block: Vec<u8>,
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct PutBlockArgs {
-    pub bytes: Vec<u8>,
-}
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct PutBlockResponse {
-    #[serde(deserialize_with = "ids::must_deserialize_id")]
-    pub id: ids::Id,
-}
-
 pub fn create_jsonrpc_error(e: std::io::Error) -> Error {
     let mut error = Error::new(ErrorCode::InternalError);
     error.message = format!("{}", e);