*: fix claim tx (#83)

* spaces-cli: fix naming
* mempool: move channel into inner and fix threaded test
* vm: better handle errs with app_gossip
* spacesvm: bump deps
* name change cleanup
* spaces-cli: add ping command and cleanup
* spaces-cli: simplify output of successful tx

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

Author: hexfusion

spaces-cli/Cargo.toml

@@ -1,15 +1,15 @@
 [package]
-name = "spacesvm_cli"
+name = "spaces-cli"
 version = "0.0.0"
 edition = "2021"
 rust-version = "1.65"
 publish = false
-description = "spacesvm_cli_for_issuing_RPC_commands"
+description = "spacesvm cli for issuing RPC commands"
 license = "BSD-3-Clause"
 homepage = "https://avax.network"
 
 [dependencies]
-avalanche-types = { version = "0.0.135", features = ["subnet"] }
+avalanche-types = { version = "0.0.138", features = ["subnet"] }
 clap = { version = "4.0", features = ["derive"] }
 hex = "0.4.3"
 jsonrpc-core = "18.0.0"

spaces-cli/src/main.rs

@@ -1,14 +1,19 @@
-use std::error;
-use std::fs::File;
-use std::io::{Result, Write};
-use std::path::Path;
+use std::{
+    error,
+    fs::File,
+    io::{Result, Write},
+    path::Path,
+};
 
 use avalanche_types::key;
 use clap::{Parser, Subcommand};
 use jsonrpc_client_transports::{transports, RpcError};
 use jsonrpc_core::futures;
 use spacesvm::{
-    api::{DecodeTxArgs, IssueTxArgs, ResolveArgs, ServiceClient as Client},
+    api::{
+        DecodeTxArgs, IssueTxArgs, IssueTxResponse, PingResponse, ResolveArgs, ResolveResponse,
+        ServiceClient as Client,
+    },
     chain::tx::{decoder, tx::TransactionType, unsigned::TransactionData},
 };
 
@@ -46,6 +51,7 @@ enum Command {
         space: String,
         key: String,
     },
+    Ping {},
 }
 
 #[tokio::main]
@@ -55,22 +61,36 @@ async fn main() -> std::result::Result<(), Box<dyn error::Error>> {
     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?;
 
+    // prints the value returned if available.
     if let Command::Get { space, key } = &cli.command {
-        futures::executor::block_on(client.resolve(ResolveArgs {
-            space: space.as_bytes().to_vec(),
-            key: key.as_bytes().to_vec(),
-        }))
-        .map_err(|e| e.to_string())?;
+        let resp =
+            futures::executor::block_on(get(&client, space, key)).map_err(|e| e.to_string())?;
+        log::debug!("{:?}", resp);
+
+        println!("{}", String::from_utf8_lossy(&resp.value));
+        return Ok(());
+    }
+
+    // returns on success and errors on failure
+    if let Command::Ping {} = &cli.command {
+        let resp = futures::executor::block_on(ping(&client)).map_err(|e| e.to_string())?;
+        log::debug!("{:?}", resp);
+
+        return Ok(());
     }
 
     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())
+    // prints the id of a successful transaction.
+    let resp = futures::executor::block_on(sign_and_submit(&client, &secret_key, tx))
+        .map_err(|e| e.to_string())?;
+    println!("{}", resp.tx_id);
+
+    Ok(())
 }
 
+/// Takes a TX command and returns transaction data.
 fn command_to_tx(command: Command) -> Result<TransactionData> {
     match command {
         Command::Claim { space } => Ok(claim_tx(space)),
@@ -83,6 +103,7 @@ fn command_to_tx(command: Command) -> Result<TransactionData> {
     }
 }
 
+/// Returns a private key from a given path or creates new.
 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();
@@ -125,20 +146,18 @@ fn delete_tx(space: String, key: String) -> TransactionData {
     }
 }
 
