GRIN/nym
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

almost got surb reply..

Browse Source
This commit is contained in:
mfahampshire
2023-07-10 09:08:40 +02:00
parent 7f37c95599
commit bc565c494b
10 changed files with 172 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files
demos/rust-cosmos-broadcaster-client/src/commands/commands.rs
+1 -35
View File
@@ -2,7 +2,6 @@ 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::signing::direct_wallet::DirectSecp256k1HdWallet;
use nym_validator_client::signing::tx_signer::TxSigner;
use nym_validator_client::signing::SignerData;
@@ -14,29 +13,7 @@ use bip39;
use bs58;
use nym_sdk::mixnet::{self, MixnetClient};
use serde::{Deserialize, Serialize};
// use serde_json::Result;
#[derive(Deserialize, Serialize)]
struct SequenceRequest {
validator: String,
signer_address: AccountId,
// request_type: String
}
#[derive(Deserialize, Serialize)]
struct SequenceResponse {
sequence_response: u8,
chain_id: Id
}
enum RequestTypes {
Sequence(SequenceRequest),
// Broadcast(BroadcastRequest)
}
enum ResponseTypes {
Sequence(SequenceResponse),
// Broadcast(BroadcastResponse)
}
use crate::commands::reqres::SequenceRequest;
pub async fn offline_sign(mnemonic: bip39::Mnemonic, to: AccountId, client: &mut MixnetClient , sp_address: Recipient) -> String {
@@ -51,17 +28,6 @@ pub async fn offline_sign(mnemonic: bip39::Mnemonic, to: AccountId, client: &mut
// local 'client' ONLY signing messages
let tx_signer = TxSigner::new(signer);
/////////////// to go on server side
// possibly remote client that doesn't do ANY signing
// (only broadcasts + queries for sequence numbers)
// let broadcaster = HttpClient::new(validator).unwrap();
// // get sequence information and chain ID from the service
// // add sdk, send req for sequence
// // get signer information
// let sequence_response = broadcaster.get_sequence(&signer_address).await.unwrap();
// let chain_id = broadcaster.get_chain_id().await.unwrap();
///////////////
let message = SequenceRequest{
validator,
signer_address,
demos/rust-cosmos-broadcaster-client/src/commands/commands/reqres.rs
View File
demos/rust-cosmos-broadcaster-client/src/commands/mod.rs
+2 -1
View File
@@ -1 +1,2 @@
pub mod commands;
pub mod reqres;
pub mod commands;
demos/rust-cosmos-broadcaster-client/src/commands/reqres.rs
+40
View File
@@ -0,0 +1,40 @@
use cosmrs::rpc::{Id};
use serde::{Deserialize, Serialize};
use cosmrs::{AccountId};
#[derive(Deserialize, Serialize, Debug)]
pub struct SequenceRequest {
pub validator: String,
pub signer_address: AccountId,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct SequenceResponse {
pub sequence_response: u8,
pub chain_id: Id
}
#[derive(Deserialize, Serialize, Debug)]
pub struct BroadcastRequest {
pub base58_tx_bytes: String
}
#[derive(Deserialize, Serialize, Debug)]
pub struct BroadcastResponse{
pub tx_hash: String
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum RequestTypes {
Sequence(SequenceRequest),
Broadcast(BroadcastRequest)
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum ResponseTypes {
Sequence(SequenceResponse),
Broadcast(BroadcastResponse)
}
demos/rust-cosmos-broadcaster-client/src/main.rs
+3 -4
View File
@@ -1,7 +1,6 @@
use std::path::PathBuf;
use clap::{ Parser, Subcommand, Args};
use nym_sdk::mixnet::{Recipient, MixnetClient, MixnetClientBuilder, StoragePaths};
use nym_sdk::mixnet::{Recipient, MixnetClientBuilder, StoragePaths};
use nym_validator_client::nyxd::AccountId;
use nym_bin_common::logging::setup_logging;
mod commands;
@@ -53,9 +52,9 @@ async fn main() {
let cli = Cli::parse();
// TODO look @ arg env setup from NR main.rs
// TODO take from args
let sp_address = Recipient::try_from_base58_string("6RkSh3QZCBQaSsMjZFSdRgRYkgKkKErQTtZtCyffsaSu.5xLdj5scMH116KazYDBUPRs16oE3BZhEAko8rjynTCJ6@E3mvZTHQCdBvhfr178Swx9g4QG3kkRUun7YnToLMcMbM").unwrap();
let sp_address = Recipient::try_from_base58_string("58t3wcC14TYvhbq8ATpoQmf9jtJ44pYYU1oj9KKYokQu.BAR7nDgfJxSpatuXB97gqa1rvhfeTvHgVmPkJrvU8pz6@DfNMqQRy6pPkU8Z5rBsxRwzDUzAMXHPFwMhjF16ScZqn").unwrap();
let config_dir = PathBuf::from("/tmp/cosmos-broadcaster-mixnet-client");
let config_dir = PathBuf::from("/tmp/cosmos-broadcaster-mixnet-client-2");
let storage_paths = StoragePaths::new_from_dir(&config_dir).unwrap();
let client = MixnetClientBuilder::new_with_default_storage(storage_paths)
.await
demos/rust-cosmos-broadcaster-server/Cargo.toml
+1
View File
@@ -24,3 +24,4 @@ ts-rs = "6.1.2"
bs58 = "0.5.0"
serde = { workspace = true, features = ["derive"] }
serde_json = { workspace = true }
cosmwasm-std = { workspace = true, optional = true }
demos/rust-cosmos-broadcaster-server/src/commands/commands.rs
+47 -14
View File
@@ -1,21 +1,54 @@
/*
code for sequence and chain
// possibly remote client that doesn't do ANY signing
// (only broadcasts + queries for sequence numbers)
let broadcaster = HttpClient::new(validator).unwrap();
// 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::signing::direct_wallet::DirectSecp256k1HdWallet;
// use nym_validator_client::signing::tx_signer::TxSigner;
// use nym_validator_client::signing::SignerData;
// use cosmrs::bank::MsgSend;
use cosmrs::rpc::{HttpClient, Id, Client};
// use cosmrs::tx::Msg;
use cosmrs::{tx, AccountId, Coin, Denom};
// use bip39;
use bs58;
use nym_sdk::mixnet::{self, MixnetClient};
use serde::{Deserialize, Serialize};
use crate::commands::reqres::{SequenceRequest, SequenceRequestResponse};
pub async fn get_sequence(validator: String, signer_address: AccountId) -> SequenceRequestResponse {
/*
TODO create broadcaster in different fn and build on setup - pass to both fns as arg
*/
let broadcaster = HttpClient::new(validator.as_str()).unwrap();
// get signer information
let sequence_response = broadcaster.get_sequence(&signer_address).await.unwrap();
// TODO look @ how you can return SequenceResponse type from cosmwasm
let sequence = broadcaster.get_sequence(&signer_address).await.unwrap();
let chain_id = broadcaster.get_chain_id().await.unwrap();
-> pass back chain_id and sequence_response to client side
// todo!()
let res = SequenceRequestResponse { sequence: 9, chain_id: cosmrs::rpc::Id::Str(String::from("chain_id_placeholder")) };
res
}
pub async fn broadcast(base58_tx_bytes: String) -> String {
todo!();
/*
TODO create broadcaster in different fn and build on setup - pass to both fns as arg
*/
code for broadcast
// decode the base58 tx to vec<u8>
// let tx_bytes = bs58::decode(base58_tx_bytes);
// broadcast the tx
let res = rpc::Client::broadcast_tx_commit(&broadcaster, tx_bytes.into())
.await
.unwrap();
// // create instance of Transaction struct w tx_bytes - tx_to_broadcast
// send res back via SURBs
*/
// // broadcast the tx
// let res = Client::broadcast_tx_commit(&broadcaster, tx_to_broadcast)
// .await
// .unwrap();
// let placeholder = String::from("palceholder");
// placeholder
}
demos/rust-cosmos-broadcaster-server/src/commands/mod.rs
+2 -1
View File
@@ -1 +1,2 @@
pub mod commands;
pub mod reqres;
pub mod commands;
demos/rust-cosmos-broadcaster-server/src/commands/reqres.rs
+40
View File
@@ -0,0 +1,40 @@
use cosmrs::rpc::{HttpClient, Id};
use serde::{Deserialize, Serialize};
use cosmrs::{tx, AccountId, Coin, Denom};
use nym_validator_client::nyxd::cosmwasm_client::types::SequenceResponse;
#[derive(Deserialize, Serialize, Debug)]
pub struct SequenceRequest {
pub validator: String,
pub signer_address: AccountId,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct SequenceRequestResponse {
pub sequence: u8, // fix this - should be cosmwasmclient::SequenceResponse
pub chain_id: Id
}
#[derive(Deserialize, Serialize, Debug)]
pub struct BroadcastRequest {
pub base58_tx_bytes: String
}
#[derive(Deserialize, Serialize, Debug)]
pub struct BroadcastResponse{
pub tx_hash: String
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum RequestTypes {
Sequence(SequenceRequest),
Broadcast(BroadcastRequest)
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum ResponseTypes {
Sequence(SequenceRequestResponse),
Broadcast(BroadcastResponse)
}
demos/rust-cosmos-broadcaster-server/src/main.rs
+36 -66
View File
@@ -4,37 +4,16 @@ 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)
}
use cosmrs::{rpc::{Id}};
use nym_sphinx_anonymous_replies::{self, requests::RepliableMessage};
use crate::commands::reqres;
// pull in ::reply::{MixnetAddress, MixnetMessage}
#[tokio::main]
async fn main() {
setup_logging();
let config_dir = PathBuf::from("/tmp/cosmos-broadcaster-mixnet-server");
// TODO put client creation in own fn
let config_dir = PathBuf::from("/tmp/cosmos-broadcaster-mixnet-server-2");
let storage_paths = StoragePaths::new_from_dir(&config_dir).unwrap();
let client = MixnetClientBuilder::new_with_default_storage(storage_paths)
.await
@@ -44,61 +23,52 @@ async fn main() {
.unwrap();
let mut client = client.connect_to_mixnet().await.unwrap();
let our_address = client.nym_address();
println!("Our client nym address is: {our_address}");
println!("\nOur client nym address is: {our_address}");
/*
TODO
* make process just wait for another message instead of end after single match()
* add threads!
*/
println!("\nWaiting for message");
if let Some(received) = client.wait_for_messages().await {
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();
let request: reqres::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) ")
}
reqres::RequestTypes::Sequence(request) => {
println!("\nincoming sequence request details:\nvalidator: {},\nsigner address: {}\n", request.validator, request.signer_address);
let sequence: reqres::SequenceRequestResponse = commands::commands::get_sequence(request.validator, request.signer_address).await;
print!("debug print -------- {:#?}", sequence);
// send back to sender via SURBS...
// TODO how to properly parse to AnonymousSenderTag?
// TODO make a rust sdk example of replying via SURBs
println!("debug print SENDER TAG --------- {:#?}", r.sender_tag);
if Some(r.sender_tag).is_some() {
// TODO construct reply
let return_recipient = MixnetAddress::from(r.sender_tag);
// send back thru mixnet
client.send_str(return_recipient, &serde_json::to_string(&sequence).unwrap()).await;
} else {
// // TODO replace with actual error type to return
println!("no surbs cannot reply an0n")
}
},
reqres::RequestTypes::Broadcast(BroadcastRequest) => {
todo!()
}
}
}
/*
deserialise json
check fn struct match
match{} and pass to function
*/
}
}
// TODO V2 - multithreading!
client.disconnect().await;
}
/*
code for sequence and chain
// possibly remote client that doesn't do ANY signing
// (only broadcasts + queries for sequence numbers)
let broadcaster = HttpClient::new(validator).unwrap();
// get signer information
let sequence_response = broadcaster.get_sequence(&signer_address).await.unwrap();
let chain_id = broadcaster.get_chain_id().await.unwrap();
-> pass back chain_id and sequence_response to client side
code for broadcast
// decode the base58 tx to vec<u8>
// broadcast the tx
let res = rpc::Client::broadcast_tx_commit(&broadcaster, tx_bytes.into())
.await
.unwrap();
// send res back via SURBs
*/