passing message types properly between client and sp

demos/rust-cosmos-broadcaster-client/plan.txt

@@ -1,13 +0,0 @@
-Plan:
-* rewrite ts cosmos broadcaster SP in rust
-* create simple rust binary for client cli use with 2 functions:
-	* use standard CLI method - cf. NymCLI
-	* getSequence() for offline signing
-	* submitTx() for sending tx thru mixnet to SP for broadcasting
-
-* rust server code - communicates with chain
-	* sdk
-	* nym validator client - broadcast client, gets sequence + submits tx
-* rust client code - communicates with server via mixnet
-	* sdk
-	* nym validator client - offline signer

demos/rust-cosmos-broadcaster-client/src/commands/commands.rs

@@ -2,7 +2,7 @@ use nym_cli_commands::validator::mixnet::Mixnet;
 use nym_crypto::generic_array::sequence;
 use nym_sphinx_addressing::clients::Recipient;
 use nym_validator_client::nyxd::CosmWasmClient;
-use nym_validator_client::nyxd::cosmwasm_client::types::SequenceResponse;
+// use nym_validator_client::nyxd::cosmwasm_client::types::SequenceResponse;
 use nym_validator_client::signing::direct_wallet::DirectSecp256k1HdWallet;
 use nym_validator_client::signing::tx_signer::TxSigner;
 use nym_validator_client::signing::SignerData;
@@ -17,15 +17,25 @@ use serde::{Deserialize, Serialize};
 // use serde_json::Result; 
 
 #[derive(Deserialize, Serialize)]
-struct SequenceRequestData<'a> {
-    validator: &'a str, 
+struct SequenceRequest {
+    validator: String, 
     signer_address: AccountId, 
-    request_type: String
+    // request_type: String
+}
+#[derive(Deserialize, Serialize)]
+struct SequenceResponse {
+    sequence_response: u8, 
+    chain_id: Id
 }
 
-struct SequenceResponseData {
-    sequence_response: SequenceResponse, 
-    chain_id: Id
+enum RequestTypes {
+    Sequence(SequenceRequest), 
+    // Broadcast(BroadcastRequest)
+}
+
+enum ResponseTypes {
+    Sequence(SequenceResponse), 
+    // Broadcast(BroadcastResponse)
 }
 
 pub async fn offline_sign(mnemonic: bip39::Mnemonic, to: AccountId, client: &mut MixnetClient , sp_address: Recipient) -> String {
@@ -33,7 +43,7 @@ pub async fn offline_sign(mnemonic: bip39::Mnemonic, to: AccountId, client: &mut
     // TODO take coin amount from function args, + load network vars from config file. 
     let prefix = "n";
     let denom: Denom = "unym".parse().unwrap();
-    let validator = "https://qwerty-validator.qa.nymte.ch";
+    let validator = String::from("https://qwerty-validator.qa.nymte.ch");
 
     let signer = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);
     let signer_address = signer.try_derive_accounts().unwrap()[0].address().clone();
@@ -52,10 +62,10 @@ pub async fn offline_sign(mnemonic: bip39::Mnemonic, to: AccountId, client: &mut
     // let chain_id = broadcaster.get_chain_id().await.unwrap();
 /////////////// 
  
-    let message = SequenceRequestData{
+    let message = SequenceRequest{
         validator, 
         signer_address,
-        request_type: String::from("sequence_request")
+        // request_type: String::from("sequence_request")
     }; 
     // send req to client 
     client.send_str(sp_address, &serde_json::to_string(&message).unwrap()).await;
@@ -64,7 +74,7 @@ pub async fn offline_sign(mnemonic: bip39::Mnemonic, to: AccountId, client: &mut
         println!("{:#?}", i.message); 
     }
     // parse json of res to get signer_data and chain_id, store in SeqResData struct 
-
+ 
     todo!()
 
 /* 

demos/rust-cosmos-broadcaster-server/Cargo.toml

@@ -10,6 +10,7 @@ edition = "2021"
 clap = { version = "4.0", features = ["derive"] }
 nym-bin-common = { path = "../../common/bin-common"}
 nym-sphinx-addressing = { path = "../../common/nymsphinx/addressing" }
+nym-sphinx-anonymous-replies = { path = "../../common/nymsphinx/anonymous-replies" }
 nym-sdk = { path = "../../sdk/rust/nym-sdk" }
 nym-crypto = { path = "../../common/crypto" }
 nym-cli-commands = { path = "../../common/commands" }

demos/rust-cosmos-broadcaster-server/src/main.rs

@@ -4,6 +4,31 @@ use nym_bin_common::logging::setup_logging;
 use std::path::PathBuf;
 mod commands; 
 use serde::{Deserialize, Serialize};
+use cosmrs::rpc::{Id};
+use nym_sphinx_anonymous_replies::{self, requests::RepliableMessage}; 
+
+
+#[derive(Debug, Deserialize, Serialize)]
+struct SequenceRequest {
+    validator: String, 
+    signer_address: AccountId, 
+    // request_type: String
+}
+#[derive(Deserialize, Serialize)]
+struct SequenceResponse {
+    sequence_response: u8, 
+    chain_id: Id
+}
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(untagged)]
+enum RequestTypes {
+    Sequence(SequenceRequest), 
+    // Broadcast(BroadcastRequest)
+}
+enum ResponseTypes {
+    Sequence(SequenceResponse), 
+    // Broadcast(BroadcastResponse)
+}
 
 #[tokio::main]
 async fn main() {
@@ -21,13 +46,26 @@ async fn main() {
     let our_address = client.nym_address();
     println!("Our client nym address is: {our_address}");
 
-    println!("Waiting for message");
+    println!("\nWaiting for message");
     if let Some(received) = client.wait_for_messages().await {
          
-        for r in received {
-            let to_parse  = String::from_utf8_lossy(&r.message); 
-            println!("Received: {}", &to_parse);
-            let parsed = serde_json::from_str(&to_parse).unwrap();
+        for r in &received {
+            let s = String::from_utf8(r.message.clone()); 
+            if s.is_ok() {
+                let p = s.unwrap(); 
+                let request: RequestTypes = serde_json::from_str(&p).unwrap(); 
+                println!("incoming request: {:#?}", &request);
+                match request {
+                    RequestTypes::Sequence(SequenceRequest) => {
+                        println!("matched!")
+                        // TODO pass to commands::fn 
+                    }, 
+                    // RequestTypes::Broadcast(BroadcastRequest) // TODO 
+                    _ => {
+                        println!(" (x_x) ")
+                    }
+                } 
+            } 
 
             /*
             deserialise json