-async fn ping(client: &Client) -> Result<()> {
+async fn ping(client: &Client) -> Result<PingResponse> {
     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(())
+    client.ping().await.map_err(error_handling)
 }
 
+/// Decodes transaction signs the typed data ans issues tx returning IssueTxResponse.
 async fn sign_and_submit(
     client: &Client,
     pk: &key::secp256k1::private_key::Key,
     tx_data: TransactionData,
-) -> Result<()> {
+) -> Result<IssueTxResponse> {
     let error_handling =
         |e: RpcError| std::io::Error::new(std::io::ErrorKind::Other, dbg!(e).to_string());
     let resp = client
@@ -151,13 +170,25 @@ async fn sign_and_submit(
     let dh = decoder::hash_structured_data(typed_data)?;
     let sig = pk.sign_digest(&dh.as_bytes())?;
 
-    let resp = client
+    client
         .issue_tx(IssueTxArgs {
             typed_data: resp.typed_data,
             signature: sig.to_bytes().to_vec(),
         })
         .await
-        .map_err(error_handling)?;
-    println!("response: {:?}", resp);
-    Ok(())
+        .map_err(error_handling)
+}
+
+/// Get returns a ResolveResponse.
+async fn get(client: &Client, space: &str, key: &str) -> Result<ResolveResponse> {
+    let error_handling =
+        |e: RpcError| std::io::Error::new(std::io::ErrorKind::Other, dbg!(e).to_string());
+
+    client
+        .resolve(ResolveArgs {
+            space: space.as_bytes().to_vec(),
+            key: key.as_bytes().to_vec(),
+        })
+        .await
+        .map_err(error_handling)
 }

spacesvm/Cargo.toml

@@ -15,7 +15,7 @@ name = "spacesvm"
 path = "src/bin/spaces/main.rs"
 
 [dependencies]
-avalanche-types = { version = "0.0.135", features = ["subnet"] }
+avalanche-types = { version = "0.0.138", features = ["subnet"] }
 byteorder = "1.4.3"
 chrono = "0.4.22"
 crossbeam-channel = "0.5.6"

spacesvm/src/bin/spaces/main.rs

@@ -6,7 +6,7 @@ use log::info;
 
 use spacesvm::{genesis, vm};
 
-pub const APP_NAME: &str = "spaces-vm-rs";
+pub const APP_NAME: &str = "spacesvm-rs";
 
 #[tokio::main]
 async fn main() -> Result<()> {

spacesvm/src/chain/storage.rs

@@ -239,18 +239,18 @@ pub async fn has_space(
     db.has(&space_info_key(space)).await
 }
 
-/// 'KEY_PREFIX' + 'BYTE_DELIMITER' + [r_bucket] + 'BYTE_DELIMITER' + [key]
-pub fn space_value_key(r_bucket: ids::short::Id, key: &[u8]) -> Vec<u8> {
+/// 'KEY_PREFIX' + 'BYTE_DELIMITER' + [r_space] + 'BYTE_DELIMITER' + [key]
+pub fn space_value_key(r_space: ids::short::Id, key: &[u8]) -> Vec<u8> {
     let mut k: Vec<u8> = Vec::with_capacity(2 + SHORT_ID_LEN + 1 + key.len());
     k.push(KEY_PREFIX);
     k.push(BYTE_DELIMITER);
-    k.extend_from_slice(r_bucket.as_ref());
+    k.extend_from_slice(r_space.as_ref());
     k.push(BYTE_DELIMITER);
     k.extend_from_slice(key);
     k
 }
 
-/// 'INFO_PREFIX' + 'BYTE_DELIMITER' + [bucket]
+/// 'INFO_PREFIX' + 'BYTE_DELIMITER' + [space]
 pub fn space_info_key(space: &[u8]) -> Vec<u8> {
     let mut k: Vec<u8> = Vec::with_capacity(space.len() + 2);
     k.push(INFO_PREFIX);

spacesvm/src/chain/tx/decoder.rs

@@ -15,7 +15,7 @@ pub const TD_STRING: &str = "string";
 pub const TD_U64: &str = "u64";
 pub const TD_BYTES: &str = "bytes";
 pub const TD_BLOCK_ID: &str = "blockId";
-pub const TD_SPACE: &str = "bucket";
+pub const TD_SPACE: &str = "space";
 pub const TD_KEY: &str = "key";
 pub const TD_VALUE: &str = "value";
 

spacesvm/src/chain/tx/delete.rs

@@ -17,7 +17,7 @@ use super::{
     unsigned,
 };
 
-/// Removes a key and value from the underlying bucket. No error will return
+/// Removes a key and value from the underlying space. No error will return
 /// if the key is not found.
 #[derive(Serialize, Deserialize, Clone, Debug, Default)]
 #[serde(rename_all = "camelCase")]
@@ -63,14 +63,14 @@ impl unsigned::Transaction for Tx {
         if info.is_none() {
             return Err(Error::new(
                 ErrorKind::NotFound,
-                format!("bucket not found: {}", self.space),
+                format!("space not found: {}", self.space),
             ));
         }
         let info = info.unwrap();
         if info.owner != txn_ctx.sender {
             return Err(Error::new(
                 ErrorKind::PermissionDenied,
-                format!("sets only allowed for bucket owner: {}", self.space),
+                format!("sets only allowed for space owner: {}", self.space),
             ));
         }
 

spacesvm/src/chain/tx/set.rs

@@ -22,8 +22,8 @@ use super::{
 const HASH_LEN: usize = 66;
 
 /// Performs a write against the logical keyspace. If the key exists
-/// the value will be overwritten. The root bucket must be created
-/// in advance.
+/// the value will be overwritten. The space must be created in
+/// advance.
 #[derive(Serialize, Deserialize, Clone, Debug)]
 
 pub struct Tx {

spacesvm/src/chain/tx/tx.rs

@@ -16,7 +16,7 @@ use super::{decoder, unsigned::TransactionContext};
 pub enum TransactionType {
     /// Root namespace.
     Claim,
-    /// Create or update a key/value pair for a bucket.
+    /// Create or update a key/value pair for a space.
     Set,
     /// Remove a key.
     Delete,
@@ -33,7 +33,7 @@ impl Default for TransactionType {
 impl fmt::Display for TransactionType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            TransactionType::Claim => write!(f, "bucket"),
+            TransactionType::Claim => write!(f, "claim"),
             TransactionType::Set => write!(f, "set"),
             TransactionType::Delete => write!(f, "delete"),
             TransactionType::Unknown => write!(f, "unknown"),