From c39c9ad4ca4145a434ce9b42caed2b88dd7aebf6 Mon Sep 17 00:00:00 2001 From: Oleksandr Pravdyvyi Date: Tue, 14 Oct 2025 15:29:18 +0300 Subject: [PATCH 01/17] feat: cli refactor --- integration_tests/src/lib.rs | 303 ++++++---- wallet/src/cli/chain.rs | 253 ++++++++ wallet/src/cli/mod.rs | 3 + .../src/cli/native_token_transfer_program.rs | 342 +++++++++++ wallet/src/cli/pinata_program.rs | 157 +++++ wallet/src/lib.rs | 552 +----------------- 6 files changed, 966 insertions(+), 644 deletions(-) create mode 100644 wallet/src/cli/chain.rs create mode 100644 wallet/src/cli/native_token_transfer_program.rs create mode 100644 wallet/src/cli/pinata_program.rs diff --git a/integration_tests/src/lib.rs b/integration_tests/src/lib.rs index abe1c76..a560e9f 100644 --- a/integration_tests/src/lib.rs +++ b/integration_tests/src/lib.rs @@ -19,8 +19,18 @@ use tempfile::TempDir; use tokio::task::JoinHandle; use wallet::{ Command, SubcommandReturnValue, WalletCore, - cli::token_program::{ - TokenProgramSubcommand, TokenProgramSubcommandPrivate, TokenProgramSubcommandPublic, + cli::{ + chain::{ChainSubcommand, FetchSubcommand, RegisterSubcommand}, + native_token_transfer_program::{ + NativeTokenTransferProgramSubcommand, NativeTokenTransferProgramSubcommandPrivate, + NativeTokenTransferProgramSubcommandShielded, + }, + pinata_program::{ + PinataProgramSubcommand, PinataProgramSubcommandPrivate, PinataProgramSubcommandPublic, + }, + token_program::{ + TokenProgramSubcommand, TokenProgramSubcommandPrivate, TokenProgramSubcommandPublic, + }, }, config::PersistentAccountData, helperfunctions::{fetch_config, fetch_persistent_accounts}, @@ -100,11 +110,13 @@ pub async fn post_test(residual: (ServerHandle, JoinHandle>, TempDir) pub async fn test_success() { info!("test_success"); - let command = Command::SendNativeTokenTransferPublic { - from: ACC_SENDER.to_string(), - to: ACC_RECEIVER.to_string(), - amount: 100, - }; + let command = Command::Transfer( + NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { + from: ACC_SENDER.to_string(), + to: ACC_RECEIVER.to_string(), + amount: 100, + }, + ); let wallet_config = fetch_config().unwrap(); @@ -136,7 +148,9 @@ pub async fn test_success() { pub async fn test_success_move_to_another_account() { info!("test_success_move_to_another_account"); - let command = Command::RegisterAccountPublic {}; + let command = Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPublic {}, + )); let wallet_config = fetch_config().unwrap(); @@ -160,11 +174,13 @@ pub async fn test_success_move_to_another_account() { panic!("Failed to produce new account, not present in persistent accounts"); } - let command = Command::SendNativeTokenTransferPublic { - from: ACC_SENDER.to_string(), - to: new_persistent_account_addr.clone(), - amount: 100, - }; + let command = Command::Transfer( + NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { + from: ACC_SENDER.to_string(), + to: new_persistent_account_addr.clone(), + amount: 100, + }, + ); wallet::execute_subcommand(command).await.unwrap(); @@ -192,11 +208,13 @@ pub async fn test_success_move_to_another_account() { pub async fn test_failure() { info!("test_failure"); - let command = Command::SendNativeTokenTransferPublic { - from: ACC_SENDER.to_string(), - to: ACC_RECEIVER.to_string(), - amount: 1000000, - }; + let command = Command::Transfer( + NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { + from: ACC_SENDER.to_string(), + to: ACC_RECEIVER.to_string(), + amount: 1000000, + }, + ); let wallet_config = fetch_config().unwrap(); @@ -230,11 +248,13 @@ pub async fn test_failure() { pub async fn test_success_two_transactions() { info!("test_success_two_transactions"); - let command = Command::SendNativeTokenTransferPublic { - from: ACC_SENDER.to_string(), - to: ACC_RECEIVER.to_string(), - amount: 100, - }; + let command = Command::Transfer( + NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { + from: ACC_SENDER.to_string(), + to: ACC_RECEIVER.to_string(), + amount: 100, + }, + ); let wallet_config = fetch_config().unwrap(); @@ -263,11 +283,13 @@ pub async fn test_success_two_transactions() { info!("First TX Success!"); - let command = Command::SendNativeTokenTransferPublic { - from: ACC_SENDER.to_string(), - to: ACC_RECEIVER.to_string(), - amount: 100, - }; + let command = Command::Transfer( + NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { + from: ACC_SENDER.to_string(), + to: ACC_RECEIVER.to_string(), + amount: 100, + }, + ); wallet::execute_subcommand(command).await.unwrap(); @@ -319,17 +341,23 @@ pub async fn test_success_token_program() { let wallet_config = fetch_config().unwrap(); // Create new account for the token definition - wallet::execute_subcommand(Command::RegisterAccountPublic {}) - .await - .unwrap(); + wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPublic {}, + ))) + .await + .unwrap(); // Create new account for the token supply holder - wallet::execute_subcommand(Command::RegisterAccountPublic {}) - .await - .unwrap(); + wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPublic {}, + ))) + .await + .unwrap(); // Create new account for receiving a token transaction - wallet::execute_subcommand(Command::RegisterAccountPublic {}) - .await - .unwrap(); + wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPublic {}, + ))) + .await + .unwrap(); let persistent_accounts = fetch_persistent_accounts().unwrap(); @@ -462,26 +490,32 @@ pub async fn test_success_token_program_private_owned() { // Create new account for the token definition (public) let SubcommandReturnValue::RegisterAccount { addr: definition_addr, - } = wallet::execute_subcommand(Command::RegisterAccountPublic {}) - .await - .unwrap() + } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPublic {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for the token supply holder (private) let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = - wallet::execute_subcommand(Command::RegisterAccountPrivate {}) - .await - .unwrap() + wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPrivate {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for receiving a token transaction let SubcommandReturnValue::RegisterAccount { addr: recipient_addr, - } = wallet::execute_subcommand(Command::RegisterAccountPrivate {}) - .await - .unwrap() + } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPrivate {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; @@ -595,26 +629,32 @@ pub async fn test_success_token_program_private_claiming_path() { // Create new account for the token definition (public) let SubcommandReturnValue::RegisterAccount { addr: definition_addr, - } = wallet::execute_subcommand(Command::RegisterAccountPublic {}) - .await - .unwrap() + } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPublic {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for the token supply holder (private) let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = - wallet::execute_subcommand(Command::RegisterAccountPrivate {}) - .await - .unwrap() + wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPrivate {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for receiving a token transaction let SubcommandReturnValue::RegisterAccount { addr: recipient_addr, - } = wallet::execute_subcommand(Command::RegisterAccountPrivate {}) - .await - .unwrap() + } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPrivate {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; @@ -690,11 +730,13 @@ pub async fn test_success_token_program_private_claiming_path() { info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let command = Command::FetchPrivateAccount { - tx_hash, - acc_addr: recipient_addr.to_string(), - output_id: 1, - }; + let command = Command::Chain(ChainSubcommand::Fetch( + FetchSubcommand::FetchPrivateAccount { + tx_hash, + acc_addr: recipient_addr.to_string(), + output_id: 1, + }, + )); wallet::execute_subcommand(command).await.unwrap(); @@ -717,11 +759,13 @@ pub async fn test_success_private_transfer_to_another_owned_account() { let from: Address = ACC_SENDER_PRIVATE.parse().unwrap(); let to: Address = ACC_RECEIVER_PRIVATE.parse().unwrap(); - let command = Command::SendNativeTokenTransferPrivateOwnedAccount { - from: from.to_string(), - to: to.to_string(), - amount: 100, - }; + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Private( + NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateOwnedAccount { + from: from.to_string(), + to: to.to_string(), + amount: 100, + }, + )); wallet::execute_subcommand(command).await.unwrap(); @@ -750,12 +794,14 @@ pub async fn test_success_private_transfer_to_another_foreign_account() { let to_npk_string = hex::encode(to_npk.0); let to_ipk = Secp256k1Point::from_scalar(to_npk.0); - let command = Command::SendNativeTokenTransferPrivateForeignAccount { - from: from.to_string(), - to_npk: to_npk_string, - to_ipk: hex::encode(to_ipk.0), - amount: 100, - }; + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Private( + NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateForeignAccount { + from: from.to_string(), + to_npk: to_npk_string, + to_ipk: hex::encode(to_ipk.0), + amount: 100, + }, + )); let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } = wallet::execute_subcommand(command).await.unwrap() @@ -789,7 +835,9 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat info!("test_success_private_transfer_to_another_owned_account_claiming_path"); let from: Address = ACC_SENDER_PRIVATE.parse().unwrap(); - let command = Command::RegisterAccountPrivate {}; + let command = Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPrivate {}, + )); let sub_ret = wallet::execute_subcommand(command).await.unwrap(); let SubcommandReturnValue::RegisterAccount { addr: to_addr } = sub_ret else { @@ -808,12 +856,14 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat .cloned() .unwrap(); - let command = Command::SendNativeTokenTransferPrivateForeignAccount { - from: from.to_string(), - to_npk: hex::encode(to_keys.nullifer_public_key.0), - to_ipk: hex::encode(to_keys.incoming_viewing_public_key.0), - amount: 100, - }; + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Private( + NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateForeignAccount { + from: from.to_string(), + to_npk: hex::encode(to_keys.nullifer_public_key.0), + to_ipk: hex::encode(to_keys.incoming_viewing_public_key.0), + amount: 100, + }, + )); let sub_ret = wallet::execute_subcommand(command).await.unwrap(); let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } = sub_ret else { @@ -822,11 +872,13 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat let tx = fetch_privacy_preserving_tx(&seq_client, tx_hash.clone()).await; - let command = Command::FetchPrivateAccount { - tx_hash, - acc_addr: to_addr.to_string(), - output_id: 1, - }; + let command = Command::Chain(ChainSubcommand::Fetch( + FetchSubcommand::FetchPrivateAccount { + tx_hash, + acc_addr: to_addr.to_string(), + output_id: 1, + }, + )); wallet::execute_subcommand(command).await.unwrap(); let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); @@ -851,11 +903,13 @@ pub async fn test_success_deshielded_transfer_to_another_account() { info!("test_success_deshielded_transfer_to_another_account"); let from: Address = ACC_SENDER_PRIVATE.parse().unwrap(); let to: Address = ACC_RECEIVER.parse().unwrap(); - let command = Command::SendNativeTokenTransferDeshielded { - from: from.to_string(), - to: to.to_string(), - amount: 100, - }; + let command = Command::Transfer( + NativeTokenTransferProgramSubcommand::SendNativeTokenTransferDeshielded { + from: from.to_string(), + to: to.to_string(), + amount: 100, + }, + ); let wallet_config = fetch_config().unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); @@ -892,11 +946,13 @@ pub async fn test_success_shielded_transfer_to_another_owned_account() { info!("test_success_shielded_transfer_to_another_owned_account"); let from: Address = ACC_SENDER.parse().unwrap(); let to: Address = ACC_RECEIVER_PRIVATE.parse().unwrap(); - let command = Command::SendNativeTokenTransferShielded { - from: from.to_string(), - to: to.to_string(), - amount: 100, - }; + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Shielded( + NativeTokenTransferProgramSubcommandShielded::SendNativeTokenTransferShielded { + from: from.to_string(), + to: to.to_string(), + amount: 100, + }, + )); let wallet_config = fetch_config().unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); @@ -931,12 +987,13 @@ pub async fn test_success_shielded_transfer_to_another_foreign_account() { let to_ipk = Secp256k1Point::from_scalar(to_npk.0); let from: Address = ACC_SENDER.parse().unwrap(); - let command = Command::SendNativeTokenTransferShieldedForeignAccount { + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Shielded( + NativeTokenTransferProgramSubcommandShielded::SendNativeTokenTransferShieldedForeignAccount { from: from.to_string(), to_npk: to_npk_string, to_ipk: hex::encode(to_ipk.0), amount: 100, - }; + })); let wallet_config = fetch_config().unwrap(); @@ -972,11 +1029,13 @@ pub async fn test_pinata() { let pinata_addr = "cafe".repeat(16); let pinata_prize = 150; let solution = 989106; - let command = Command::ClaimPinata { - pinata_addr: pinata_addr.clone(), - winner_addr: ACC_SENDER.to_string(), - solution, - }; + let command = Command::PinataProgram(PinataProgramSubcommand::Public( + PinataProgramSubcommandPublic::ClaimPinata { + pinata_addr: pinata_addr.clone(), + winner_addr: ACC_SENDER.to_string(), + solution, + }, + )); let wallet_config = fetch_config().unwrap(); @@ -1018,11 +1077,13 @@ pub async fn test_pinata_private_receiver() { let pinata_prize = 150; let solution = 989106; - let command = Command::ClaimPinataPrivateReceiverOwned { - pinata_addr: pinata_addr.clone(), - winner_addr: ACC_SENDER_PRIVATE.to_string(), - solution, - }; + let command = Command::PinataProgram(PinataProgramSubcommand::Private( + PinataProgramSubcommandPrivate::ClaimPinataPrivateReceiverOwned { + pinata_addr: pinata_addr.clone(), + winner_addr: ACC_SENDER_PRIVATE.to_string(), + solution, + }, + )); let wallet_config = fetch_config().unwrap(); @@ -1050,11 +1111,13 @@ pub async fn test_pinata_private_receiver() { .unwrap() .balance; - let command = Command::FetchPrivateAccount { - tx_hash: tx_hash.clone(), - acc_addr: ACC_SENDER_PRIVATE.to_string(), - output_id: 0, - }; + let command = Command::Chain(ChainSubcommand::Fetch( + FetchSubcommand::FetchPrivateAccount { + tx_hash: tx_hash.clone(), + acc_addr: ACC_SENDER_PRIVATE.to_string(), + output_id: 0, + }, + )); wallet::execute_subcommand(command).await.unwrap(); let wallet_config = fetch_config().unwrap(); @@ -1079,18 +1142,22 @@ pub async fn test_pinata_private_receiver_new_account() { // Create new account for the token supply holder (private) let SubcommandReturnValue::RegisterAccount { addr: winner_addr } = - wallet::execute_subcommand(Command::RegisterAccountPrivate {}) - .await - .unwrap() + wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPrivate {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; - let command = Command::ClaimPinataPrivateReceiverOwned { - pinata_addr: pinata_addr.clone(), - winner_addr: winner_addr.to_string(), - solution, - }; + let command = Command::PinataProgram(PinataProgramSubcommand::Private( + PinataProgramSubcommandPrivate::ClaimPinataPrivateReceiverOwned { + pinata_addr: pinata_addr.clone(), + winner_addr: winner_addr.to_string(), + solution, + }, + )); let wallet_config = fetch_config().unwrap(); diff --git a/wallet/src/cli/chain.rs b/wallet/src/cli/chain.rs new file mode 100644 index 0000000..ad58301 --- /dev/null +++ b/wallet/src/cli/chain.rs @@ -0,0 +1,253 @@ +use std::str::FromStr; + +use anyhow::Result; +use clap::Subcommand; +use common::transaction::NSSATransaction; +use nssa::Address; + +use crate::{ + SubcommandReturnValue, WalletCore, cli::WalletSubcommand, helperfunctions::HumanReadableAccount, +}; + +///Represents generic chain CLI subcommand +#[derive(Subcommand, Debug, Clone)] +pub enum ChainSubcommand { + ///Get + #[command(subcommand)] + Get(GetSubcommand), + ///Fetch + #[command(subcommand)] + Fetch(FetchSubcommand), + ///Register + #[command(subcommand)] + Register(RegisterSubcommand), +} + +///Represents generic getter CLI subcommand +#[derive(Subcommand, Debug, Clone)] +pub enum GetSubcommand { + ///Get account `addr` balance + GetPublicAccountBalance { + #[arg(short, long)] + addr: String, + }, + ///Get account `addr` nonce + GetPublicAccountNonce { + #[arg(short, long)] + addr: String, + }, + ///Get account at address `addr` + GetPublicAccount { + #[arg(short, long)] + addr: String, + }, + ///Get private account with `addr` from storage + GetPrivateAccount { + #[arg(short, long)] + addr: String, + }, +} + +///Represents generic getter CLI subcommand +#[derive(Subcommand, Debug, Clone)] +pub enum FetchSubcommand { + ///Fetch transaction by `hash` + FetchTx { + #[arg(short, long)] + tx_hash: String, + }, + ///Claim account `acc_addr` generated in transaction `tx_hash`, using secret `sh_secret` at ciphertext id `ciph_id` + FetchPrivateAccount { + ///tx_hash - valid 32 byte hex string + #[arg(long)] + tx_hash: String, + ///acc_addr - valid 32 byte hex string + #[arg(long)] + acc_addr: String, + ///output_id - id of the output in the transaction + #[arg(long)] + output_id: usize, + }, +} + +///Represents generic register CLI subcommand +#[derive(Subcommand, Debug, Clone)] +pub enum RegisterSubcommand { + ///Register new public account + RegisterAccountPublic {}, + ///Register new private account + RegisterAccountPrivate {}, +} + +impl WalletSubcommand for GetSubcommand { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + GetSubcommand::GetPublicAccountBalance { addr } => { + let addr = Address::from_str(&addr)?; + + let balance = wallet_core.get_account_balance(addr).await?; + println!("Accounts {addr} balance is {balance}"); + + Ok(SubcommandReturnValue::Empty) + } + GetSubcommand::GetPublicAccountNonce { addr } => { + let addr = Address::from_str(&addr)?; + + let nonce = wallet_core.get_accounts_nonces(vec![addr]).await?[0]; + println!("Accounts {addr} nonce is {nonce}"); + + Ok(SubcommandReturnValue::Empty) + } + GetSubcommand::GetPublicAccount { addr } => { + let addr: Address = addr.parse()?; + let account = wallet_core.get_account_public(addr).await?; + let account_hr: HumanReadableAccount = account.clone().into(); + println!("{}", serde_json::to_string(&account_hr).unwrap()); + + Ok(SubcommandReturnValue::Account(account)) + } + GetSubcommand::GetPrivateAccount { addr } => { + let addr: Address = addr.parse()?; + if let Some(account) = wallet_core.get_account_private(&addr) { + println!("{}", serde_json::to_string(&account).unwrap()); + } else { + println!("Private account not found."); + } + Ok(SubcommandReturnValue::Empty) + } + } + } +} + +impl WalletSubcommand for FetchSubcommand { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + FetchSubcommand::FetchTx { tx_hash } => { + let tx_obj = wallet_core + .sequencer_client + .get_transaction_by_hash(tx_hash) + .await?; + + println!("Transaction object {tx_obj:#?}"); + + Ok(SubcommandReturnValue::Empty) + } + FetchSubcommand::FetchPrivateAccount { + tx_hash, + acc_addr, + output_id: ciph_id, + } => { + let acc_addr: Address = acc_addr.parse().unwrap(); + + let account_key_chain = wallet_core + .storage + .user_data + .user_private_accounts + .get(&acc_addr); + + let Some((account_key_chain, _)) = account_key_chain else { + anyhow::bail!("Account not found"); + }; + + let transfer_tx = wallet_core.poll_native_token_transfer(tx_hash).await?; + + if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { + let to_ebc = tx.message.encrypted_private_post_states[ciph_id].clone(); + let to_comm = tx.message.new_commitments[ciph_id].clone(); + let shared_secret = + account_key_chain.calculate_shared_secret_receiver(to_ebc.epk); + + let res_acc_to = nssa_core::EncryptionScheme::decrypt( + &to_ebc.ciphertext, + &shared_secret, + &to_comm, + ciph_id as u32, + ) + .unwrap(); + + println!("RES acc to {res_acc_to:#?}"); + + println!("Transaction data is {:?}", tx.message); + + wallet_core + .storage + .insert_private_account_data(acc_addr, res_acc_to); + } + + let path = wallet_core.store_persistent_accounts()?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::Empty) + } + } + } +} + +impl WalletSubcommand for RegisterSubcommand { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + RegisterSubcommand::RegisterAccountPublic {} => { + let addr = wallet_core.create_new_account_public(); + + println!("Generated new account with addr {addr}"); + + let path = wallet_core.store_persistent_accounts()?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::RegisterAccount { addr }) + } + RegisterSubcommand::RegisterAccountPrivate {} => { + let addr = wallet_core.create_new_account_private(); + + let (key, _) = wallet_core + .storage + .user_data + .get_private_account(&addr) + .unwrap(); + + println!("Generated new account with addr {addr}"); + println!("With npk {}", hex::encode(&key.nullifer_public_key)); + println!( + "With ipk {}", + hex::encode(key.incoming_viewing_public_key.to_bytes()) + ); + + let path = wallet_core.store_persistent_accounts()?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::RegisterAccount { addr }) + } + } + } +} + +impl WalletSubcommand for ChainSubcommand { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + ChainSubcommand::Get(get_subcommand) => { + get_subcommand.handle_subcommand(wallet_core).await + } + ChainSubcommand::Fetch(fetch_subcommand) => { + fetch_subcommand.handle_subcommand(wallet_core).await + } + ChainSubcommand::Register(register_subcommand) => { + register_subcommand.handle_subcommand(wallet_core).await + } + } + } +} diff --git a/wallet/src/cli/mod.rs b/wallet/src/cli/mod.rs index 5b277e0..093a501 100644 --- a/wallet/src/cli/mod.rs +++ b/wallet/src/cli/mod.rs @@ -2,6 +2,9 @@ use anyhow::Result; use crate::{SubcommandReturnValue, WalletCore}; +pub mod chain; +pub mod native_token_transfer_program; +pub mod pinata_program; pub mod token_program; pub(crate) trait WalletSubcommand { diff --git a/wallet/src/cli/native_token_transfer_program.rs b/wallet/src/cli/native_token_transfer_program.rs new file mode 100644 index 0000000..355c7f3 --- /dev/null +++ b/wallet/src/cli/native_token_transfer_program.rs @@ -0,0 +1,342 @@ +use anyhow::Result; +use clap::Subcommand; +use common::transaction::NSSATransaction; +use nssa::Address; + +use crate::{SubcommandReturnValue, WalletCore, cli::WalletSubcommand}; + +///Represents generic CLI subcommand for a wallet working with native token transfer program +#[derive(Subcommand, Debug, Clone)] +pub enum NativeTokenTransferProgramSubcommand { + ///Send native token transfer from `from` to `to` for `amount` + /// + /// Public operation + SendNativeTokenTransferPublic { + ///from - valid 32 byte hex string + #[arg(long)] + from: String, + ///to - valid 32 byte hex string + #[arg(long)] + to: String, + ///amount - amount of balance to move + #[arg(long)] + amount: u128, + }, + ///Private execution + #[command(subcommand)] + Private(NativeTokenTransferProgramSubcommandPrivate), + ///Send native token transfer from `from` to `to` for `amount` + /// + /// Deshielded operation + SendNativeTokenTransferDeshielded { + ///from - valid 32 byte hex string + #[arg(long)] + from: String, + ///to - valid 32 byte hex string + #[arg(long)] + to: String, + ///amount - amount of balance to move + #[arg(long)] + amount: u128, + }, + ///Shielded execution + #[command(subcommand)] + Shielded(NativeTokenTransferProgramSubcommandShielded), +} + +///Represents generic shielded CLI subcommand for a wallet working with native token transfer program +#[derive(Subcommand, Debug, Clone)] +pub enum NativeTokenTransferProgramSubcommandShielded { + ///Send native token transfer from `from` to `to` for `amount` + /// + /// Shielded operation + SendNativeTokenTransferShielded { + ///from - valid 32 byte hex string + #[arg(long)] + from: String, + ///to - valid 32 byte hex string + #[arg(long)] + to: String, + ///amount - amount of balance to move + #[arg(long)] + amount: u128, + }, + ///Send native token transfer from `from` to `to` for `amount` + /// + /// Shielded operation + SendNativeTokenTransferShieldedForeignAccount { + ///from - valid 32 byte hex string + #[arg(long)] + from: String, + ///to_npk - valid 32 byte hex string + #[arg(long)] + to_npk: String, + ///to_ipk - valid 33 byte hex string + #[arg(long)] + to_ipk: String, + ///amount - amount of balance to move + #[arg(long)] + amount: u128, + }, +} + +///Represents generic private CLI subcommand for a wallet working with native token transfer program +#[derive(Subcommand, Debug, Clone)] +pub enum NativeTokenTransferProgramSubcommandPrivate { + ///Send native token transfer from `from` to `to` for `amount` + /// + /// Private operation + SendNativeTokenTransferPrivateOwnedAccount { + ///from - valid 32 byte hex string + #[arg(long)] + from: String, + ///to - valid 32 byte hex string + #[arg(long)] + to: String, + ///amount - amount of balance to move + #[arg(long)] + amount: u128, + }, + ///Send native token transfer from `from` to `to` for `amount` + /// + /// Private operation + SendNativeTokenTransferPrivateForeignAccount { + ///from - valid 32 byte hex string + #[arg(long)] + from: String, + ///to_npk - valid 32 byte hex string + #[arg(long)] + to_npk: String, + ///to_ipk - valid 33 byte hex string + #[arg(long)] + to_ipk: String, + ///amount - amount of balance to move + #[arg(long)] + amount: u128, + }, +} + +impl WalletSubcommand for NativeTokenTransferProgramSubcommandPrivate { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateOwnedAccount { from, to, amount } => { + let from: Address = from.parse().unwrap(); + let to: Address = to.parse().unwrap(); + + let (res, [secret_from, secret_to]) = wallet_core + .send_private_native_token_transfer_owned_account(from, to, amount) + .await?; + + println!("Results of tx send is {res:#?}"); + + let tx_hash = res.tx_hash; + let transfer_tx = wallet_core + .poll_native_token_transfer(tx_hash.clone()) + .await?; + + if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { + let acc_decode_data = vec![(secret_from, from), (secret_to, to)]; + + wallet_core + .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; + } + + let path = wallet_core.store_persistent_accounts()?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) + } + NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateForeignAccount { + from, + to_npk, + to_ipk, + amount, + } => { + let from: Address = from.parse().unwrap(); + let to_npk_res = hex::decode(to_npk)?; + let mut to_npk = [0; 32]; + to_npk.copy_from_slice(&to_npk_res); + let to_npk = nssa_core::NullifierPublicKey(to_npk); + + let to_ipk_res = hex::decode(to_ipk)?; + let mut to_ipk = [0u8; 33]; + to_ipk.copy_from_slice(&to_ipk_res); + let to_ipk = + nssa_core::encryption::shared_key_derivation::Secp256k1Point(to_ipk.to_vec()); + + let (res, [secret_from, _]) = wallet_core + .send_private_native_token_transfer_outer_account(from, to_npk, to_ipk, amount) + .await?; + + println!("Results of tx send is {res:#?}"); + + let tx_hash = res.tx_hash; + let transfer_tx = wallet_core + .poll_native_token_transfer(tx_hash.clone()) + .await?; + + if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { + let acc_decode_data = vec![(secret_from, from)]; + + wallet_core + .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; + } + + let path = wallet_core.store_persistent_accounts()?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) + } + } + } +} + +impl WalletSubcommand for NativeTokenTransferProgramSubcommandShielded { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + NativeTokenTransferProgramSubcommandShielded::SendNativeTokenTransferShielded { from, to, amount } => { + let from: Address = from.parse().unwrap(); + let to: Address = to.parse().unwrap(); + + let (res, secret) = wallet_core + .send_shielded_native_token_transfer(from, to, amount) + .await?; + + println!("Results of tx send is {res:#?}"); + + let tx_hash = res.tx_hash; + let transfer_tx = wallet_core + .poll_native_token_transfer(tx_hash.clone()) + .await?; + + if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { + let acc_decode_data = vec![(secret, to)]; + + wallet_core + .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; + } + + let path = wallet_core.store_persistent_accounts()?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) + } + NativeTokenTransferProgramSubcommandShielded::SendNativeTokenTransferShieldedForeignAccount { + from, + to_npk, + to_ipk, + amount, + } => { + let from: Address = from.parse().unwrap(); + + let to_npk_res = hex::decode(to_npk)?; + let mut to_npk = [0; 32]; + to_npk.copy_from_slice(&to_npk_res); + let to_npk = nssa_core::NullifierPublicKey(to_npk); + + let to_ipk_res = hex::decode(to_ipk)?; + let mut to_ipk = [0u8; 33]; + to_ipk.copy_from_slice(&to_ipk_res); + let to_ipk = + nssa_core::encryption::shared_key_derivation::Secp256k1Point(to_ipk.to_vec()); + + let (res, _) = wallet_core + .send_shielded_native_token_transfer_outer_account(from, to_npk, to_ipk, amount) + .await?; + + println!("Results of tx send is {res:#?}"); + + let tx_hash = res.tx_hash; + + let path = wallet_core.store_persistent_accounts()?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) + } + } + } +} + +impl WalletSubcommand for NativeTokenTransferProgramSubcommand { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + NativeTokenTransferProgramSubcommand::Private(private_subcommand) => { + private_subcommand.handle_subcommand(wallet_core).await + } + NativeTokenTransferProgramSubcommand::Shielded(shielded_subcommand) => { + shielded_subcommand.handle_subcommand(wallet_core).await + } + NativeTokenTransferProgramSubcommand::SendNativeTokenTransferDeshielded { + from, + to, + amount, + } => { + let from: Address = from.parse().unwrap(); + let to: Address = to.parse().unwrap(); + + let (res, secret) = wallet_core + .send_deshielded_native_token_transfer(from, to, amount) + .await?; + + println!("Results of tx send is {res:#?}"); + + let tx_hash = res.tx_hash; + let transfer_tx = wallet_core + .poll_native_token_transfer(tx_hash.clone()) + .await?; + + if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { + let acc_decode_data = vec![(secret, from)]; + + wallet_core.decode_insert_privacy_preserving_transaction_results( + tx, + &acc_decode_data, + )?; + } + + let path = wallet_core.store_persistent_accounts()?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) + } + NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { + from, + to, + amount, + } => { + let from: Address = from.parse().unwrap(); + let to: Address = to.parse().unwrap(); + + let res = wallet_core + .send_public_native_token_transfer(from, to, amount) + .await?; + + println!("Results of tx send is {res:#?}"); + + let transfer_tx = wallet_core.poll_native_token_transfer(res.tx_hash).await?; + + println!("Transaction data is {transfer_tx:?}"); + + let path = wallet_core.store_persistent_accounts()?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::Empty) + } + } + } +} diff --git a/wallet/src/cli/pinata_program.rs b/wallet/src/cli/pinata_program.rs new file mode 100644 index 0000000..2a001b8 --- /dev/null +++ b/wallet/src/cli/pinata_program.rs @@ -0,0 +1,157 @@ +use anyhow::Result; +use clap::Subcommand; +use common::transaction::NSSATransaction; +use log::info; + +use crate::{SubcommandReturnValue, WalletCore, cli::WalletSubcommand}; + +///Represents generic CLI subcommand for a wallet working with pinata program +#[derive(Subcommand, Debug, Clone)] +pub enum PinataProgramSubcommand { + ///Public execution + #[command(subcommand)] + Public(PinataProgramSubcommandPublic), + ///Private execution + #[command(subcommand)] + Private(PinataProgramSubcommandPrivate), +} + +///Represents generic public CLI subcommand for a wallet working with pinata program +#[derive(Subcommand, Debug, Clone)] +pub enum PinataProgramSubcommandPublic { + // TODO: Testnet only. Refactor to prevent compilation on mainnet. + // Claim piñata prize + ClaimPinata { + ///pinata_addr - valid 32 byte hex string + #[arg(long)] + pinata_addr: String, + ///winner_addr - valid 32 byte hex string + #[arg(long)] + winner_addr: String, + ///solution - solution to pinata challenge + #[arg(long)] + solution: u128, + }, +} + +///Represents generic private CLI subcommand for a wallet working with pinata program +#[derive(Subcommand, Debug, Clone)] +pub enum PinataProgramSubcommandPrivate { + // TODO: Testnet only. Refactor to prevent compilation on mainnet. + // Claim piñata prize + ClaimPinataPrivateReceiverOwned { + ///pinata_addr - valid 32 byte hex string + #[arg(long)] + pinata_addr: String, + ///winner_addr - valid 32 byte hex string + #[arg(long)] + winner_addr: String, + ///solution - solution to pinata challenge + #[arg(long)] + solution: u128, + }, +} + +impl WalletSubcommand for PinataProgramSubcommandPublic { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + PinataProgramSubcommandPublic::ClaimPinata { + pinata_addr, + winner_addr, + solution, + } => { + let res = wallet_core + .claim_pinata( + pinata_addr.parse().unwrap(), + winner_addr.parse().unwrap(), + solution, + ) + .await?; + info!("Results of tx send is {res:#?}"); + + Ok(SubcommandReturnValue::Empty) + } + } + } +} + +impl WalletSubcommand for PinataProgramSubcommandPrivate { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + PinataProgramSubcommandPrivate::ClaimPinataPrivateReceiverOwned { + pinata_addr, + winner_addr, + solution, + } => { + let pinata_addr = pinata_addr.parse().unwrap(); + let winner_addr = winner_addr.parse().unwrap(); + + let winner_intialized = wallet_core + .check_private_account_initialized(&winner_addr) + .await; + + let (res, [secret_winner]) = if winner_intialized { + wallet_core + .claim_pinata_private_owned_account_already_initialized( + pinata_addr, + winner_addr, + solution, + ) + .await? + } else { + wallet_core + .claim_pinata_private_owned_account_not_initialized( + pinata_addr, + winner_addr, + solution, + ) + .await? + }; + + info!("Results of tx send is {res:#?}"); + + let tx_hash = res.tx_hash; + let transfer_tx = wallet_core + .poll_native_token_transfer(tx_hash.clone()) + .await?; + + if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { + let acc_decode_data = vec![(secret_winner, winner_addr)]; + + wallet_core.decode_insert_privacy_preserving_transaction_results( + tx, + &acc_decode_data, + )?; + } + + let path = wallet_core.store_persistent_accounts()?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) + } + } + } +} + +impl WalletSubcommand for PinataProgramSubcommand { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + PinataProgramSubcommand::Private(private_subcommand) => { + private_subcommand.handle_subcommand(wallet_core).await + } + PinataProgramSubcommand::Public(public_subcommand) => { + public_subcommand.handle_subcommand(wallet_core).await + } + } + } +} diff --git a/wallet/src/lib.rs b/wallet/src/lib.rs index ac4cf6d..65eca41 100644 --- a/wallet/src/lib.rs +++ b/wallet/src/lib.rs @@ -1,4 +1,4 @@ -use std::{fs::File, io::Write, path::PathBuf, str::FromStr, sync::Arc}; +use std::{fs::File, io::Write, path::PathBuf, sync::Arc}; use base64::{Engine, engine::general_purpose::STANDARD as BASE64}; use common::{ @@ -15,12 +15,15 @@ use nssa::{Account, Address}; use clap::{Parser, Subcommand}; use nssa_core::Commitment; -use crate::cli::WalletSubcommand; +use crate::cli::{ + WalletSubcommand, chain::ChainSubcommand, + native_token_transfer_program::NativeTokenTransferProgramSubcommand, + pinata_program::PinataProgramSubcommand, +}; use crate::{ cli::token_program::TokenProgramSubcommand, helperfunctions::{ - HumanReadableAccount, fetch_config, fetch_persistent_accounts, get_home, - produce_data_for_storage, + fetch_config, fetch_persistent_accounts, get_home, produce_data_for_storage, }, poller::TxPoller, }; @@ -181,163 +184,15 @@ impl WalletCore { #[derive(Subcommand, Debug, Clone)] #[clap(about)] pub enum Command { - ///Send native token transfer from `from` to `to` for `amount` - /// - /// Public operation - SendNativeTokenTransferPublic { - ///from - valid 32 byte hex string - #[arg(long)] - from: String, - ///to - valid 32 byte hex string - #[arg(long)] - to: String, - ///amount - amount of balance to move - #[arg(long)] - amount: u128, - }, - ///Send native token transfer from `from` to `to` for `amount` - /// - /// Private operation - SendNativeTokenTransferPrivateOwnedAccount { - ///from - valid 32 byte hex string - #[arg(long)] - from: String, - ///to - valid 32 byte hex string - #[arg(long)] - to: String, - ///amount - amount of balance to move - #[arg(long)] - amount: u128, - }, - ///Send native token transfer from `from` to `to` for `amount` - /// - /// Private operation - SendNativeTokenTransferPrivateForeignAccount { - ///from - valid 32 byte hex string - #[arg(long)] - from: String, - ///to_npk - valid 32 byte hex string - #[arg(long)] - to_npk: String, - ///to_ipk - valid 33 byte hex string - #[arg(long)] - to_ipk: String, - ///amount - amount of balance to move - #[arg(long)] - amount: u128, - }, - ///Send native token transfer from `from` to `to` for `amount` - /// - /// Deshielded operation - SendNativeTokenTransferDeshielded { - ///from - valid 32 byte hex string - #[arg(long)] - from: String, - ///to - valid 32 byte hex string - #[arg(long)] - to: String, - ///amount - amount of balance to move - #[arg(long)] - amount: u128, - }, - ///Send native token transfer from `from` to `to` for `amount` - /// - /// Shielded operation - SendNativeTokenTransferShielded { - ///from - valid 32 byte hex string - #[arg(long)] - from: String, - ///to - valid 32 byte hex string - #[arg(long)] - to: String, - ///amount - amount of balance to move - #[arg(long)] - amount: u128, - }, - ///Send native token transfer from `from` to `to` for `amount` - /// - /// Shielded operation - SendNativeTokenTransferShieldedForeignAccount { - ///from - valid 32 byte hex string - #[arg(long)] - from: String, - ///to_npk - valid 32 byte hex string - #[arg(long)] - to_npk: String, - ///to_ipk - valid 33 byte hex string - #[arg(long)] - to_ipk: String, - ///amount - amount of balance to move - #[arg(long)] - amount: u128, - }, - ///Claim account `acc_addr` generated in transaction `tx_hash`, using secret `sh_secret` at ciphertext id `ciph_id` - FetchPrivateAccount { - ///tx_hash - valid 32 byte hex string - #[arg(long)] - tx_hash: String, - ///acc_addr - valid 32 byte hex string - #[arg(long)] - acc_addr: String, - ///output_id - id of the output in the transaction - #[arg(long)] - output_id: usize, - }, - ///Get private account with `addr` from storage - GetPrivateAccount { - #[arg(short, long)] - addr: String, - }, - ///Register new public account - RegisterAccountPublic {}, - ///Register new private account - RegisterAccountPrivate {}, - ///Fetch transaction by `hash` - FetchTx { - #[arg(short, long)] - tx_hash: String, - }, - ///Get account `addr` balance - GetPublicAccountBalance { - #[arg(short, long)] - addr: String, - }, - ///Get account `addr` nonce - GetPublicAccountNonce { - #[arg(short, long)] - addr: String, - }, - ///Get account at address `addr` - GetPublicAccount { - #[arg(short, long)] - addr: String, - }, - // TODO: Testnet only. Refactor to prevent compilation on mainnet. - // Claim piñata prize - ClaimPinata { - ///pinata_addr - valid 32 byte hex string - #[arg(long)] - pinata_addr: String, - ///winner_addr - valid 32 byte hex string - #[arg(long)] - winner_addr: String, - ///solution - solution to pinata challenge - #[arg(long)] - solution: u128, - }, - // TODO: Testnet only. Refactor to prevent compilation on mainnet. - // Claim piñata prize - ClaimPinataPrivateReceiverOwned { - ///pinata_addr - valid 32 byte hex string - #[arg(long)] - pinata_addr: String, - ///winner_addr - valid 32 byte hex string - #[arg(long)] - winner_addr: String, - ///solution - solution to pinata challenge - #[arg(long)] - solution: u128, - }, + ///Transfer command + #[command(subcommand)] + Transfer(NativeTokenTransferProgramSubcommand), + ///Chain command + #[command(subcommand)] + Chain(ChainSubcommand), + ///Pinata command + #[command(subcommand)] + PinataProgram(PinataProgramSubcommand), ///Token command #[command(subcommand)] TokenProgram(TokenProgramSubcommand), @@ -365,373 +220,18 @@ pub async fn execute_subcommand(command: Command) -> Result { - let from: Address = from.parse().unwrap(); - let to: Address = to.parse().unwrap(); - - let res = wallet_core - .send_public_native_token_transfer(from, to, amount) - .await?; - - println!("Results of tx send is {res:#?}"); - - let transfer_tx = wallet_core.poll_native_token_transfer(res.tx_hash).await?; - - println!("Transaction data is {transfer_tx:?}"); - - let path = wallet_core.store_persistent_accounts()?; - - println!("Stored persistent accounts at {path:#?}"); - - SubcommandReturnValue::Empty + Command::Transfer(transfer_subcommand) => { + transfer_subcommand + .handle_subcommand(&mut wallet_core) + .await? } - Command::SendNativeTokenTransferPrivateOwnedAccount { from, to, amount } => { - let from: Address = from.parse().unwrap(); - let to: Address = to.parse().unwrap(); - - let (res, [secret_from, secret_to]) = wallet_core - .send_private_native_token_transfer_owned_account(from, to, amount) - .await?; - - println!("Results of tx send is {res:#?}"); - - let tx_hash = res.tx_hash; - let transfer_tx = wallet_core - .poll_native_token_transfer(tx_hash.clone()) - .await?; - - if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { - let acc_decode_data = vec![(secret_from, from), (secret_to, to)]; - - wallet_core - .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; - } - - let path = wallet_core.store_persistent_accounts()?; - - println!("Stored persistent accounts at {path:#?}"); - - SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } + Command::Chain(chain_subcommand) => { + chain_subcommand.handle_subcommand(&mut wallet_core).await? } - Command::SendNativeTokenTransferPrivateForeignAccount { - from, - to_npk, - to_ipk, - amount, - } => { - let from: Address = from.parse().unwrap(); - let to_npk_res = hex::decode(to_npk)?; - let mut to_npk = [0; 32]; - to_npk.copy_from_slice(&to_npk_res); - let to_npk = nssa_core::NullifierPublicKey(to_npk); - - let to_ipk_res = hex::decode(to_ipk)?; - let mut to_ipk = [0u8; 33]; - to_ipk.copy_from_slice(&to_ipk_res); - let to_ipk = - nssa_core::encryption::shared_key_derivation::Secp256k1Point(to_ipk.to_vec()); - - let (res, [secret_from, _]) = wallet_core - .send_private_native_token_transfer_outer_account(from, to_npk, to_ipk, amount) - .await?; - - println!("Results of tx send is {res:#?}"); - - let tx_hash = res.tx_hash; - let transfer_tx = wallet_core - .poll_native_token_transfer(tx_hash.clone()) - .await?; - - if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { - let acc_decode_data = vec![(secret_from, from)]; - - wallet_core - .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; - } - - let path = wallet_core.store_persistent_accounts()?; - - println!("Stored persistent accounts at {path:#?}"); - - SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } - } - Command::SendNativeTokenTransferDeshielded { from, to, amount } => { - let from: Address = from.parse().unwrap(); - let to: Address = to.parse().unwrap(); - - let (res, secret) = wallet_core - .send_deshielded_native_token_transfer(from, to, amount) - .await?; - - println!("Results of tx send is {res:#?}"); - - let tx_hash = res.tx_hash; - let transfer_tx = wallet_core - .poll_native_token_transfer(tx_hash.clone()) - .await?; - - if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { - let acc_decode_data = vec![(secret, from)]; - - wallet_core - .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; - } - - let path = wallet_core.store_persistent_accounts()?; - - println!("Stored persistent accounts at {path:#?}"); - - SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } - } - Command::SendNativeTokenTransferShielded { from, to, amount } => { - let from: Address = from.parse().unwrap(); - let to: Address = to.parse().unwrap(); - - let (res, secret) = wallet_core - .send_shielded_native_token_transfer(from, to, amount) - .await?; - - println!("Results of tx send is {res:#?}"); - - let tx_hash = res.tx_hash; - let transfer_tx = wallet_core - .poll_native_token_transfer(tx_hash.clone()) - .await?; - - if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { - let acc_decode_data = vec![(secret, to)]; - - wallet_core - .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; - } - - let path = wallet_core.store_persistent_accounts()?; - - println!("Stored persistent accounts at {path:#?}"); - - SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } - } - Command::SendNativeTokenTransferShieldedForeignAccount { - from, - to_npk, - to_ipk, - amount, - } => { - let from: Address = from.parse().unwrap(); - - let to_npk_res = hex::decode(to_npk)?; - let mut to_npk = [0; 32]; - to_npk.copy_from_slice(&to_npk_res); - let to_npk = nssa_core::NullifierPublicKey(to_npk); - - let to_ipk_res = hex::decode(to_ipk)?; - let mut to_ipk = [0u8; 33]; - to_ipk.copy_from_slice(&to_ipk_res); - let to_ipk = - nssa_core::encryption::shared_key_derivation::Secp256k1Point(to_ipk.to_vec()); - - let (res, _) = wallet_core - .send_shielded_native_token_transfer_outer_account(from, to_npk, to_ipk, amount) - .await?; - - println!("Results of tx send is {res:#?}"); - - let tx_hash = res.tx_hash; - - let path = wallet_core.store_persistent_accounts()?; - - println!("Stored persistent accounts at {path:#?}"); - - SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } - } - Command::FetchPrivateAccount { - tx_hash, - acc_addr, - output_id: ciph_id, - } => { - let acc_addr: Address = acc_addr.parse().unwrap(); - - let account_key_chain = wallet_core - .storage - .user_data - .user_private_accounts - .get(&acc_addr); - - let Some((account_key_chain, _)) = account_key_chain else { - anyhow::bail!("Account not found"); - }; - - let transfer_tx = wallet_core.poll_native_token_transfer(tx_hash).await?; - - if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { - let to_ebc = tx.message.encrypted_private_post_states[ciph_id].clone(); - let to_comm = tx.message.new_commitments[ciph_id].clone(); - let shared_secret = account_key_chain.calculate_shared_secret_receiver(to_ebc.epk); - - let res_acc_to = nssa_core::EncryptionScheme::decrypt( - &to_ebc.ciphertext, - &shared_secret, - &to_comm, - ciph_id as u32, - ) - .unwrap(); - - println!("RES acc to {res_acc_to:#?}"); - - println!("Transaction data is {:?}", tx.message); - - wallet_core - .storage - .insert_private_account_data(acc_addr, res_acc_to); - } - - let path = wallet_core.store_persistent_accounts()?; - - println!("Stored persistent accounts at {path:#?}"); - - SubcommandReturnValue::Empty - } - Command::RegisterAccountPublic {} => { - let addr = wallet_core.create_new_account_public(); - - println!("Generated new account with addr {addr}"); - - let path = wallet_core.store_persistent_accounts()?; - - println!("Stored persistent accounts at {path:#?}"); - - SubcommandReturnValue::RegisterAccount { addr } - } - Command::RegisterAccountPrivate {} => { - let addr = wallet_core.create_new_account_private(); - - let (key, _) = wallet_core - .storage - .user_data - .get_private_account(&addr) - .unwrap(); - - println!("Generated new account with addr {addr}"); - println!("With npk {}", hex::encode(&key.nullifer_public_key)); - println!( - "With ipk {}", - hex::encode(key.incoming_viewing_public_key.to_bytes()) - ); - - let path = wallet_core.store_persistent_accounts()?; - - println!("Stored persistent accounts at {path:#?}"); - - SubcommandReturnValue::RegisterAccount { addr } - } - Command::FetchTx { tx_hash } => { - let tx_obj = wallet_core - .sequencer_client - .get_transaction_by_hash(tx_hash) - .await?; - - println!("Transaction object {tx_obj:#?}"); - - SubcommandReturnValue::Empty - } - Command::GetPublicAccountBalance { addr } => { - let addr = Address::from_str(&addr)?; - - let balance = wallet_core.get_account_balance(addr).await?; - println!("Accounts {addr} balance is {balance}"); - - SubcommandReturnValue::Empty - } - Command::GetPublicAccountNonce { addr } => { - let addr = Address::from_str(&addr)?; - - let nonce = wallet_core.get_accounts_nonces(vec![addr]).await?[0]; - println!("Accounts {addr} nonce is {nonce}"); - - SubcommandReturnValue::Empty - } - Command::GetPublicAccount { addr } => { - let addr: Address = addr.parse()?; - let account = wallet_core.get_account_public(addr).await?; - let account_hr: HumanReadableAccount = account.clone().into(); - println!("{}", serde_json::to_string(&account_hr).unwrap()); - - SubcommandReturnValue::Account(account) - } - Command::GetPrivateAccount { addr } => { - let addr: Address = addr.parse()?; - if let Some(account) = wallet_core.get_account_private(&addr) { - println!("{}", serde_json::to_string(&account).unwrap()); - } else { - println!("Private account not found."); - } - SubcommandReturnValue::Empty - } - Command::ClaimPinata { - pinata_addr, - winner_addr, - solution, - } => { - let res = wallet_core - .claim_pinata( - pinata_addr.parse().unwrap(), - winner_addr.parse().unwrap(), - solution, - ) - .await?; - info!("Results of tx send is {res:#?}"); - - SubcommandReturnValue::Empty - } - Command::ClaimPinataPrivateReceiverOwned { - pinata_addr, - winner_addr, - solution, - } => { - let pinata_addr = pinata_addr.parse().unwrap(); - let winner_addr = winner_addr.parse().unwrap(); - - let winner_intialized = wallet_core - .check_private_account_initialized(&winner_addr) - .await; - - let (res, [secret_winner]) = if winner_intialized { - wallet_core - .claim_pinata_private_owned_account_already_initialized( - pinata_addr, - winner_addr, - solution, - ) - .await? - } else { - wallet_core - .claim_pinata_private_owned_account_not_initialized( - pinata_addr, - winner_addr, - solution, - ) - .await? - }; - - info!("Results of tx send is {res:#?}"); - - let tx_hash = res.tx_hash; - let transfer_tx = wallet_core - .poll_native_token_transfer(tx_hash.clone()) - .await?; - - if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { - let acc_decode_data = vec![(secret_winner, winner_addr)]; - - wallet_core - .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; - } - - let path = wallet_core.store_persistent_accounts()?; - - println!("Stored persistent accounts at {path:#?}"); - - SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } + Command::PinataProgram(pinata_subcommand) => { + pinata_subcommand + .handle_subcommand(&mut wallet_core) + .await? } Command::TokenProgram(token_subcommand) => { token_subcommand.handle_subcommand(&mut wallet_core).await? From 54c54199d77d07f5e3cc7ae388b326c9f2acfaeb Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Tue, 14 Oct 2025 17:15:04 -0300 Subject: [PATCH 02/17] wip --- nssa/src/lib.rs | 1 + .../program_deployment_transaction/message.rs | 4 ++++ .../src/program_deployment_transaction/mod.rs | 2 ++ .../transaction.rs | 22 +++++++++++++++++++ nssa/src/state.rs | 16 +++++++------- 5 files changed, 37 insertions(+), 8 deletions(-) create mode 100644 nssa/src/program_deployment_transaction/message.rs create mode 100644 nssa/src/program_deployment_transaction/mod.rs create mode 100644 nssa/src/program_deployment_transaction/transaction.rs diff --git a/nssa/src/lib.rs b/nssa/src/lib.rs index 21defa9..b7e041d 100644 --- a/nssa/src/lib.rs +++ b/nssa/src/lib.rs @@ -4,6 +4,7 @@ mod merkle_tree; pub mod privacy_preserving_transaction; pub mod program; pub mod public_transaction; +pub mod program_deployment_transaction; mod signature; mod state; diff --git a/nssa/src/program_deployment_transaction/message.rs b/nssa/src/program_deployment_transaction/message.rs new file mode 100644 index 0000000..4601975 --- /dev/null +++ b/nssa/src/program_deployment_transaction/message.rs @@ -0,0 +1,4 @@ +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Message { + pub(crate) bytecode: Vec, +} diff --git a/nssa/src/program_deployment_transaction/mod.rs b/nssa/src/program_deployment_transaction/mod.rs new file mode 100644 index 0000000..6aa1cda --- /dev/null +++ b/nssa/src/program_deployment_transaction/mod.rs @@ -0,0 +1,2 @@ +mod message; +mod transaction; diff --git a/nssa/src/program_deployment_transaction/transaction.rs b/nssa/src/program_deployment_transaction/transaction.rs new file mode 100644 index 0000000..36f3de0 --- /dev/null +++ b/nssa/src/program_deployment_transaction/transaction.rs @@ -0,0 +1,22 @@ +use std::collections::HashMap; + +use nssa_core::{account::Account, address::Address}; + +use crate::{V01State, error::NssaError, program_deployment_transaction::message::Message}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ProgramDeploymentTransaction { + message: Message, +} + +impl ProgramDeploymentTransaction { + pub fn new(message: Message) -> Self { + Self { message } + } + pub(crate) fn validate_and_produce_public_state_diff( + &self, + state: &mut V01State, + ) -> Result, NssaError> { + todo!() + } +} diff --git a/nssa/src/state.rs b/nssa/src/state.rs index 3066809..b93794c 100644 --- a/nssa/src/state.rs +++ b/nssa/src/state.rs @@ -61,7 +61,7 @@ type NullifierSet = HashSet; pub struct V01State { public_state: HashMap, private_state: (CommitmentSet, NullifierSet), - builtin_programs: HashMap, + programs: HashMap, } impl V01State { @@ -90,7 +90,7 @@ impl V01State { let mut this = Self { public_state, private_state: (private_state, NullifierSet::new()), - builtin_programs: HashMap::new(), + programs: HashMap::new(), }; this.insert_program(Program::authenticated_transfer_program()); @@ -100,7 +100,7 @@ impl V01State { } pub(crate) fn insert_program(&mut self, program: Program) { - self.builtin_programs.insert(program.id(), program); + self.programs.insert(program.id(), program); } pub fn transition_from_public_transaction( @@ -173,7 +173,7 @@ impl V01State { } pub(crate) fn builtin_programs(&self) -> &HashMap { - &self.builtin_programs + &self.programs } pub fn commitment_set_digest(&self) -> CommitmentSetDigest { @@ -312,7 +312,7 @@ pub mod tests { let state = V01State::new_with_genesis_accounts(&initial_data, &[]); assert_eq!(state.public_state, expected_public_state); - assert_eq!(state.builtin_programs, expected_builtin_programs); + assert_eq!(state.programs, expected_builtin_programs); } #[test] @@ -320,11 +320,11 @@ pub mod tests { let mut state = V01State::new_with_genesis_accounts(&[], &[]); let program_to_insert = Program::simple_balance_transfer(); let program_id = program_to_insert.id(); - assert!(!state.builtin_programs.contains_key(&program_id)); + assert!(!state.programs.contains_key(&program_id)); state.insert_program(program_to_insert); - assert!(state.builtin_programs.contains_key(&program_id)); + assert!(state.programs.contains_key(&program_id)); } #[test] @@ -357,7 +357,7 @@ pub mod tests { let builtin_programs = state.builtin_programs(); - assert_eq!(builtin_programs, &state.builtin_programs); + assert_eq!(builtin_programs, &state.programs); } #[test] From 88446b17f9f735fcae4c768061ff9744c3f475c5 Mon Sep 17 00:00:00 2001 From: Oleksandr Pravdyvyi Date: Wed, 15 Oct 2025 15:17:30 +0300 Subject: [PATCH 03/17] feat: automatic mode added --- common/src/sequencer_client/mod.rs | 17 +++++- wallet/src/lib.rs | 93 +++++++++++++++++++++++++++++- wallet/src/main.rs | 10 +++- 3 files changed, 114 insertions(+), 6 deletions(-) diff --git a/common/src/sequencer_client/mod.rs b/common/src/sequencer_client/mod.rs index 1aec903..3c27cae 100644 --- a/common/src/sequencer_client/mod.rs +++ b/common/src/sequencer_client/mod.rs @@ -9,8 +9,8 @@ use serde_json::Value; use crate::rpc_primitives::requests::{ GetAccountRequest, GetAccountResponse, GetAccountsNoncesRequest, GetAccountsNoncesResponse, - GetProofForCommitmentRequest, GetProofForCommitmentResponse, GetTransactionByHashRequest, - GetTransactionByHashResponse, + GetLastBlockRequest, GetLastBlockResponse, GetProofForCommitmentRequest, + GetProofForCommitmentResponse, GetTransactionByHashRequest, GetTransactionByHashResponse, }; use crate::sequencer_client::json::AccountInitialData; use crate::transaction::{EncodedTransaction, NSSATransaction}; @@ -74,6 +74,19 @@ impl SequencerClient { Ok(resp_deser) } + ///Get last known `blokc_id` from sequencer + pub async fn get_last_block(&self) -> Result { + let block_req = GetLastBlockRequest {}; + + let req = serde_json::to_value(block_req)?; + + let resp = self.call_method_with_payload("get_last_block", req).await?; + + let resp_deser = serde_json::from_value(resp)?; + + Ok(resp_deser) + } + ///Get account public balance for `address`. `address` must be a valid hex-string for 32 bytes. pub async fn get_account_balance( &self, diff --git a/wallet/src/lib.rs b/wallet/src/lib.rs index 65eca41..36e78e6 100644 --- a/wallet/src/lib.rs +++ b/wallet/src/lib.rs @@ -2,6 +2,7 @@ use std::{fs::File, io::Write, path::PathBuf, sync::Arc}; use base64::{Engine, engine::general_purpose::STANDARD as BASE64}; use common::{ + block::HashableBlockData, sequencer_client::SequencerClient, transaction::{EncodedTransaction, NSSATransaction}, }; @@ -10,7 +11,7 @@ use anyhow::Result; use chain_storage::WalletChainStore; use config::WalletConfig; use log::info; -use nssa::{Account, Address}; +use nssa::{Account, Address, privacy_preserving_transaction::message::EncryptedAccountData}; use clap::{Parser, Subcommand}; use nssa_core::Commitment; @@ -202,9 +203,12 @@ pub enum Command { #[derive(Parser, Debug)] #[clap(version, about)] pub struct Args { + /// Continious run flag + #[arg(short, long)] + pub continious_run: bool, /// Wallet command #[command(subcommand)] - pub command: Command, + pub command: Option, } #[derive(Debug, Clone)] @@ -240,3 +244,88 @@ pub async fn execute_subcommand(command: Command) -> Result Result<()> { + let config = fetch_config()?; + let seq_client = Arc::new(SequencerClient::new(config.sequencer_addr.clone())?); + let mut wallet_core = WalletCore::start_from_config_update_chain(config.clone())?; + + let mut latest_block_num = seq_client.get_last_block().await?.last_block; + let mut curr_last_block = latest_block_num; + + loop { + for block_id in curr_last_block..(latest_block_num + 1) { + let block = borsh::from_slice::( + &seq_client.get_block(block_id).await?.block, + )?; + + for tx in block.transactions { + let nssa_tx = NSSATransaction::try_from(&tx)?; + + if let NSSATransaction::PrivacyPreserving(tx) = nssa_tx { + let mut affected_accounts = vec![]; + + for (acc_addr, (key_chain, _)) in + &wallet_core.storage.user_data.user_private_accounts + { + let view_tag = EncryptedAccountData::compute_view_tag( + key_chain.nullifer_public_key.clone(), + key_chain.incoming_viewing_public_key.clone(), + ); + + for (ciph_id, encrypted_data) in tx + .message() + .encrypted_private_post_states + .iter() + .enumerate() + { + if encrypted_data.view_tag == view_tag { + let ciphertext = &encrypted_data.ciphertext; + let commitment = &tx.message.new_commitments[ciph_id]; + let shared_secret = key_chain + .calculate_shared_secret_receiver(encrypted_data.epk.clone()); + + let res_acc = nssa_core::EncryptionScheme::decrypt( + ciphertext, + &shared_secret, + commitment, + ciph_id as u32, + ); + + if let Some(res_acc) = res_acc { + println!( + "Received new account for addr {acc_addr:#?} with account object {res_acc:#?}" + ); + + affected_accounts.push((*acc_addr, res_acc)); + } + } + } + } + + for (affected_addr, new_acc) in affected_accounts { + wallet_core + .storage + .insert_private_account_data(affected_addr, new_acc); + } + } + } + + wallet_core.store_persistent_accounts()?; + + println!( + "Block at id {block_id} with timestamp {} parsed", + block.timestamp + ); + } + + curr_last_block = latest_block_num + 1; + + tokio::time::sleep(std::time::Duration::from_millis( + config.seq_poll_timeout_millis, + )) + .await; + + latest_block_num = seq_client.get_last_block().await?.last_block; + } +} diff --git a/wallet/src/main.rs b/wallet/src/main.rs index b296400..9cab532 100644 --- a/wallet/src/main.rs +++ b/wallet/src/main.rs @@ -1,7 +1,7 @@ use anyhow::Result; use clap::Parser; use tokio::runtime::Builder; -use wallet::{Args, execute_subcommand}; +use wallet::{Args, execute_continious_run, execute_subcommand}; pub const NUM_THREADS: usize = 2; @@ -17,7 +17,13 @@ fn main() -> Result<()> { env_logger::init(); runtime.block_on(async move { - execute_subcommand(args.command).await.unwrap(); + if let Some(command) = args.command { + execute_subcommand(command).await.unwrap(); + } else if args.continious_run { + execute_continious_run().await.unwrap(); + } else { + println!("NOTHING TO DO"); + } }); Ok(()) From 28fe9e2113b3bdb083d5121c28fd70deab6ed32b Mon Sep 17 00:00:00 2001 From: Oleksandr Pravdyvyi Date: Wed, 15 Oct 2025 15:44:52 +0300 Subject: [PATCH 04/17] fix: merge updates --- .../src/cli/native_token_transfer_program.rs | 28 ++++- wallet/src/cli/pinata_program.rs | 2 +- wallet/src/token_transfers/private.rs | 103 ++++++++++++++++-- wallet/src/token_transfers/shielded.rs | 89 ++++++++++++--- 4 files changed, 190 insertions(+), 32 deletions(-) diff --git a/wallet/src/cli/native_token_transfer_program.rs b/wallet/src/cli/native_token_transfer_program.rs index 355c7f3..6d43d64 100644 --- a/wallet/src/cli/native_token_transfer_program.rs +++ b/wallet/src/cli/native_token_transfer_program.rs @@ -126,9 +126,17 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommandPrivate { let from: Address = from.parse().unwrap(); let to: Address = to.parse().unwrap(); - let (res, [secret_from, secret_to]) = wallet_core - .send_private_native_token_transfer_owned_account(from, to, amount) - .await?; + let to_initialization = wallet_core.check_private_account_initialized(&to).await?; + + let (res, [secret_from, secret_to]) = if let Some(to_proof) = to_initialization { + wallet_core + .send_private_native_token_transfer_owned_account_already_initialized(from, to, amount, to_proof) + .await? + } else { + wallet_core + .send_private_native_token_transfer_owned_account_not_initialized(from, to, amount) + .await? + }; println!("Results of tx send is {res:#?}"); @@ -206,9 +214,17 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommandShielded { let from: Address = from.parse().unwrap(); let to: Address = to.parse().unwrap(); - let (res, secret) = wallet_core - .send_shielded_native_token_transfer(from, to, amount) - .await?; + let to_initialization = wallet_core.check_private_account_initialized(&to).await?; + + let (res, secret) = if let Some(to_proof) = to_initialization { + wallet_core + .send_shielded_native_token_transfer_already_initialized(from, to, amount, to_proof) + .await? + } else { + wallet_core + .send_shielded_native_token_transfer_not_initialized(from, to, amount) + .await? + }; println!("Results of tx send is {res:#?}"); diff --git a/wallet/src/cli/pinata_program.rs b/wallet/src/cli/pinata_program.rs index eb5c716..b197ae0 100644 --- a/wallet/src/cli/pinata_program.rs +++ b/wallet/src/cli/pinata_program.rs @@ -102,7 +102,7 @@ impl WalletSubcommand for PinataProgramSubcommandPrivate { pinata_addr, winner_addr, solution, - winner_proof + winner_proof, ) .await? } else { diff --git a/wallet/src/token_transfers/private.rs b/wallet/src/token_transfers/private.rs index 5253acd..0c6751b 100644 --- a/wallet/src/token_transfers/private.rs +++ b/wallet/src/token_transfers/private.rs @@ -6,7 +6,7 @@ use nssa::{ program::Program, }; use nssa_core::{ - Commitment, NullifierPublicKey, SharedSecretKey, account::AccountWithMetadata, + Commitment, MembershipProof, NullifierPublicKey, SharedSecretKey, account::AccountWithMetadata, encryption::IncomingViewingPublicKey, }; @@ -98,11 +98,12 @@ impl WalletCore { } } - pub async fn send_private_native_token_transfer_owned_account( + pub async fn send_private_native_token_transfer_owned_account_already_initialized( &self, from: Address, to: Address, balance_to_move: u128, + to_proof: MembershipProof, ) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> { let Some((from_keys, from_acc)) = self.storage.user_data.get_private_account(&from).cloned() @@ -124,7 +125,6 @@ impl WalletCore { let program = Program::authenticated_transfer_program(); let sender_commitment = Commitment::new(&from_npk, &from_acc); - let receiver_commitment = Commitment::new(&to_npk, &to_acc); let sender_pre = AccountWithMetadata::new(from_acc.clone(), true, &from_npk); let recipient_pre = AccountWithMetadata::new(to_acc.clone(), true, &to_npk); @@ -153,14 +153,7 @@ impl WalletCore { .unwrap() .unwrap(), ), - ( - to_keys.private_key_holder.nullifier_secret_key, - self.sequencer_client - .get_proof_for_commitment(receiver_commitment) - .await - .unwrap() - .unwrap(), - ), + (to_keys.private_key_holder.nullifier_secret_key, to_proof), ], &program, ) @@ -196,4 +189,92 @@ impl WalletCore { Err(ExecutionFailureKind::InsufficientFundsError) } } + + pub async fn send_private_native_token_transfer_owned_account_not_initialized( + &self, + from: Address, + to: Address, + balance_to_move: u128, + ) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> { + let Some((from_keys, from_acc)) = + self.storage.user_data.get_private_account(&from).cloned() + else { + return Err(ExecutionFailureKind::KeyNotFoundError); + }; + + let Some((to_keys, to_acc)) = self.storage.user_data.get_private_account(&to).cloned() + else { + return Err(ExecutionFailureKind::KeyNotFoundError); + }; + + let from_npk = from_keys.nullifer_public_key; + let from_ipk = from_keys.incoming_viewing_public_key; + let to_npk = to_keys.nullifer_public_key.clone(); + let to_ipk = to_keys.incoming_viewing_public_key.clone(); + + if from_acc.balance >= balance_to_move { + let program = Program::authenticated_transfer_program(); + + let sender_commitment = Commitment::new(&from_npk, &from_acc); + + let sender_pre = AccountWithMetadata::new(from_acc.clone(), true, &from_npk); + let recipient_pre = AccountWithMetadata::new(to_acc.clone(), false, &to_npk); + + let eph_holder_from = EphemeralKeyHolder::new(&from_npk); + let shared_secret_from = eph_holder_from.calculate_shared_secret_sender(&from_ipk); + + let eph_holder_to = EphemeralKeyHolder::new(&to_npk); + let shared_secret_to = eph_holder_to.calculate_shared_secret_sender(&to_ipk); + + let (output, proof) = circuit::execute_and_prove( + &[sender_pre, recipient_pre], + &Program::serialize_instruction(balance_to_move).unwrap(), + &[1, 2], + &produce_random_nonces(2), + &[ + (from_npk.clone(), shared_secret_from.clone()), + (to_npk.clone(), shared_secret_to.clone()), + ], + &[( + from_keys.private_key_holder.nullifier_secret_key, + self.sequencer_client + .get_proof_for_commitment(sender_commitment) + .await + .unwrap() + .unwrap(), + )], + &program, + ) + .unwrap(); + + let message = Message::try_from_circuit_output( + vec![], + vec![], + vec![ + ( + from_npk.clone(), + from_ipk.clone(), + eph_holder_from.generate_ephemeral_public_key(), + ), + ( + to_npk.clone(), + to_ipk.clone(), + eph_holder_to.generate_ephemeral_public_key(), + ), + ], + output, + ) + .unwrap(); + + let witness_set = WitnessSet::for_message(&message, proof, &[]); + let tx = PrivacyPreservingTransaction::new(message, witness_set); + + Ok(( + self.sequencer_client.send_tx_private(tx).await?, + [shared_secret_from, shared_secret_to], + )) + } else { + Err(ExecutionFailureKind::InsufficientFundsError) + } + } } diff --git a/wallet/src/token_transfers/shielded.rs b/wallet/src/token_transfers/shielded.rs index 1cf1cb7..8fabedd 100644 --- a/wallet/src/token_transfers/shielded.rs +++ b/wallet/src/token_transfers/shielded.rs @@ -6,14 +6,84 @@ use nssa::{ program::Program, }; use nssa_core::{ - Commitment, NullifierPublicKey, SharedSecretKey, account::AccountWithMetadata, + MembershipProof, NullifierPublicKey, SharedSecretKey, account::AccountWithMetadata, encryption::IncomingViewingPublicKey, }; use crate::{WalletCore, helperfunctions::produce_random_nonces}; impl WalletCore { - pub async fn send_shielded_native_token_transfer( + pub async fn send_shielded_native_token_transfer_already_initialized( + &self, + from: Address, + to: Address, + balance_to_move: u128, + to_proof: MembershipProof, + ) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> { + let Ok(from_acc) = self.get_account_public(from).await else { + return Err(ExecutionFailureKind::KeyNotFoundError); + }; + + let Some((to_keys, to_acc)) = self.storage.user_data.get_private_account(&to).cloned() + else { + return Err(ExecutionFailureKind::KeyNotFoundError); + }; + + let to_npk = to_keys.nullifer_public_key.clone(); + let to_ipk = to_keys.incoming_viewing_public_key.clone(); + + if from_acc.balance >= balance_to_move { + let program = Program::authenticated_transfer_program(); + + let sender_pre = AccountWithMetadata::new(from_acc.clone(), true, from); + let recipient_pre = AccountWithMetadata::new(to_acc.clone(), true, &to_npk); + + let eph_holder = EphemeralKeyHolder::new(&to_npk); + let shared_secret = eph_holder.calculate_shared_secret_sender(&to_ipk); + + let (output, proof) = circuit::execute_and_prove( + &[sender_pre, recipient_pre], + &nssa::program::Program::serialize_instruction(balance_to_move).unwrap(), + &[0, 1], + &produce_random_nonces(1), + &[(to_npk.clone(), shared_secret.clone())], + &[(to_keys.private_key_holder.nullifier_secret_key, to_proof)], + &program, + ) + .unwrap(); + + let message = Message::try_from_circuit_output( + vec![from], + vec![from_acc.nonce], + vec![( + to_npk.clone(), + to_ipk.clone(), + eph_holder.generate_ephemeral_public_key(), + )], + output, + ) + .unwrap(); + + let signing_key = self.storage.user_data.get_pub_account_signing_key(&from); + + let Some(signing_key) = signing_key else { + return Err(ExecutionFailureKind::KeyNotFoundError); + }; + + let witness_set = WitnessSet::for_message(&message, proof, &[signing_key]); + + let tx = PrivacyPreservingTransaction::new(message, witness_set); + + Ok(( + self.sequencer_client.send_tx_private(tx).await?, + shared_secret, + )) + } else { + Err(ExecutionFailureKind::InsufficientFundsError) + } + } + + pub async fn send_shielded_native_token_transfer_not_initialized( &self, from: Address, to: Address, @@ -34,10 +104,8 @@ impl WalletCore { if from_acc.balance >= balance_to_move { let program = Program::authenticated_transfer_program(); - let receiver_commitment = Commitment::new(&to_npk, &to_acc); - let sender_pre = AccountWithMetadata::new(from_acc.clone(), true, from); - let recipient_pre = AccountWithMetadata::new(to_acc.clone(), true, &to_npk); + let recipient_pre = AccountWithMetadata::new(to_acc.clone(), false, &to_npk); let eph_holder = EphemeralKeyHolder::new(&to_npk); let shared_secret = eph_holder.calculate_shared_secret_sender(&to_ipk); @@ -45,17 +113,10 @@ impl WalletCore { let (output, proof) = circuit::execute_and_prove( &[sender_pre, recipient_pre], &nssa::program::Program::serialize_instruction(balance_to_move).unwrap(), - &[0, 1], + &[0, 2], &produce_random_nonces(1), &[(to_npk.clone(), shared_secret.clone())], - &[( - to_keys.private_key_holder.nullifier_secret_key, - self.sequencer_client - .get_proof_for_commitment(receiver_commitment) - .await - .unwrap() - .unwrap(), - )], + &[], &program, ) .unwrap(); From da28f3317b72b1c3c814cac0081ee00c56272b17 Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Wed, 15 Oct 2025 17:25:26 -0300 Subject: [PATCH 05/17] add transition function for program deployment --- nssa/Cargo.toml | 1 + nssa/src/error.rs | 6 ++ nssa/src/lib.rs | 2 +- .../transaction.rs | 2 +- nssa/src/program.rs | 78 ++++++++++++------- .../src/program_deployment_transaction/mod.rs | 2 + .../transaction.rs | 21 +++-- nssa/src/public_transaction/transaction.rs | 2 +- nssa/src/state.rs | 14 +++- 9 files changed, 87 insertions(+), 41 deletions(-) diff --git a/nssa/Cargo.toml b/nssa/Cargo.toml index 93553a8..72c4fe8 100644 --- a/nssa/Cargo.toml +++ b/nssa/Cargo.toml @@ -14,6 +14,7 @@ secp256k1 = "0.31.1" rand = "0.8" borsh = "1.5.7" hex = "0.4.3" +risc0-binfmt = "3.0.2" [dev-dependencies] test-program-methods = { path = "test_program_methods" } diff --git a/nssa/src/error.rs b/nssa/src/error.rs index 0e85789..8ed9657 100644 --- a/nssa/src/error.rs +++ b/nssa/src/error.rs @@ -48,4 +48,10 @@ pub enum NssaError { #[error("Circuit proving error")] CircuitProvingError(String), + + #[error("Invalid program bytecode")] + InvalidProgramBytecode, + + #[error("Program already exists")] + ProgramAlreadyExists, } diff --git a/nssa/src/lib.rs b/nssa/src/lib.rs index b7e041d..b394cad 100644 --- a/nssa/src/lib.rs +++ b/nssa/src/lib.rs @@ -3,8 +3,8 @@ pub mod error; mod merkle_tree; pub mod privacy_preserving_transaction; pub mod program; -pub mod public_transaction; pub mod program_deployment_transaction; +pub mod public_transaction; mod signature; mod state; diff --git a/nssa/src/privacy_preserving_transaction/transaction.rs b/nssa/src/privacy_preserving_transaction/transaction.rs index cdf02c2..af4ba39 100644 --- a/nssa/src/privacy_preserving_transaction/transaction.rs +++ b/nssa/src/privacy_preserving_transaction/transaction.rs @@ -29,7 +29,7 @@ impl PrivacyPreservingTransaction { pub(crate) fn validate_and_produce_public_state_diff( &self, - state: &mut V01State, + state: &V01State, ) -> Result, NssaError> { let message = &self.message; let witness_set = &self.witness_set; diff --git a/nssa/src/program.rs b/nssa/src/program.rs index 5abc153..17f6d2b 100644 --- a/nssa/src/program.rs +++ b/nssa/src/program.rs @@ -2,10 +2,7 @@ use nssa_core::{ account::{Account, AccountWithMetadata}, program::{InstructionData, ProgramId, ProgramOutput}, }; -use program_methods::{ - AUTHENTICATED_TRANSFER_ELF, AUTHENTICATED_TRANSFER_ID, PINATA_ELF, PINATA_ID, TOKEN_ELF, - TOKEN_ID, -}; +use program_methods::{AUTHENTICATED_TRANSFER_ELF, PINATA_ELF, TOKEN_ELF}; use risc0_zkvm::{ExecutorEnv, ExecutorEnvBuilder, default_executor, serde::to_vec}; use serde::Serialize; @@ -14,16 +11,26 @@ use crate::error::NssaError; #[derive(Debug, PartialEq, Eq)] pub struct Program { id: ProgramId, - elf: &'static [u8], + elf: Vec, } impl Program { + pub(crate) fn new(bytecode: Vec) -> Result { + let binary = risc0_binfmt::ProgramBinary::decode(&bytecode) + .map_err(|_| NssaError::InvalidProgramBytecode)?; + let id = binary + .compute_image_id() + .map_err(|_| NssaError::InvalidProgramBytecode)? + .into(); + Ok(Self { elf: bytecode, id }) + } + pub fn id(&self) -> ProgramId { self.id } - pub(crate) fn elf(&self) -> &'static [u8] { - self.elf + pub(crate) fn elf(&self) -> &[u8] { + &self.elf } pub fn serialize_instruction( @@ -45,7 +52,7 @@ impl Program { // Execute the program (without proving) let executor = default_executor(); let session_info = executor - .execute(env, self.elf) + .execute(env, self.elf()) .map_err(|e| NssaError::ProgramExecutionFailed(e.to_string()))?; // Get outputs @@ -71,33 +78,34 @@ impl Program { } pub fn authenticated_transfer_program() -> Self { - Self { - id: AUTHENTICATED_TRANSFER_ID, - elf: AUTHENTICATED_TRANSFER_ELF, - } + // This unwrap won't panic since the `AUTHENTICATED_TRANSFER_ELF` comes from risc0 build of + // `program_methods` + Self::new(AUTHENTICATED_TRANSFER_ELF.to_vec()).unwrap() } pub fn token() -> Self { - Self { - id: TOKEN_ID, - elf: TOKEN_ELF, - } + // This unwrap won't panic since the `TOKEN_ELF` comes from risc0 build of + // `program_methods` + Self::new(TOKEN_ELF.to_vec()).unwrap() } } // TODO: Testnet only. Refactor to prevent compilation on mainnet. impl Program { pub fn pinata() -> Self { - Self { - id: PINATA_ID, - elf: PINATA_ELF, - } + // This unwrap won't panic since the `PINATA_ELF` comes from risc0 build of + // `program_methods` + Self::new(PINATA_ELF.to_vec()).unwrap() } } #[cfg(test)] mod tests { use nssa_core::account::{Account, AccountId, AccountWithMetadata}; + use program_methods::{ + AUTHENTICATED_TRANSFER_ELF, AUTHENTICATED_TRANSFER_ID, PINATA_ELF, PINATA_ID, TOKEN_ELF, + TOKEN_ID, + }; use crate::program::Program; @@ -108,7 +116,7 @@ mod tests { Program { id: NONCE_CHANGER_ID, - elf: NONCE_CHANGER_ELF, + elf: NONCE_CHANGER_ELF.to_vec(), } } @@ -118,7 +126,7 @@ mod tests { Program { id: EXTRA_OUTPUT_ID, - elf: EXTRA_OUTPUT_ELF, + elf: EXTRA_OUTPUT_ELF.to_vec(), } } @@ -128,7 +136,7 @@ mod tests { Program { id: MISSING_OUTPUT_ID, - elf: MISSING_OUTPUT_ELF, + elf: MISSING_OUTPUT_ELF.to_vec(), } } @@ -138,7 +146,7 @@ mod tests { Program { id: PROGRAM_OWNER_CHANGER_ID, - elf: PROGRAM_OWNER_CHANGER_ELF, + elf: PROGRAM_OWNER_CHANGER_ELF.to_vec(), } } @@ -148,7 +156,7 @@ mod tests { Program { id: SIMPLE_BALANCE_TRANSFER_ID, - elf: SIMPLE_BALANCE_TRANSFER_ELF, + elf: SIMPLE_BALANCE_TRANSFER_ELF.to_vec(), } } @@ -158,7 +166,7 @@ mod tests { Program { id: DATA_CHANGER_ID, - elf: DATA_CHANGER_ELF, + elf: DATA_CHANGER_ELF.to_vec(), } } @@ -168,7 +176,7 @@ mod tests { Program { id: MINTER_ID, - elf: MINTER_ELF, + elf: MINTER_ELF.to_vec(), } } @@ -178,7 +186,7 @@ mod tests { Program { id: BURNER_ID, - elf: BURNER_ELF, + elf: BURNER_ELF.to_vec(), } } } @@ -216,4 +224,18 @@ mod tests { assert_eq!(sender_post, expected_sender_post); assert_eq!(recipient_post, expected_recipient_post); } + + #[test] + fn test_builtin_programs() { + let auth_transfer_program = Program::authenticated_transfer_program(); + let token_program = Program::token(); + let pinata_program = Program::pinata(); + + assert_eq!(auth_transfer_program.id, AUTHENTICATED_TRANSFER_ID); + assert_eq!(auth_transfer_program.elf, AUTHENTICATED_TRANSFER_ELF); + assert_eq!(token_program.id, TOKEN_ID); + assert_eq!(token_program.elf, TOKEN_ELF); + assert_eq!(pinata_program.id, PINATA_ID); + assert_eq!(pinata_program.elf, PINATA_ELF); + } } diff --git a/nssa/src/program_deployment_transaction/mod.rs b/nssa/src/program_deployment_transaction/mod.rs index 6aa1cda..0bf8c7f 100644 --- a/nssa/src/program_deployment_transaction/mod.rs +++ b/nssa/src/program_deployment_transaction/mod.rs @@ -1,2 +1,4 @@ mod message; mod transaction; + +pub use transaction::ProgramDeploymentTransaction; diff --git a/nssa/src/program_deployment_transaction/transaction.rs b/nssa/src/program_deployment_transaction/transaction.rs index 36f3de0..dfd348b 100644 --- a/nssa/src/program_deployment_transaction/transaction.rs +++ b/nssa/src/program_deployment_transaction/transaction.rs @@ -1,8 +1,6 @@ -use std::collections::HashMap; - -use nssa_core::{account::Account, address::Address}; - -use crate::{V01State, error::NssaError, program_deployment_transaction::message::Message}; +use crate::{ + V01State, error::NssaError, program::Program, program_deployment_transaction::message::Message, +}; #[derive(Debug, Clone, PartialEq, Eq)] pub struct ProgramDeploymentTransaction { @@ -13,10 +11,17 @@ impl ProgramDeploymentTransaction { pub fn new(message: Message) -> Self { Self { message } } + pub(crate) fn validate_and_produce_public_state_diff( &self, - state: &mut V01State, - ) -> Result, NssaError> { - todo!() + state: &V01State, + ) -> Result { + // TODO: remove clone + let program = Program::new(self.message.bytecode.clone())?; + if state.programs().contains_key(&program.id()) { + Err(NssaError::ProgramAlreadyExists) + } else { + Ok(program) + } } } diff --git a/nssa/src/public_transaction/transaction.rs b/nssa/src/public_transaction/transaction.rs index d6b9614..92db97e 100644 --- a/nssa/src/public_transaction/transaction.rs +++ b/nssa/src/public_transaction/transaction.rs @@ -102,7 +102,7 @@ impl PublicTransaction { // Check the `program_id` corresponds to a built-in program // Only allowed program so far is the authenticated transfer program - let Some(program) = state.builtin_programs().get(&message.program_id) else { + let Some(program) = state.programs().get(&message.program_id) else { return Err(NssaError::InvalidInput("Unknown program".into())); }; diff --git a/nssa/src/state.rs b/nssa/src/state.rs index b93794c..1819b50 100644 --- a/nssa/src/state.rs +++ b/nssa/src/state.rs @@ -1,6 +1,7 @@ use crate::{ error::NssaError, merkle_tree::MerkleTree, privacy_preserving_transaction::PrivacyPreservingTransaction, program::Program, + program_deployment_transaction::ProgramDeploymentTransaction, public_transaction::PublicTransaction, }; use nssa_core::{ @@ -157,6 +158,15 @@ impl V01State { Ok(()) } + pub fn transition_from_program_deployment_transaction( + &mut self, + tx: &ProgramDeploymentTransaction, + ) -> Result<(), NssaError> { + let program = tx.validate_and_produce_public_state_diff(self)?; + self.insert_program(program); + Ok(()) + } + fn get_account_by_address_mut(&mut self, address: Address) -> &mut Account { self.public_state.entry(address).or_default() } @@ -172,7 +182,7 @@ impl V01State { self.private_state.0.get_proof_for(commitment) } - pub(crate) fn builtin_programs(&self) -> &HashMap { + pub(crate) fn programs(&self) -> &HashMap { &self.programs } @@ -355,7 +365,7 @@ pub mod tests { fn test_builtin_programs_getter() { let state = V01State::new_with_genesis_accounts(&[], &[]); - let builtin_programs = state.builtin_programs(); + let builtin_programs = state.programs(); assert_eq!(builtin_programs, &state.programs); } From bfde33d78d4ef89b840e48e6d76c5dd4db345650 Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Wed, 15 Oct 2025 18:00:35 -0300 Subject: [PATCH 06/17] add add canonical serialization for program deployment txs --- .../src/{test_utils.rs => test_utils/mod.rs} | 0 common/src/transaction.rs | 7 ++ nssa/src/encoding/mod.rs | 1 + .../program_deployment_transaction.rs | 70 +++++++++++++++++++ nssa/src/lib.rs | 1 + .../src/program_deployment_transaction/mod.rs | 1 + .../transaction.rs | 2 +- sequencer_core/src/lib.rs | 7 ++ 8 files changed, 88 insertions(+), 1 deletion(-) rename common/src/{test_utils.rs => test_utils/mod.rs} (100%) create mode 100644 nssa/src/encoding/program_deployment_transaction.rs diff --git a/common/src/test_utils.rs b/common/src/test_utils/mod.rs similarity index 100% rename from common/src/test_utils.rs rename to common/src/test_utils/mod.rs diff --git a/common/src/transaction.rs b/common/src/transaction.rs index 3a2bda1..add67b0 100644 --- a/common/src/transaction.rs +++ b/common/src/transaction.rs @@ -15,6 +15,7 @@ use sha2::digest::typenum::{UInt, UTerm}; pub enum NSSATransaction { Public(nssa::PublicTransaction), PrivacyPreserving(nssa::PrivacyPreservingTransaction), + ProgramDeployment(nssa::ProgramDeploymentTransaction), } impl From for NSSATransaction { @@ -41,6 +42,7 @@ pub type Tag = u8; pub enum TxKind { Public, PrivacyPreserving, + ProgramDeployment, } #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize)] @@ -62,6 +64,10 @@ impl From for EncodedTransaction { tx_kind: TxKind::PrivacyPreserving, encoded_transaction_data: tx.to_bytes(), }, + NSSATransaction::ProgramDeployment(tx) => Self { + tx_kind: TxKind::ProgramDeployment, + encoded_transaction_data: todo!(), + }, } } } @@ -77,6 +83,7 @@ impl TryFrom<&EncodedTransaction> for NSSATransaction { nssa::PrivacyPreservingTransaction::from_bytes(&value.encoded_transaction_data) .map(|tx| tx.into()) } + TxKind::ProgramDeployment => todo!(), } } } diff --git a/nssa/src/encoding/mod.rs b/nssa/src/encoding/mod.rs index 5ff45e2..383fb9a 100644 --- a/nssa/src/encoding/mod.rs +++ b/nssa/src/encoding/mod.rs @@ -1,2 +1,3 @@ pub mod privacy_preserving_transaction; pub mod public_transaction; +pub mod program_deployment_transaction; diff --git a/nssa/src/encoding/program_deployment_transaction.rs b/nssa/src/encoding/program_deployment_transaction.rs new file mode 100644 index 0000000..1a31e59 --- /dev/null +++ b/nssa/src/encoding/program_deployment_transaction.rs @@ -0,0 +1,70 @@ +// TODO: Consider switching to deriving Borsh + +use std::io::{Cursor, Read}; + +use nssa_core::program::ProgramId; + +use crate::{ + Address, ProgramDeploymentTransaction, PublicKey, PublicTransaction, Signature, + error::NssaError, program_deployment_transaction::Message, +}; + +const MESSAGE_ENCODING_PREFIX_LEN: usize = 22; +const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = b"\x02/NSSA/v0.1/TxMessage/"; + +impl Message { + /// Serializes a `Message` into bytes in the following layout: + /// PREFIX || bytecode_len (4 bytes LE) || + /// Integers are encoded in little-endian byte order, and fields appear in the above order. + pub(crate) fn to_bytes(&self) -> Vec { + let mut bytes = MESSAGE_ENCODING_PREFIX.to_vec(); + let bytecode_len = self.bytecode.len() as u32; + bytes.extend(&bytecode_len.to_le_bytes()); + bytes.extend(&self.bytecode); + bytes + } + + pub(crate) fn from_cursor(cursor: &mut Cursor<&[u8]>) -> Result { + let prefix = { + let mut this = [0u8; MESSAGE_ENCODING_PREFIX_LEN]; + cursor.read_exact(&mut this)?; + this + }; + if &prefix != MESSAGE_ENCODING_PREFIX { + return Err(NssaError::TransactionDeserializationError( + "Invalid public message prefix".to_string(), + )); + } + let bytecode_len = u32_from_cursor(cursor)?; + let mut bytecode = Vec::with_capacity(bytecode_len as usize); + let num_bytes = cursor.read(&mut bytecode)?; + if num_bytes != bytecode_len as usize { + return Err(NssaError::TransactionDeserializationError( + "Invalid number of bytes".to_string(), + )); + } + Ok(Self { bytecode }) + } +} + +impl ProgramDeploymentTransaction { + pub fn to_bytes(&self) -> Vec { + self.message.to_bytes() + } + + pub fn from_bytes(bytes: &[u8]) -> Result { + let mut cursor = Cursor::new(bytes); + Self::from_cursor(&mut cursor) + } + + pub fn from_cursor(cursor: &mut Cursor<&[u8]>) -> Result { + let message = Message::from_cursor(cursor)?; + Ok(Self::new(message)) + } +} + +fn u32_from_cursor(cursor: &mut Cursor<&[u8]>) -> Result { + let mut word_buf = [0u8; 4]; + cursor.read_exact(&mut word_buf)?; + Ok(u32::from_le_bytes(word_buf)) +} diff --git a/nssa/src/lib.rs b/nssa/src/lib.rs index b394cad..d357daf 100644 --- a/nssa/src/lib.rs +++ b/nssa/src/lib.rs @@ -14,6 +14,7 @@ pub use privacy_preserving_transaction::{ PrivacyPreservingTransaction, circuit::execute_and_prove, }; pub use public_transaction::PublicTransaction; +pub use program_deployment_transaction::ProgramDeploymentTransaction; pub use signature::PrivateKey; pub use signature::PublicKey; pub use signature::Signature; diff --git a/nssa/src/program_deployment_transaction/mod.rs b/nssa/src/program_deployment_transaction/mod.rs index 0bf8c7f..42c6cd8 100644 --- a/nssa/src/program_deployment_transaction/mod.rs +++ b/nssa/src/program_deployment_transaction/mod.rs @@ -2,3 +2,4 @@ mod message; mod transaction; pub use transaction::ProgramDeploymentTransaction; +pub use message::Message; diff --git a/nssa/src/program_deployment_transaction/transaction.rs b/nssa/src/program_deployment_transaction/transaction.rs index dfd348b..87724c5 100644 --- a/nssa/src/program_deployment_transaction/transaction.rs +++ b/nssa/src/program_deployment_transaction/transaction.rs @@ -4,7 +4,7 @@ use crate::{ #[derive(Debug, Clone, PartialEq, Eq)] pub struct ProgramDeploymentTransaction { - message: Message, + pub(crate) message: Message, } impl ProgramDeploymentTransaction { diff --git a/sequencer_core/src/lib.rs b/sequencer_core/src/lib.rs index 7da9fab..172d41e 100644 --- a/sequencer_core/src/lib.rs +++ b/sequencer_core/src/lib.rs @@ -98,6 +98,7 @@ impl SequencerCore { Err(TransactionMalformationErrorKind::InvalidSignature) } } + NSSATransaction::ProgramDeployment(program_deployment_transaction) => todo!(), } } @@ -142,6 +143,12 @@ impl SequencerCore { .transition_from_privacy_preserving_transaction(tx) .inspect_err(|err| warn!("Error at transition {err:#?}"))?; } + NSSATransaction::ProgramDeployment(tx) => { + self.store + .state + .transition_from_program_deployment_transaction(tx) + .inspect_err(|err| warn!("Error at transition {err:#?}"))?; + } } Ok(tx) From 942e90ae2a526b572421b35ad61196ac30431eb4 Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Wed, 15 Oct 2025 20:14:19 -0300 Subject: [PATCH 07/17] add sequencer methods --- common/src/sequencer_client/mod.rs | 19 +++++++++++++++ .../src/{test_utils/mod.rs => test_utils.rs} | 1 + common/src/transaction.rs | 13 +++++++++-- integration_tests/src/lib.rs | 22 +++++++++++++++++- .../src/simple_balance_transfer.bin | Bin 0 -> 368396 bytes .../src/bin/privacy_preserving_circuit.rs | 3 --- .../program_deployment_transaction.rs | 20 +++++++++++++++- .../program_deployment_transaction/message.rs | 6 +++++ nssa/src/public_transaction/transaction.rs | 3 +-- sequencer_core/src/lib.rs | 2 +- 10 files changed, 79 insertions(+), 10 deletions(-) rename common/src/{test_utils/mod.rs => test_utils.rs} (99%) create mode 100644 integration_tests/src/simple_balance_transfer.bin diff --git a/common/src/sequencer_client/mod.rs b/common/src/sequencer_client/mod.rs index 1aec903..5f0bb85 100644 --- a/common/src/sequencer_client/mod.rs +++ b/common/src/sequencer_client/mod.rs @@ -237,4 +237,23 @@ impl SequencerClient { Ok(resp_deser) } + + pub async fn send_tx_program( + &self, + transaction: nssa::ProgramDeploymentTransaction, + ) -> Result { + let transaction = EncodedTransaction::from(NSSATransaction::ProgramDeployment(transaction)); + + let tx_req = SendTxRequest { + transaction: borsh::to_vec(&transaction).unwrap(), + }; + + let req = serde_json::to_value(tx_req)?; + + let resp = self.call_method_with_payload("send_tx", req).await?; + + let resp_deser = serde_json::from_value(resp)?; + + Ok(resp_deser) + } } diff --git a/common/src/test_utils/mod.rs b/common/src/test_utils.rs similarity index 99% rename from common/src/test_utils/mod.rs rename to common/src/test_utils.rs index 9d68db8..9678580 100644 --- a/common/src/test_utils/mod.rs +++ b/common/src/test_utils.rs @@ -68,3 +68,4 @@ pub fn create_transaction_native_token_transfer( EncodedTransaction::from(NSSATransaction::Public(nssa_tx)) } + diff --git a/common/src/transaction.rs b/common/src/transaction.rs index add67b0..0a6c057 100644 --- a/common/src/transaction.rs +++ b/common/src/transaction.rs @@ -30,6 +30,12 @@ impl From for NSSATransaction { } } +impl From for NSSATransaction { + fn from(value: nssa::ProgramDeploymentTransaction) -> Self { + Self::ProgramDeployment(value) + } +} + use crate::TreeHashType; pub type CipherText = Vec; @@ -66,7 +72,7 @@ impl From for EncodedTransaction { }, NSSATransaction::ProgramDeployment(tx) => Self { tx_kind: TxKind::ProgramDeployment, - encoded_transaction_data: todo!(), + encoded_transaction_data: tx.to_bytes(), }, } } @@ -83,7 +89,10 @@ impl TryFrom<&EncodedTransaction> for NSSATransaction { nssa::PrivacyPreservingTransaction::from_bytes(&value.encoded_transaction_data) .map(|tx| tx.into()) } - TxKind::ProgramDeployment => todo!(), + TxKind::ProgramDeployment => { + nssa::ProgramDeploymentTransaction::from_bytes(&value.encoded_transaction_data) + .map(|tx| tx.into()) + } } } } diff --git a/integration_tests/src/lib.rs b/integration_tests/src/lib.rs index 1690445..85cb7a1 100644 --- a/integration_tests/src/lib.rs +++ b/integration_tests/src/lib.rs @@ -9,7 +9,7 @@ use common::{ transaction::{EncodedTransaction, NSSATransaction}, }; use log::{info, warn}; -use nssa::{Address, PrivacyPreservingTransaction, program::Program}; +use nssa::{Address, PrivacyPreservingTransaction, ProgramDeploymentTransaction, program::Program}; use nssa_core::{ Commitment, NullifierPublicKey, encryption::shared_key_derivation::Secp256k1Point, }; @@ -42,6 +42,8 @@ pub const ACC_RECEIVER_PRIVATE: &str = pub const TIME_TO_WAIT_FOR_BLOCK_SECONDS: u64 = 12; +pub const NSSA_PROGRAM_FOR_TEST: &'static [u8] = include_bytes!("simple_balance_transfer.bin"); + #[allow(clippy::type_complexity)] pub async fn pre_test( home_dir: PathBuf, @@ -791,6 +793,20 @@ pub async fn test_pinata() { info!("Success!"); } +pub async fn test_program_deployment() { + info!("test program deployment"); + println!("{}", NSSA_PROGRAM_FOR_TEST.len()); + let bytecode = NSSA_PROGRAM_FOR_TEST.to_vec(); + let message = nssa::program_deployment_transaction::Message::new(bytecode); + let transaction = ProgramDeploymentTransaction::new(message); + + let wallet_config = fetch_config().unwrap(); + let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); + + let response = seq_client.send_tx_program(transaction).await.unwrap(); + println!("response: {:?}", response); +} + macro_rules! test_cleanup_wrap { ($home_dir:ident, $test_func:ident) => {{ let res = pre_test($home_dir.clone()).await.unwrap(); @@ -871,6 +887,9 @@ pub async fn main_tests_runner() -> Result<()> { "test_pinata" => { test_cleanup_wrap!(home_dir, test_pinata); } + "test_program_deployment" => { + test_cleanup_wrap!(home_dir, test_program_deployment); + } "all" => { test_cleanup_wrap!(home_dir, test_success_move_to_another_account); test_cleanup_wrap!(home_dir, test_success); @@ -902,6 +921,7 @@ pub async fn main_tests_runner() -> Result<()> { test_success_private_transfer_to_another_owned_account_claiming_path ); test_cleanup_wrap!(home_dir, test_pinata); + test_cleanup_wrap!(home_dir, test_program_deployment); } "all_private" => { test_cleanup_wrap!( diff --git a/integration_tests/src/simple_balance_transfer.bin b/integration_tests/src/simple_balance_transfer.bin new file mode 100644 index 0000000000000000000000000000000000000000..f4e72c90d6d113215809933309612b08e599ae47 GIT binary patch literal 368396 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

B~-L6NJ3?aewN!&u4eyGS%LZkCTt>^WC%Y92K94 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 literal 0 HcmV?d00001 diff --git a/nssa/program_methods/guest/src/bin/privacy_preserving_circuit.rs b/nssa/program_methods/guest/src/bin/privacy_preserving_circuit.rs index 266db1a..a1aa8c9 100644 --- a/nssa/program_methods/guest/src/bin/privacy_preserving_circuit.rs +++ b/nssa/program_methods/guest/src/bin/privacy_preserving_circuit.rs @@ -21,9 +21,6 @@ fn main() { program_id, } = env::read(); - // TODO: Check that `program_execution_proof` is one of the allowed built-in programs - // assert_eq!(program_id, AUTHENTICATED_TRANSFER_PROGRAM_ID); - // Check that `program_output` is consistent with the execution of the corresponding program. env::verify(program_id, &to_vec(&program_output).unwrap()).unwrap(); diff --git a/nssa/src/encoding/program_deployment_transaction.rs b/nssa/src/encoding/program_deployment_transaction.rs index 1a31e59..70bd4ea 100644 --- a/nssa/src/encoding/program_deployment_transaction.rs +++ b/nssa/src/encoding/program_deployment_transaction.rs @@ -36,9 +36,10 @@ impl Message { )); } let bytecode_len = u32_from_cursor(cursor)?; - let mut bytecode = Vec::with_capacity(bytecode_len as usize); + let mut bytecode = vec![0; bytecode_len as usize]; let num_bytes = cursor.read(&mut bytecode)?; if num_bytes != bytecode_len as usize { + println!("num bytes: {}", num_bytes); return Err(NssaError::TransactionDeserializationError( "Invalid number of bytes".to_string(), )); @@ -68,3 +69,20 @@ fn u32_from_cursor(cursor: &mut Cursor<&[u8]>) -> Result { cursor.read_exact(&mut word_buf)?; Ok(u32::from_le_bytes(word_buf)) } + +#[cfg(test)] +mod tests { + use std::io::Cursor; + + use crate::{ProgramDeploymentTransaction, program_deployment_transaction::Message}; + + #[test] + fn test_roundtrip() { + let message = Message::new(vec![0xca, 0xfe, 0xca, 0xfe, 0x01, 0x02, 0x03]); + let tx = ProgramDeploymentTransaction::new(message); + let bytes = tx.to_bytes(); + let mut cursor = Cursor::new(bytes.as_ref()); + let tx_from_cursor = ProgramDeploymentTransaction::from_cursor(&mut cursor).unwrap(); + assert_eq!(tx, tx_from_cursor); + } +} diff --git a/nssa/src/program_deployment_transaction/message.rs b/nssa/src/program_deployment_transaction/message.rs index 4601975..6a5c670 100644 --- a/nssa/src/program_deployment_transaction/message.rs +++ b/nssa/src/program_deployment_transaction/message.rs @@ -2,3 +2,9 @@ pub struct Message { pub(crate) bytecode: Vec, } + +impl Message { + pub fn new(bytecode: Vec) -> Self { + Self { bytecode } + } +} diff --git a/nssa/src/public_transaction/transaction.rs b/nssa/src/public_transaction/transaction.rs index 92db97e..ea9c430 100644 --- a/nssa/src/public_transaction/transaction.rs +++ b/nssa/src/public_transaction/transaction.rs @@ -100,8 +100,7 @@ impl PublicTransaction { }) .collect(); - // Check the `program_id` corresponds to a built-in program - // Only allowed program so far is the authenticated transfer program + // Check the `program_id` corresponds to a deployed program let Some(program) = state.programs().get(&message.program_id) else { return Err(NssaError::InvalidInput("Unknown program".into())); }; diff --git a/sequencer_core/src/lib.rs b/sequencer_core/src/lib.rs index 172d41e..f7fc9be 100644 --- a/sequencer_core/src/lib.rs +++ b/sequencer_core/src/lib.rs @@ -98,7 +98,7 @@ impl SequencerCore { Err(TransactionMalformationErrorKind::InvalidSignature) } } - NSSATransaction::ProgramDeployment(program_deployment_transaction) => todo!(), + NSSATransaction::ProgramDeployment(tx) => Ok(NSSATransaction::ProgramDeployment(tx)), } } From 9614c3143bd7c305546b4c203a4501f54f4e1c69 Mon Sep 17 00:00:00 2001 From: Oleksandr Pravdyvyi Date: Thu, 16 Oct 2025 15:58:35 +0300 Subject: [PATCH 08/17] feat: integration test and async fs --- integration_tests/src/lib.rs | 196 ++++++++++++++---- wallet/src/cli/chain.rs | 6 +- .../src/cli/native_token_transfer_program.rs | 12 +- wallet/src/cli/pinata_program.rs | 2 +- wallet/src/cli/token_program.rs | 6 +- wallet/src/helperfunctions.rs | 21 +- wallet/src/lib.rs | 23 +- 7 files changed, 191 insertions(+), 75 deletions(-) diff --git a/integration_tests/src/lib.rs b/integration_tests/src/lib.rs index a560e9f..a1aa3e0 100644 --- a/integration_tests/src/lib.rs +++ b/integration_tests/src/lib.rs @@ -118,7 +118,7 @@ pub async fn test_success() { }, ); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); @@ -152,13 +152,13 @@ pub async fn test_success_move_to_another_account() { RegisterSubcommand::RegisterAccountPublic {}, )); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); wallet::execute_subcommand(command).await.unwrap(); - let persistent_accounts = fetch_persistent_accounts().unwrap(); + let persistent_accounts = fetch_persistent_accounts().await.unwrap(); let mut new_persistent_account_addr = String::new(); @@ -216,7 +216,7 @@ pub async fn test_failure() { }, ); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); @@ -256,7 +256,7 @@ pub async fn test_success_two_transactions() { }, ); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); @@ -317,7 +317,7 @@ pub async fn test_success_two_transactions() { pub async fn test_get_account() { info!("test_get_account"); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); let account = seq_client @@ -338,7 +338,7 @@ pub async fn test_get_account() { /// This test creates a new token using the token program. After creating the token, the test executes a /// token transfer to a new account. pub async fn test_success_token_program() { - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); // Create new account for the token definition wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( @@ -359,7 +359,7 @@ pub async fn test_success_token_program() { .await .unwrap(); - let persistent_accounts = fetch_persistent_accounts().unwrap(); + let persistent_accounts = fetch_persistent_accounts().await.unwrap(); let mut new_persistent_accounts_addr = Vec::new(); @@ -485,7 +485,7 @@ pub async fn test_success_token_program() { /// This test creates a new private token using the token program. After creating the token, the test executes a /// private token transfer to a new account. All accounts are owned except definition. pub async fn test_success_token_program_private_owned() { - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); // Create new account for the token definition (public) let SubcommandReturnValue::RegisterAccount { @@ -556,8 +556,10 @@ pub async fn test_success_token_program_private_owned() { ] ); - let wallet_config = fetch_config().unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_config = fetch_config().await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&supply_addr) @@ -579,8 +581,10 @@ pub async fn test_success_token_program_private_owned() { info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let wallet_config = fetch_config().unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_config = fetch_config().await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&supply_addr) @@ -607,8 +611,10 @@ pub async fn test_success_token_program_private_owned() { info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let wallet_config = fetch_config().unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_config = fetch_config().await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&supply_addr) @@ -624,7 +630,7 @@ pub async fn test_success_token_program_private_owned() { /// This test creates a new private token using the token program. After creating the token, the test executes a /// private token transfer to a new account. pub async fn test_success_token_program_private_claiming_path() { - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); // Create new account for the token definition (public) let SubcommandReturnValue::RegisterAccount { @@ -695,8 +701,10 @@ pub async fn test_success_token_program_private_claiming_path() { ] ); - let wallet_config = fetch_config().unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_config = fetch_config().await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&supply_addr) @@ -740,8 +748,10 @@ pub async fn test_success_token_program_private_claiming_path() { wallet::execute_subcommand(command).await.unwrap(); - let wallet_config = fetch_config().unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_config = fetch_config().await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&supply_addr) @@ -772,9 +782,11 @@ pub async fn test_success_private_transfer_to_another_owned_account() { info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&from) @@ -812,9 +824,11 @@ pub async fn test_success_private_transfer_to_another_foreign_account() { info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&from) @@ -844,9 +858,11 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat panic!("FAILED TO REGISTER ACCOUNT"); }; - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config.clone()).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config.clone()) + .await + .unwrap(); let (to_keys, _) = wallet_storage .storage @@ -880,7 +896,9 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat }, )); wallet::execute_subcommand(command).await.unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&from) @@ -899,6 +917,78 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat info!("Success!"); } +pub async fn test_success_private_transfer_to_another_owned_account_cont_run_path() { + info!("test_success_private_transfer_to_another_owned_account_cont_run_path"); + let continious_run_handle = tokio::spawn(wallet::execute_continious_run()); + + let from: Address = ACC_SENDER_PRIVATE.parse().unwrap(); + + let command = Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPrivate {}, + )); + + let sub_ret = wallet::execute_subcommand(command).await.unwrap(); + let SubcommandReturnValue::RegisterAccount { addr: to_addr } = sub_ret else { + panic!("FAILED TO REGISTER ACCOUNT"); + }; + + let wallet_config = fetch_config().await.unwrap(); + let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config.clone()) + .await + .unwrap(); + + let (to_keys, _) = wallet_storage + .storage + .user_data + .user_private_accounts + .get(&to_addr) + .cloned() + .unwrap(); + + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Private( + NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateForeignAccount { + from: from.to_string(), + to_npk: hex::encode(to_keys.nullifer_public_key.0), + to_ipk: hex::encode(to_keys.incoming_viewing_public_key.0), + amount: 100, + }, + )); + + let sub_ret = wallet::execute_subcommand(command).await.unwrap(); + let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } = sub_ret else { + panic!("FAILED TO SEND TX"); + }; + + let tx = fetch_privacy_preserving_tx(&seq_client, tx_hash.clone()).await; + + println!("Waiting for next blocks to check if continoius run fetch account"); + tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; + tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; + + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); + + let new_commitment1 = wallet_storage + .get_private_account_commitment(&from) + .unwrap(); + assert_eq!(tx.message.new_commitments[0], new_commitment1); + + assert_eq!(tx.message.new_commitments.len(), 2); + for commitment in tx.message.new_commitments.into_iter() { + assert!(verify_commitment_is_in_state(commitment, &seq_client).await); + } + + let to_res_acc = wallet_storage.get_account_private(&to_addr).unwrap(); + + assert_eq!(to_res_acc.balance, 100); + + continious_run_handle.abort(); + + info!("Success!"); +} + pub async fn test_success_deshielded_transfer_to_another_account() { info!("test_success_deshielded_transfer_to_another_account"); let from: Address = ACC_SENDER_PRIVATE.parse().unwrap(); @@ -911,9 +1001,11 @@ pub async fn test_success_deshielded_transfer_to_another_account() { }, ); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config.clone()).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config.clone()) + .await + .unwrap(); let from_acc = wallet_storage.get_account_private(&from).unwrap(); assert_eq!(from_acc.balance, 10000); @@ -923,7 +1015,9 @@ pub async fn test_success_deshielded_transfer_to_another_account() { info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let from_acc = wallet_storage.get_account_private(&from).unwrap(); let new_commitment = wallet_storage @@ -954,7 +1048,7 @@ pub async fn test_success_shielded_transfer_to_another_owned_account() { }, )); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); wallet::execute_subcommand(command).await.unwrap(); @@ -962,8 +1056,10 @@ pub async fn test_success_shielded_transfer_to_another_owned_account() { info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let wallet_config = fetch_config().unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_config = fetch_config().await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let acc_to = wallet_storage.get_account_private(&to).unwrap(); let new_commitment = wallet_storage.get_private_account_commitment(&to).unwrap(); @@ -995,7 +1091,7 @@ pub async fn test_success_shielded_transfer_to_another_foreign_account() { amount: 100, })); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); @@ -1037,7 +1133,7 @@ pub async fn test_pinata() { }, )); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); @@ -1085,7 +1181,7 @@ pub async fn test_pinata_private_receiver() { }, )); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); @@ -1120,9 +1216,11 @@ pub async fn test_pinata_private_receiver() { )); wallet::execute_subcommand(command).await.unwrap(); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&ACC_SENDER_PRIVATE.parse().unwrap()) @@ -1159,7 +1257,7 @@ pub async fn test_pinata_private_receiver_new_account() { }, )); - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); @@ -1181,9 +1279,11 @@ pub async fn test_pinata_private_receiver_new_account() { .unwrap() .balance; - let wallet_config = fetch_config().unwrap(); + let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&winner_addr) @@ -1287,6 +1387,12 @@ pub async fn main_tests_runner() -> Result<()> { "test_pinata_private_receiver_new_account" => { test_cleanup_wrap!(home_dir, test_pinata_private_receiver_new_account); } + "test_success_private_transfer_to_another_owned_account_cont_run_path" => { + test_cleanup_wrap!( + home_dir, + test_success_private_transfer_to_another_owned_account_cont_run_path + ); + } "all" => { test_cleanup_wrap!(home_dir, test_success_move_to_another_account); test_cleanup_wrap!(home_dir, test_success); @@ -1322,6 +1428,10 @@ pub async fn main_tests_runner() -> Result<()> { test_cleanup_wrap!(home_dir, test_success_token_program_private_owned); test_cleanup_wrap!(home_dir, test_success_token_program_private_claiming_path); test_cleanup_wrap!(home_dir, test_pinata_private_receiver_new_account); + test_cleanup_wrap!( + home_dir, + test_success_private_transfer_to_another_owned_account_cont_run_path + ); } "all_private" => { test_cleanup_wrap!( @@ -1352,6 +1462,10 @@ pub async fn main_tests_runner() -> Result<()> { test_cleanup_wrap!(home_dir, test_success_token_program_private_owned); test_cleanup_wrap!(home_dir, test_success_token_program_private_claiming_path); test_cleanup_wrap!(home_dir, test_pinata_private_receiver_new_account); + test_cleanup_wrap!( + home_dir, + test_success_private_transfer_to_another_owned_account_cont_run_path + ); } _ => { anyhow::bail!("Unknown test name"); diff --git a/wallet/src/cli/chain.rs b/wallet/src/cli/chain.rs index ad58301..258c545 100644 --- a/wallet/src/cli/chain.rs +++ b/wallet/src/cli/chain.rs @@ -180,7 +180,7 @@ impl WalletSubcommand for FetchSubcommand { .insert_private_account_data(acc_addr, res_acc_to); } - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); @@ -201,7 +201,7 @@ impl WalletSubcommand for RegisterSubcommand { println!("Generated new account with addr {addr}"); - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); @@ -223,7 +223,7 @@ impl WalletSubcommand for RegisterSubcommand { hex::encode(key.incoming_viewing_public_key.to_bytes()) ); - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); diff --git a/wallet/src/cli/native_token_transfer_program.rs b/wallet/src/cli/native_token_transfer_program.rs index 6d43d64..eb6310c 100644 --- a/wallet/src/cli/native_token_transfer_program.rs +++ b/wallet/src/cli/native_token_transfer_program.rs @@ -152,7 +152,7 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommandPrivate { .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; } - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); @@ -194,7 +194,7 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommandPrivate { .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; } - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); @@ -240,7 +240,7 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommandShielded { .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; } - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); @@ -273,7 +273,7 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommandShielded { let tx_hash = res.tx_hash; - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); @@ -323,7 +323,7 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommand { )?; } - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); @@ -347,7 +347,7 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommand { println!("Transaction data is {transfer_tx:?}"); - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); diff --git a/wallet/src/cli/pinata_program.rs b/wallet/src/cli/pinata_program.rs index b197ae0..6ccfb97 100644 --- a/wallet/src/cli/pinata_program.rs +++ b/wallet/src/cli/pinata_program.rs @@ -131,7 +131,7 @@ impl WalletSubcommand for PinataProgramSubcommandPrivate { )?; } - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); diff --git a/wallet/src/cli/token_program.rs b/wallet/src/cli/token_program.rs index 7a17730..7bd3e88 100644 --- a/wallet/src/cli/token_program.rs +++ b/wallet/src/cli/token_program.rs @@ -174,7 +174,7 @@ impl WalletSubcommand for TokenProgramSubcommandPrivate { )?; } - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); @@ -231,7 +231,7 @@ impl WalletSubcommand for TokenProgramSubcommandPrivate { )?; } - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); @@ -281,7 +281,7 @@ impl WalletSubcommand for TokenProgramSubcommandPrivate { )?; } - let path = wallet_core.store_persistent_accounts()?; + let path = wallet_core.store_persistent_accounts().await?; println!("Stored persistent accounts at {path:#?}"); diff --git a/wallet/src/helperfunctions.rs b/wallet/src/helperfunctions.rs index 20f4eec..a67b8ec 100644 --- a/wallet/src/helperfunctions.rs +++ b/wallet/src/helperfunctions.rs @@ -1,7 +1,8 @@ use base64::{Engine, engine::general_purpose::STANDARD as BASE64}; use nssa_core::account::Nonce; use rand::{RngCore, rngs::OsRng}; -use std::{fs::File, io::BufReader, path::PathBuf, str::FromStr}; +use std::{path::PathBuf, str::FromStr}; +use tokio::io::AsyncReadExt; use anyhow::Result; use key_protocol::key_protocol_core::NSSAUserData; @@ -22,25 +23,25 @@ pub fn get_home() -> Result { } /// Fetch config from `NSSA_WALLET_HOME_DIR` -pub fn fetch_config() -> Result { +pub async fn fetch_config() -> Result { let config_home = get_home()?; - let file = File::open(config_home.join("wallet_config.json"))?; - let reader = BufReader::new(file); + let config_contents = tokio::fs::read(config_home.join("wallet_config.json")).await?; - Ok(serde_json::from_reader(reader)?) + Ok(serde_json::from_slice(&config_contents)?) } /// Fetch list of accounts stored at `NSSA_WALLET_HOME_DIR/curr_accounts.json` /// /// If file not present, it is considered as empty list of persistent accounts -pub fn fetch_persistent_accounts() -> Result> { +pub async fn fetch_persistent_accounts() -> Result> { let home = get_home()?; let accs_path = home.join("curr_accounts.json"); + let mut persistent_accounts_content = vec![]; - match File::open(accs_path) { - Ok(file) => { - let reader = BufReader::new(file); - Ok(serde_json::from_reader(reader)?) + match tokio::fs::File::open(accs_path).await { + Ok(mut file) => { + file.read_to_end(&mut persistent_accounts_content).await?; + Ok(serde_json::from_slice(&persistent_accounts_content)?) } Err(err) => match err.kind() { std::io::ErrorKind::NotFound => Ok(vec![]), diff --git a/wallet/src/lib.rs b/wallet/src/lib.rs index ff17a10..ae96064 100644 --- a/wallet/src/lib.rs +++ b/wallet/src/lib.rs @@ -1,4 +1,4 @@ -use std::{fs::File, io::Write, path::PathBuf, sync::Arc}; +use std::{path::PathBuf, sync::Arc}; use base64::{Engine, engine::general_purpose::STANDARD as BASE64}; use common::{ @@ -15,6 +15,7 @@ use nssa::{Account, Address, privacy_preserving_transaction::message::EncryptedA use clap::{Parser, Subcommand}; use nssa_core::{Commitment, MembershipProof}; +use tokio::io::AsyncWriteExt; use crate::cli::{ WalletSubcommand, chain::ChainSubcommand, @@ -47,13 +48,13 @@ pub struct WalletCore { } impl WalletCore { - pub fn start_from_config_update_chain(config: WalletConfig) -> Result { + pub async fn start_from_config_update_chain(config: WalletConfig) -> Result { let client = Arc::new(SequencerClient::new(config.sequencer_addr.clone())?); let tx_poller = TxPoller::new(config.clone(), client.clone()); let mut storage = WalletChainStore::new(config)?; - let persistent_accounts = fetch_persistent_accounts()?; + let persistent_accounts = fetch_persistent_accounts().await?; for pers_acc_data in persistent_accounts { storage.insert_account_data(pers_acc_data); } @@ -66,15 +67,15 @@ impl WalletCore { } ///Store persistent accounts at home - pub fn store_persistent_accounts(&self) -> Result { + pub async fn store_persistent_accounts(&self) -> Result { let home = get_home()?; let accs_path = home.join("curr_accounts.json"); let data = produce_data_for_storage(&self.storage.user_data); let accs = serde_json::to_vec_pretty(&data)?; - let mut accs_file = File::create(accs_path.as_path())?; - accs_file.write_all(&accs)?; + let mut accs_file = tokio::fs::File::create(accs_path.as_path()).await?; + accs_file.write_all(&accs).await?; info!("Stored accounts data at {accs_path:#?}"); @@ -221,8 +222,8 @@ pub enum SubcommandReturnValue { } pub async fn execute_subcommand(command: Command) -> Result { - let wallet_config = fetch_config()?; - let mut wallet_core = WalletCore::start_from_config_update_chain(wallet_config)?; + let wallet_config = fetch_config().await?; + let mut wallet_core = WalletCore::start_from_config_update_chain(wallet_config).await?; let subcommand_ret = match command { Command::Transfer(transfer_subcommand) => { @@ -247,9 +248,9 @@ pub async fn execute_subcommand(command: Command) -> Result Result<()> { - let config = fetch_config()?; + let config = fetch_config().await?; let seq_client = Arc::new(SequencerClient::new(config.sequencer_addr.clone())?); - let mut wallet_core = WalletCore::start_from_config_update_chain(config.clone())?; + let mut wallet_core = WalletCore::start_from_config_update_chain(config.clone()).await?; let mut latest_block_num = seq_client.get_last_block().await?.last_block; let mut curr_last_block = latest_block_num; @@ -312,7 +313,7 @@ pub async fn execute_continious_run() -> Result<()> { } } - wallet_core.store_persistent_accounts()?; + wallet_core.store_persistent_accounts().await?; println!( "Block at id {block_id} with timestamp {} parsed", From ba20728f400d69c02a045aeb53ebff28fccc965f Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Thu, 16 Oct 2025 16:19:03 -0300 Subject: [PATCH 09/17] update version tags in domain separator --- .../debug/sequencer/sequencer_config.json | 4 ++-- .../configs/debug/wallet/wallet_config.json | 8 ++++---- integration_tests/src/lib.rs | 8 ++++---- nssa/core/src/encryption/mod.rs | 2 +- nssa/core/src/nullifier.rs | 18 +++++++++--------- .../encoding/privacy_preserving_transaction.rs | 4 ++-- .../encoding/program_deployment_transaction.rs | 9 +++------ nssa/src/encoding/public_transaction.rs | 4 ++-- .../privacy_preserving_transaction/message.rs | 6 +++--- nssa/src/program.rs | 5 +++++ nssa/src/public_transaction/transaction.rs | 8 ++++---- nssa/src/signature/public_key.rs | 2 +- sequencer_core/src/lib.rs | 8 ++++---- sequencer_rpc/src/process.rs | 12 ++++++------ .../configs/debug/sequencer_config.json | 4 ++-- wallet/src/chain_storage/mod.rs | 4 ++-- 16 files changed, 54 insertions(+), 52 deletions(-) diff --git a/integration_tests/configs/debug/sequencer/sequencer_config.json b/integration_tests/configs/debug/sequencer/sequencer_config.json index 87624ae..2a2037d 100644 --- a/integration_tests/configs/debug/sequencer/sequencer_config.json +++ b/integration_tests/configs/debug/sequencer/sequencer_config.json @@ -8,11 +8,11 @@ "port": 3040, "initial_accounts": [ { - "addr": "0eee24287296ba55278f1e5403be014754866366388730303c2889be17ada065", + "addr": "d07ad2e84b27fa00c262f0a1eea0ff35ca0973547e6a106f72f193c2dc838b44", "balance": 10000 }, { - "addr": "9e3d8e654d440e95293aa2dceceb137899a59535e952f747068e7a0ee30965f2", + "addr": "e7ae77c5ef1a05999344af499fc78a1705398d62ed06cf2e1479f6def89a39bc", "balance": 20000 } ], diff --git a/integration_tests/configs/debug/wallet/wallet_config.json b/integration_tests/configs/debug/wallet/wallet_config.json index 09209f6..0081da6 100644 --- a/integration_tests/configs/debug/wallet/wallet_config.json +++ b/integration_tests/configs/debug/wallet/wallet_config.json @@ -9,7 +9,7 @@ "initial_accounts": [ { "Public": { - "address": "0eee24287296ba55278f1e5403be014754866366388730303c2889be17ada065", + "address": "d07ad2e84b27fa00c262f0a1eea0ff35ca0973547e6a106f72f193c2dc838b44", "pub_sign_key": [ 1, 1, @@ -48,7 +48,7 @@ }, { "Public": { - "address": "9e3d8e654d440e95293aa2dceceb137899a59535e952f747068e7a0ee30965f2", + "address": "e7ae77c5ef1a05999344af499fc78a1705398d62ed06cf2e1479f6def89a39bc", "pub_sign_key": [ 2, 2, @@ -87,7 +87,7 @@ }, { "Private": { - "address": "9cb6b0035320266e430eac9d96745769e7efcf30d2b9cc21ff000b3f873dc2a8", + "address": "d360d6b5763f71ac6af56253687fd7d556d5c6c64312e53c0b92ef039a4375df", "account": { "program_owner": [ 0, @@ -316,7 +316,7 @@ }, { "Private": { - "address": "a55f4f98d2f265c91d8a9868564242d8070b9bf7180a29363f52eb76988636fd", + "address": "f27087ffc29b99035303697dcf6c8e323b1847d4261e6afd49e0d71c6dfa31ea", "account": { "program_owner": [ 0, diff --git a/integration_tests/src/lib.rs b/integration_tests/src/lib.rs index 85cb7a1..fa22250 100644 --- a/integration_tests/src/lib.rs +++ b/integration_tests/src/lib.rs @@ -32,13 +32,13 @@ struct Args { test_name: String, } -pub const ACC_SENDER: &str = "0eee24287296ba55278f1e5403be014754866366388730303c2889be17ada065"; -pub const ACC_RECEIVER: &str = "9e3d8e654d440e95293aa2dceceb137899a59535e952f747068e7a0ee30965f2"; +pub const ACC_SENDER: &str = "d07ad2e84b27fa00c262f0a1eea0ff35ca0973547e6a106f72f193c2dc838b44"; +pub const ACC_RECEIVER: &str = "e7ae77c5ef1a05999344af499fc78a1705398d62ed06cf2e1479f6def89a39bc"; pub const ACC_SENDER_PRIVATE: &str = - "9cb6b0035320266e430eac9d96745769e7efcf30d2b9cc21ff000b3f873dc2a8"; + "d360d6b5763f71ac6af56253687fd7d556d5c6c64312e53c0b92ef039a4375df"; pub const ACC_RECEIVER_PRIVATE: &str = - "a55f4f98d2f265c91d8a9868564242d8070b9bf7180a29363f52eb76988636fd"; + "f27087ffc29b99035303697dcf6c8e323b1847d4261e6afd49e0d71c6dfa31ea"; pub const TIME_TO_WAIT_FOR_BLOCK_SECONDS: u64 = 12; diff --git a/nssa/core/src/encryption/mod.rs b/nssa/core/src/encryption/mod.rs index f2dc18e..280451b 100644 --- a/nssa/core/src/encryption/mod.rs +++ b/nssa/core/src/encryption/mod.rs @@ -54,7 +54,7 @@ impl EncryptionScheme { ) -> [u8; 32] { let mut bytes = Vec::new(); - bytes.extend_from_slice(b"NSSA/v0.1/KDF-SHA256"); + bytes.extend_from_slice(b"NSSA/v0.2/KDF-SHA256/"); bytes.extend_from_slice(&shared_secret.0); bytes.extend_from_slice(&commitment.to_byte_array()); bytes.extend_from_slice(&output_index.to_le_bytes()); diff --git a/nssa/core/src/nullifier.rs b/nssa/core/src/nullifier.rs index 5e3e208..a1bc38c 100644 --- a/nssa/core/src/nullifier.rs +++ b/nssa/core/src/nullifier.rs @@ -9,7 +9,7 @@ pub struct NullifierPublicKey(pub [u8; 32]); impl From<&NullifierPublicKey> for AccountId { fn from(value: &NullifierPublicKey) -> Self { - const PRIVATE_ACCOUNT_ID_PREFIX: &[u8; 32] = b"/NSSA/v0.1/AccountId/Private/\x00\x00\x00"; + const PRIVATE_ACCOUNT_ID_PREFIX: &[u8; 32] = b"/NSSA/v0.2/AccountId/Private/\x00\x00\x00"; let mut bytes = [0; 64]; bytes[0..32].copy_from_slice(PRIVATE_ACCOUNT_ID_PREFIX); @@ -46,7 +46,7 @@ pub struct Nullifier(pub(super) [u8; 32]); impl Nullifier { pub fn for_account_update(commitment: &Commitment, nsk: &NullifierSecretKey) -> Self { - const UPDATE_PREFIX: &[u8; 32] = b"/NSSA/v0.1/Nullifier/Update/\x00\x00\x00\x00"; + const UPDATE_PREFIX: &[u8; 32] = b"/NSSA/v0.2/Nullifier/Update/\x00\x00\x00\x00"; let mut bytes = UPDATE_PREFIX.to_vec(); bytes.extend_from_slice(&commitment.to_byte_array()); bytes.extend_from_slice(nsk); @@ -54,7 +54,7 @@ impl Nullifier { } pub fn for_account_initialization(npk: &NullifierPublicKey) -> Self { - const INIT_PREFIX: &[u8; 32] = b"/NSSA/v0.1/Nullifier/Initialize/"; + const INIT_PREFIX: &[u8; 32] = b"/NSSA/v0.2/Nullifier/Initialize/"; let mut bytes = INIT_PREFIX.to_vec(); bytes.extend_from_slice(&npk.to_byte_array()); Self(Impl::hash_bytes(&bytes).as_bytes().try_into().unwrap()) @@ -70,8 +70,8 @@ mod tests { let commitment = Commitment((0..32u8).collect::>().try_into().unwrap()); let nsk = [0x42; 32]; let expected_nullifier = Nullifier([ - 235, 128, 185, 229, 74, 74, 83, 13, 165, 48, 239, 24, 48, 101, 71, 251, 253, 92, 88, - 201, 103, 43, 250, 135, 193, 54, 175, 82, 245, 171, 90, 135, + 148, 243, 116, 209, 140, 231, 211, 61, 35, 62, 114, 110, 143, 224, 82, 201, 221, 34, + 53, 80, 185, 48, 174, 28, 203, 43, 94, 187, 85, 199, 115, 81, ]); let nullifier = Nullifier::for_account_update(&commitment, &nsk); assert_eq!(nullifier, expected_nullifier); @@ -84,8 +84,8 @@ mod tests { 255, 29, 105, 42, 186, 43, 11, 157, 168, 132, 225, 17, 163, ]); let expected_nullifier = Nullifier([ - 96, 99, 33, 1, 116, 84, 169, 18, 85, 201, 17, 243, 123, 240, 242, 34, 116, 233, 92, - 203, 247, 92, 161, 162, 135, 66, 127, 108, 230, 149, 105, 157, + 1, 6, 59, 168, 16, 146, 65, 252, 255, 91, 48, 85, 116, 189, 110, 218, 110, 136, 163, + 193, 245, 103, 51, 27, 235, 170, 215, 115, 97, 144, 36, 238, ]); let nullifier = Nullifier::for_account_initialization(&npk); assert_eq!(nullifier, expected_nullifier); @@ -113,8 +113,8 @@ mod tests { ]; let npk = NullifierPublicKey::from(&nsk); let expected_account_id = AccountId::new([ - 69, 160, 50, 67, 12, 56, 150, 116, 62, 145, 17, 161, 17, 45, 24, 53, 33, 167, 83, 178, - 47, 114, 111, 233, 251, 30, 54, 244, 184, 22, 100, 236, + 18, 153, 225, 78, 35, 214, 212, 205, 152, 83, 18, 246, 69, 41, 20, 217, 85, 1, 108, 7, + 87, 133, 181, 53, 247, 221, 174, 12, 112, 194, 34, 121, ]); let account_id = AccountId::from(&npk); diff --git a/nssa/src/encoding/privacy_preserving_transaction.rs b/nssa/src/encoding/privacy_preserving_transaction.rs index 2e5ea14..e08584b 100644 --- a/nssa/src/encoding/privacy_preserving_transaction.rs +++ b/nssa/src/encoding/privacy_preserving_transaction.rs @@ -16,8 +16,8 @@ use crate::{ }, }; -const MESSAGE_ENCODING_PREFIX_LEN: usize = 22; -const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = b"\x01/NSSA/v0.1/TxMessage/"; +const MESSAGE_ENCODING_PREFIX_LEN: usize = 32; +const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = b"/NSSA/v0.2/TxMessage/Private/\x00\x00\x00"; impl EncryptedAccountData { pub fn to_bytes(&self) -> Vec { diff --git a/nssa/src/encoding/program_deployment_transaction.rs b/nssa/src/encoding/program_deployment_transaction.rs index 70bd4ea..bb4452d 100644 --- a/nssa/src/encoding/program_deployment_transaction.rs +++ b/nssa/src/encoding/program_deployment_transaction.rs @@ -2,15 +2,12 @@ use std::io::{Cursor, Read}; -use nssa_core::program::ProgramId; - use crate::{ - Address, ProgramDeploymentTransaction, PublicKey, PublicTransaction, Signature, - error::NssaError, program_deployment_transaction::Message, + ProgramDeploymentTransaction, error::NssaError, program_deployment_transaction::Message, }; -const MESSAGE_ENCODING_PREFIX_LEN: usize = 22; -const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = b"\x02/NSSA/v0.1/TxMessage/"; +const MESSAGE_ENCODING_PREFIX_LEN: usize = 32; +const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = b"/NSSA/v0.2/TxMessage/Program/\x00\x00\x00"; impl Message { /// Serializes a `Message` into bytes in the following layout: diff --git a/nssa/src/encoding/public_transaction.rs b/nssa/src/encoding/public_transaction.rs index e8890de..3116257 100644 --- a/nssa/src/encoding/public_transaction.rs +++ b/nssa/src/encoding/public_transaction.rs @@ -10,8 +10,8 @@ use crate::{ public_transaction::{Message, WitnessSet}, }; -const MESSAGE_ENCODING_PREFIX_LEN: usize = 22; -const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = b"\x00/NSSA/v0.1/TxMessage/"; +const MESSAGE_ENCODING_PREFIX_LEN: usize = 32; +const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = b"/NSSA/v0.2/TxMessage/Public/\x00\x00\x00\x00"; impl Message { /// Serializes a `Message` into bytes in the following layout: diff --git a/nssa/src/privacy_preserving_transaction/message.rs b/nssa/src/privacy_preserving_transaction/message.rs index 0bcb02d..5911838 100644 --- a/nssa/src/privacy_preserving_transaction/message.rs +++ b/nssa/src/privacy_preserving_transaction/message.rs @@ -31,10 +31,10 @@ impl EncryptedAccountData { } } - /// Computes the tag as the first byte of SHA256("/NSSA/v0.1/ViewTag" || Npk || Ivk) + /// Computes the tag as the first byte of SHA256("/NSSA/v0.2/ViewTag/" || Npk || Ivk) pub fn compute_view_tag(npk: NullifierPublicKey, ivk: IncomingViewingPublicKey) -> ViewTag { let mut hasher = Sha256::new(); - hasher.update(b"/NSSA/v0.1/ViewTag"); + hasher.update(b"/NSSA/v0.2/ViewTag/"); hasher.update(npk.to_byte_array()); hasher.update(ivk.to_bytes()); let digest: [u8; 32] = hasher.finalize().into(); @@ -166,7 +166,7 @@ pub mod tests { let expected_view_tag = { let mut hasher = Sha256::new(); - hasher.update(b"/NSSA/v0.1/ViewTag"); + hasher.update(b"/NSSA/v0.2/ViewTag/"); hasher.update(npk.to_byte_array()); hasher.update(ivk.to_bytes()); let digest: [u8; 32] = hasher.finalize().into(); diff --git a/nssa/src/program.rs b/nssa/src/program.rs index 17f6d2b..4efd274 100644 --- a/nssa/src/program.rs +++ b/nssa/src/program.rs @@ -8,6 +8,10 @@ use serde::Serialize; use crate::error::NssaError; +/// Maximum number of cycles for a public execution. +/// TODO: Make this variable when fees are implemented +const MAX_NUM_CYCLES_PUBLIC_EXECUTION: u64 = 1024 * 1024 * 32; // 32M cycles + #[derive(Debug, PartialEq, Eq)] pub struct Program { id: ProgramId, @@ -46,6 +50,7 @@ impl Program { ) -> Result, NssaError> { // Write inputs to the program let mut env_builder = ExecutorEnv::builder(); + env_builder.session_limit(Some(MAX_NUM_CYCLES_PUBLIC_EXECUTION)); Self::write_inputs(pre_states, instruction_data, &mut env_builder)?; let env = env_builder.build().unwrap(); diff --git a/nssa/src/public_transaction/transaction.rs b/nssa/src/public_transaction/transaction.rs index ea9c430..ae37288 100644 --- a/nssa/src/public_transaction/transaction.rs +++ b/nssa/src/public_transaction/transaction.rs @@ -186,12 +186,12 @@ pub mod tests { let tx = transaction_for_tests(); let expected_signer_addresses = vec![ Address::new([ - 14, 238, 36, 40, 114, 150, 186, 85, 39, 143, 30, 84, 3, 190, 1, 71, 84, 134, 99, - 102, 56, 135, 48, 48, 60, 40, 137, 190, 23, 173, 160, 101, + 208, 122, 210, 232, 75, 39, 250, 0, 194, 98, 240, 161, 238, 160, 255, 53, 202, 9, + 115, 84, 126, 106, 16, 111, 114, 241, 147, 194, 220, 131, 139, 68, ]), Address::new([ - 158, 61, 142, 101, 77, 68, 14, 149, 41, 58, 162, 220, 236, 235, 19, 120, 153, 165, - 149, 53, 233, 82, 247, 71, 6, 142, 122, 14, 227, 9, 101, 242, + 231, 174, 119, 197, 239, 26, 5, 153, 147, 68, 175, 73, 159, 199, 138, 23, 5, 57, + 141, 98, 237, 6, 207, 46, 20, 121, 246, 222, 248, 154, 57, 188, ]), ]; let signer_addresses = tx.signer_addresses(); diff --git a/nssa/src/signature/public_key.rs b/nssa/src/signature/public_key.rs index efa732b..dbd7d64 100644 --- a/nssa/src/signature/public_key.rs +++ b/nssa/src/signature/public_key.rs @@ -33,7 +33,7 @@ impl PublicKey { impl From<&PublicKey> for Address { fn from(key: &PublicKey) -> Self { - const PUBLIC_ACCOUNT_ID_PREFIX: &[u8; 32] = b"/NSSA/v0.1/AccountId/Public/\x00\x00\x00\x00"; + const PUBLIC_ACCOUNT_ID_PREFIX: &[u8; 32] = b"/NSSA/v0.2/AccountId/Public/\x00\x00\x00\x00"; let mut hasher = Sha256::new(); hasher.update(PUBLIC_ACCOUNT_ID_PREFIX); diff --git a/sequencer_core/src/lib.rs b/sequencer_core/src/lib.rs index f7fc9be..92d53e7 100644 --- a/sequencer_core/src/lib.rs +++ b/sequencer_core/src/lib.rs @@ -238,13 +238,13 @@ mod tests { fn setup_sequencer_config() -> SequencerConfig { let acc1_addr = vec![ - 14, 238, 36, 40, 114, 150, 186, 85, 39, 143, 30, 84, 3, 190, 1, 71, 84, 134, 99, 102, - 56, 135, 48, 48, 60, 40, 137, 190, 23, 173, 160, 101, + 208, 122, 210, 232, 75, 39, 250, 0, 194, 98, 240, 161, 238, 160, 255, 53, 202, 9, 115, + 84, 126, 106, 16, 111, 114, 241, 147, 194, 220, 131, 139, 68, ]; let acc2_addr = vec![ - 158, 61, 142, 101, 77, 68, 14, 149, 41, 58, 162, 220, 236, 235, 19, 120, 153, 165, 149, - 53, 233, 82, 247, 71, 6, 142, 122, 14, 227, 9, 101, 242, + 231, 174, 119, 197, 239, 26, 5, 153, 147, 68, 175, 73, 159, 199, 138, 23, 5, 57, 141, + 98, 237, 6, 207, 46, 20, 121, 246, 222, 248, 154, 57, 188, ]; let initial_acc1 = AccountInitialData { diff --git a/sequencer_rpc/src/process.rs b/sequencer_rpc/src/process.rs index f376f94..aa6d386 100644 --- a/sequencer_rpc/src/process.rs +++ b/sequencer_rpc/src/process.rs @@ -308,13 +308,13 @@ mod tests { let tempdir = tempdir().unwrap(); let home = tempdir.path().to_path_buf(); let acc1_addr = vec![ - 14, 238, 36, 40, 114, 150, 186, 85, 39, 143, 30, 84, 3, 190, 1, 71, 84, 134, 99, 102, - 56, 135, 48, 48, 60, 40, 137, 190, 23, 173, 160, 101, + 208, 122, 210, 232, 75, 39, 250, 0, 194, 98, 240, 161, 238, 160, 255, 53, 202, 9, 115, + 84, 126, 106, 16, 111, 114, 241, 147, 194, 220, 131, 139, 68, ]; let acc2_addr = vec![ - 158, 61, 142, 101, 77, 68, 14, 149, 41, 58, 162, 220, 236, 235, 19, 120, 153, 165, 149, - 53, 233, 82, 247, 71, 6, 142, 122, 14, 227, 9, 101, 242, + 231, 174, 119, 197, 239, 26, 5, 153, 147, 68, 175, 73, 159, 199, 138, 23, 5, 57, 141, + 98, 237, 6, 207, 46, 20, 121, 246, 222, 248, 154, 57, 188, ]; let initial_acc1 = AccountInitialData { @@ -352,8 +352,8 @@ mod tests { let balance_to_move = 10; let tx = common::test_utils::create_transaction_native_token_transfer( [ - 14, 238, 36, 40, 114, 150, 186, 85, 39, 143, 30, 84, 3, 190, 1, 71, 84, 134, 99, - 102, 56, 135, 48, 48, 60, 40, 137, 190, 23, 173, 160, 101, + 208, 122, 210, 232, 75, 39, 250, 0, 194, 98, 240, 161, 238, 160, 255, 53, 202, 9, + 115, 84, 126, 106, 16, 111, 114, 241, 147, 194, 220, 131, 139, 68, ], 0, [2; 32], diff --git a/sequencer_runner/configs/debug/sequencer_config.json b/sequencer_runner/configs/debug/sequencer_config.json index 14de2c1..19ff458 100644 --- a/sequencer_runner/configs/debug/sequencer_config.json +++ b/sequencer_runner/configs/debug/sequencer_config.json @@ -8,11 +8,11 @@ "port": 3040, "initial_accounts": [ { - "addr": "0eee24287296ba55278f1e5403be014754866366388730303c2889be17ada065", + "addr": "d07ad2e84b27fa00c262f0a1eea0ff35ca0973547e6a106f72f193c2dc838b44", "balance": 10000 }, { - "addr": "9e3d8e654d440e95293aa2dceceb137899a59535e952f747068e7a0ee30965f2", + "addr": "e7ae77c5ef1a05999344af499fc78a1705398d62ed06cf2e1479f6def89a39bc", "balance": 20000 } ], diff --git a/wallet/src/chain_storage/mod.rs b/wallet/src/chain_storage/mod.rs index d4123d6..e07ba8e 100644 --- a/wallet/src/chain_storage/mod.rs +++ b/wallet/src/chain_storage/mod.rs @@ -77,14 +77,14 @@ mod tests { fn create_initial_accounts() -> Vec { let initial_acc1 = serde_json::from_str(r#"{ "Public": { - "address": "0eee24287296ba55278f1e5403be014754866366388730303c2889be17ada065", + "address": "d07ad2e84b27fa00c262f0a1eea0ff35ca0973547e6a106f72f193c2dc838b44", "pub_sign_key": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] } }"#).unwrap(); let initial_acc2 = serde_json::from_str(r#"{ "Public": { - "address": "9e3d8e654d440e95293aa2dceceb137899a59535e952f747068e7a0ee30965f2", + "address": "e7ae77c5ef1a05999344af499fc78a1705398d62ed06cf2e1479f6def89a39bc", "pub_sign_key": [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2] } }"#).unwrap(); From f3fbae66b5185f2a7c3fbd7699147681018415ba Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Thu, 16 Oct 2025 16:19:39 -0300 Subject: [PATCH 10/17] fmt --- common/src/test_utils.rs | 1 - integration_tests/src/lib.rs | 2 +- key_protocol/Cargo.toml | 1 - nssa/src/encoding/mod.rs | 2 +- nssa/src/encoding/privacy_preserving_transaction.rs | 3 ++- nssa/src/encoding/program_deployment_transaction.rs | 3 ++- nssa/src/encoding/public_transaction.rs | 3 ++- nssa/src/lib.rs | 2 +- nssa/src/program_deployment_transaction/mod.rs | 2 +- storage/Cargo.toml | 1 - wallet/Cargo.toml | 1 - 11 files changed, 10 insertions(+), 11 deletions(-) diff --git a/common/src/test_utils.rs b/common/src/test_utils.rs index 9678580..9d68db8 100644 --- a/common/src/test_utils.rs +++ b/common/src/test_utils.rs @@ -68,4 +68,3 @@ pub fn create_transaction_native_token_transfer( EncodedTransaction::from(NSSATransaction::Public(nssa_tx)) } - diff --git a/integration_tests/src/lib.rs b/integration_tests/src/lib.rs index fa22250..d65ebbf 100644 --- a/integration_tests/src/lib.rs +++ b/integration_tests/src/lib.rs @@ -42,7 +42,7 @@ pub const ACC_RECEIVER_PRIVATE: &str = pub const TIME_TO_WAIT_FOR_BLOCK_SECONDS: u64 = 12; -pub const NSSA_PROGRAM_FOR_TEST: &'static [u8] = include_bytes!("simple_balance_transfer.bin"); +pub const NSSA_PROGRAM_FOR_TEST: &[u8] = include_bytes!("simple_balance_transfer.bin"); #[allow(clippy::type_complexity)] pub async fn pre_test( diff --git a/key_protocol/Cargo.toml b/key_protocol/Cargo.toml index 6addf41..544a2f8 100644 --- a/key_protocol/Cargo.toml +++ b/key_protocol/Cargo.toml @@ -5,7 +5,6 @@ edition = "2024" [dependencies] anyhow.workspace = true -log.workspace = true serde.workspace = true k256.workspace = true sha2.workspace = true diff --git a/nssa/src/encoding/mod.rs b/nssa/src/encoding/mod.rs index 383fb9a..7d9a5a8 100644 --- a/nssa/src/encoding/mod.rs +++ b/nssa/src/encoding/mod.rs @@ -1,3 +1,3 @@ pub mod privacy_preserving_transaction; -pub mod public_transaction; pub mod program_deployment_transaction; +pub mod public_transaction; diff --git a/nssa/src/encoding/privacy_preserving_transaction.rs b/nssa/src/encoding/privacy_preserving_transaction.rs index e08584b..5788e6f 100644 --- a/nssa/src/encoding/privacy_preserving_transaction.rs +++ b/nssa/src/encoding/privacy_preserving_transaction.rs @@ -17,7 +17,8 @@ use crate::{ }; const MESSAGE_ENCODING_PREFIX_LEN: usize = 32; -const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = b"/NSSA/v0.2/TxMessage/Private/\x00\x00\x00"; +const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = + b"/NSSA/v0.2/TxMessage/Private/\x00\x00\x00"; impl EncryptedAccountData { pub fn to_bytes(&self) -> Vec { diff --git a/nssa/src/encoding/program_deployment_transaction.rs b/nssa/src/encoding/program_deployment_transaction.rs index bb4452d..2dc91b4 100644 --- a/nssa/src/encoding/program_deployment_transaction.rs +++ b/nssa/src/encoding/program_deployment_transaction.rs @@ -7,7 +7,8 @@ use crate::{ }; const MESSAGE_ENCODING_PREFIX_LEN: usize = 32; -const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = b"/NSSA/v0.2/TxMessage/Program/\x00\x00\x00"; +const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = + b"/NSSA/v0.2/TxMessage/Program/\x00\x00\x00"; impl Message { /// Serializes a `Message` into bytes in the following layout: diff --git a/nssa/src/encoding/public_transaction.rs b/nssa/src/encoding/public_transaction.rs index 3116257..03c34ee 100644 --- a/nssa/src/encoding/public_transaction.rs +++ b/nssa/src/encoding/public_transaction.rs @@ -11,7 +11,8 @@ use crate::{ }; const MESSAGE_ENCODING_PREFIX_LEN: usize = 32; -const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = b"/NSSA/v0.2/TxMessage/Public/\x00\x00\x00\x00"; +const MESSAGE_ENCODING_PREFIX: &[u8; MESSAGE_ENCODING_PREFIX_LEN] = + b"/NSSA/v0.2/TxMessage/Public/\x00\x00\x00\x00"; impl Message { /// Serializes a `Message` into bytes in the following layout: diff --git a/nssa/src/lib.rs b/nssa/src/lib.rs index d357daf..52576bc 100644 --- a/nssa/src/lib.rs +++ b/nssa/src/lib.rs @@ -13,8 +13,8 @@ pub use nssa_core::address::Address; pub use privacy_preserving_transaction::{ PrivacyPreservingTransaction, circuit::execute_and_prove, }; -pub use public_transaction::PublicTransaction; pub use program_deployment_transaction::ProgramDeploymentTransaction; +pub use public_transaction::PublicTransaction; pub use signature::PrivateKey; pub use signature::PublicKey; pub use signature::Signature; diff --git a/nssa/src/program_deployment_transaction/mod.rs b/nssa/src/program_deployment_transaction/mod.rs index 42c6cd8..b498826 100644 --- a/nssa/src/program_deployment_transaction/mod.rs +++ b/nssa/src/program_deployment_transaction/mod.rs @@ -1,5 +1,5 @@ mod message; mod transaction; -pub use transaction::ProgramDeploymentTransaction; pub use message::Message; +pub use transaction::ProgramDeploymentTransaction; diff --git a/storage/Cargo.toml b/storage/Cargo.toml index 1bc9d07..2fd4628 100644 --- a/storage/Cargo.toml +++ b/storage/Cargo.toml @@ -4,7 +4,6 @@ version = "0.1.0" edition = "2024" [dependencies] -anyhow.workspace = true thiserror.workspace = true borsh.workspace = true diff --git a/wallet/Cargo.toml b/wallet/Cargo.toml index ebd0dc5..48d79e2 100644 --- a/wallet/Cargo.toml +++ b/wallet/Cargo.toml @@ -14,7 +14,6 @@ tempfile.workspace = true clap.workspace = true nssa-core = { path = "../nssa/core" } base64.workspace = true -k256 = { version = "0.13.3" } bytemuck = "1.23.2" borsh.workspace = true hex.workspace = true From 19215ee009db93c8211ec154f404ba00e8e6a6ac Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Thu, 16 Oct 2025 16:24:18 -0300 Subject: [PATCH 11/17] rename V01State to V02State --- nssa/src/lib.rs | 2 +- .../transaction.rs | 4 +- .../transaction.rs | 4 +- nssa/src/public_transaction/transaction.rs | 10 +-- nssa/src/state.rs | 64 +++++++++---------- sequencer_core/src/sequencer_store/mod.rs | 6 +- 6 files changed, 45 insertions(+), 45 deletions(-) diff --git a/nssa/src/lib.rs b/nssa/src/lib.rs index 52576bc..957e92e 100644 --- a/nssa/src/lib.rs +++ b/nssa/src/lib.rs @@ -18,4 +18,4 @@ pub use public_transaction::PublicTransaction; pub use signature::PrivateKey; pub use signature::PublicKey; pub use signature::Signature; -pub use state::V01State; +pub use state::V02State; diff --git a/nssa/src/privacy_preserving_transaction/transaction.rs b/nssa/src/privacy_preserving_transaction/transaction.rs index af4ba39..3e89ba7 100644 --- a/nssa/src/privacy_preserving_transaction/transaction.rs +++ b/nssa/src/privacy_preserving_transaction/transaction.rs @@ -8,7 +8,7 @@ use nssa_core::{ use crate::error::NssaError; use crate::privacy_preserving_transaction::circuit::Proof; use crate::privacy_preserving_transaction::message::EncryptedAccountData; -use crate::{Address, V01State}; +use crate::{Address, V02State}; use super::message::Message; use super::witness_set::WitnessSet; @@ -29,7 +29,7 @@ impl PrivacyPreservingTransaction { pub(crate) fn validate_and_produce_public_state_diff( &self, - state: &V01State, + state: &V02State, ) -> Result, NssaError> { let message = &self.message; let witness_set = &self.witness_set; diff --git a/nssa/src/program_deployment_transaction/transaction.rs b/nssa/src/program_deployment_transaction/transaction.rs index 87724c5..4ec2e10 100644 --- a/nssa/src/program_deployment_transaction/transaction.rs +++ b/nssa/src/program_deployment_transaction/transaction.rs @@ -1,5 +1,5 @@ use crate::{ - V01State, error::NssaError, program::Program, program_deployment_transaction::message::Message, + V02State, error::NssaError, program::Program, program_deployment_transaction::message::Message, }; #[derive(Debug, Clone, PartialEq, Eq)] @@ -14,7 +14,7 @@ impl ProgramDeploymentTransaction { pub(crate) fn validate_and_produce_public_state_diff( &self, - state: &V01State, + state: &V02State, ) -> Result { // TODO: remove clone let program = Program::new(self.message.bytecode.clone())?; diff --git a/nssa/src/public_transaction/transaction.rs b/nssa/src/public_transaction/transaction.rs index ae37288..b0b8f73 100644 --- a/nssa/src/public_transaction/transaction.rs +++ b/nssa/src/public_transaction/transaction.rs @@ -8,7 +8,7 @@ use nssa_core::{ use sha2::{Digest, digest::FixedOutput}; use crate::{ - V01State, + V02State, error::NssaError, public_transaction::{Message, WitnessSet}, }; @@ -52,7 +52,7 @@ impl PublicTransaction { pub(crate) fn validate_and_produce_public_state_diff( &self, - state: &V01State, + state: &V02State, ) -> Result, NssaError> { let message = self.message(); let witness_set = self.witness_set(); @@ -123,7 +123,7 @@ pub mod tests { use sha2::{Digest, digest::FixedOutput}; use crate::{ - Address, PrivateKey, PublicKey, PublicTransaction, Signature, V01State, + Address, PrivateKey, PublicKey, PublicTransaction, Signature, V02State, error::NssaError, program::Program, public_transaction::{Message, WitnessSet}, @@ -137,10 +137,10 @@ pub mod tests { (key1, key2, addr1, addr2) } - fn state_for_tests() -> V01State { + fn state_for_tests() -> V02State { let (_, _, addr1, addr2) = keys_for_tests(); let initial_data = [(addr1, 10000), (addr2, 20000)]; - V01State::new_with_genesis_accounts(&initial_data, &[]) + V02State::new_with_genesis_accounts(&initial_data, &[]) } fn transaction_for_tests() -> PublicTransaction { diff --git a/nssa/src/state.rs b/nssa/src/state.rs index 1819b50..83183f5 100644 --- a/nssa/src/state.rs +++ b/nssa/src/state.rs @@ -59,13 +59,13 @@ impl CommitmentSet { type NullifierSet = HashSet; -pub struct V01State { +pub struct V02State { public_state: HashMap, private_state: (CommitmentSet, NullifierSet), programs: HashMap, } -impl V01State { +impl V02State { pub fn new_with_genesis_accounts( initial_data: &[(Address, u128)], initial_commitments: &[nssa_core::Commitment], @@ -225,7 +225,7 @@ impl V01State { } // TODO: Testnet only. Refactor to prevent compilation on mainnet. -impl V01State { +impl V02State { pub fn add_pinata_program(&mut self, address: Address) { self.insert_program(Program::pinata()); @@ -248,7 +248,7 @@ pub mod tests { use std::collections::HashMap; use crate::{ - Address, PublicKey, PublicTransaction, V01State, + Address, PublicKey, PublicTransaction, V02State, error::NssaError, execute_and_prove, privacy_preserving_transaction::{ @@ -319,7 +319,7 @@ pub mod tests { this }; - let state = V01State::new_with_genesis_accounts(&initial_data, &[]); + let state = V02State::new_with_genesis_accounts(&initial_data, &[]); assert_eq!(state.public_state, expected_public_state); assert_eq!(state.programs, expected_builtin_programs); @@ -327,7 +327,7 @@ pub mod tests { #[test] fn test_insert_program() { - let mut state = V01State::new_with_genesis_accounts(&[], &[]); + let mut state = V02State::new_with_genesis_accounts(&[], &[]); let program_to_insert = Program::simple_balance_transfer(); let program_id = program_to_insert.id(); assert!(!state.programs.contains_key(&program_id)); @@ -342,7 +342,7 @@ pub mod tests { let key = PrivateKey::try_new([1; 32]).unwrap(); let addr = Address::from(&PublicKey::new_from_private_key(&key)); let initial_data = [(addr, 100u128)]; - let state = V01State::new_with_genesis_accounts(&initial_data, &[]); + let state = V02State::new_with_genesis_accounts(&initial_data, &[]); let expected_account = state.public_state.get(&addr).unwrap(); let account = state.get_account_by_address(&addr); @@ -353,7 +353,7 @@ pub mod tests { #[test] fn test_get_account_by_address_default_account() { let addr2 = Address::new([0; 32]); - let state = V01State::new_with_genesis_accounts(&[], &[]); + let state = V02State::new_with_genesis_accounts(&[], &[]); let expected_account = Account::default(); let account = state.get_account_by_address(&addr2); @@ -363,7 +363,7 @@ pub mod tests { #[test] fn test_builtin_programs_getter() { - let state = V01State::new_with_genesis_accounts(&[], &[]); + let state = V02State::new_with_genesis_accounts(&[], &[]); let builtin_programs = state.programs(); @@ -375,7 +375,7 @@ pub mod tests { let key = PrivateKey::try_new([1; 32]).unwrap(); let address = Address::from(&PublicKey::new_from_private_key(&key)); let initial_data = [(address, 100)]; - let mut state = V01State::new_with_genesis_accounts(&initial_data, &[]); + let mut state = V02State::new_with_genesis_accounts(&initial_data, &[]); let from = address; let to = Address::new([2; 32]); assert_eq!(state.get_account_by_address(&to), Account::default()); @@ -395,7 +395,7 @@ pub mod tests { let key = PrivateKey::try_new([1; 32]).unwrap(); let address = Address::from(&PublicKey::new_from_private_key(&key)); let initial_data = [(address, 100)]; - let mut state = V01State::new_with_genesis_accounts(&initial_data, &[]); + let mut state = V02State::new_with_genesis_accounts(&initial_data, &[]); let from = address; let from_key = key; let to = Address::new([2; 32]); @@ -419,7 +419,7 @@ pub mod tests { let address1 = Address::from(&PublicKey::new_from_private_key(&key1)); let address2 = Address::from(&PublicKey::new_from_private_key(&key2)); let initial_data = [(address1, 100), (address2, 200)]; - let mut state = V01State::new_with_genesis_accounts(&initial_data, &[]); + let mut state = V02State::new_with_genesis_accounts(&initial_data, &[]); let from = address2; let from_key = key2; let to = address1; @@ -442,7 +442,7 @@ pub mod tests { let key2 = PrivateKey::try_new([2; 32]).unwrap(); let address2 = Address::from(&PublicKey::new_from_private_key(&key2)); let initial_data = [(address1, 100)]; - let mut state = V01State::new_with_genesis_accounts(&initial_data, &[]); + let mut state = V02State::new_with_genesis_accounts(&initial_data, &[]); let address3 = Address::new([3; 32]); let balance_to_move = 5; @@ -460,7 +460,7 @@ pub mod tests { assert_eq!(state.get_account_by_address(&address3).nonce, 0); } - impl V01State { + impl V02State { pub fn force_insert_account(&mut self, address: Address, account: Account) { self.public_state.insert(address, account); } @@ -527,7 +527,7 @@ pub mod tests { fn test_program_should_fail_if_modifies_nonces() { let initial_data = [(Address::new([1; 32]), 100)]; let mut state = - V01State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); + V02State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); let addresses = vec![Address::new([1; 32])]; let program_id = Program::nonce_changer_program().id(); let message = @@ -544,7 +544,7 @@ pub mod tests { fn test_program_should_fail_if_output_accounts_exceed_inputs() { let initial_data = [(Address::new([1; 32]), 100)]; let mut state = - V01State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); + V02State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); let addresses = vec![Address::new([1; 32])]; let program_id = Program::extra_output_program().id(); let message = @@ -561,7 +561,7 @@ pub mod tests { fn test_program_should_fail_with_missing_output_accounts() { let initial_data = [(Address::new([1; 32]), 100)]; let mut state = - V01State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); + V02State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); let addresses = vec![Address::new([1; 32]), Address::new([2; 32])]; let program_id = Program::missing_output_program().id(); let message = @@ -578,7 +578,7 @@ pub mod tests { fn test_program_should_fail_if_modifies_program_owner_with_only_non_default_program_owner() { let initial_data = [(Address::new([1; 32]), 0)]; let mut state = - V01State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); + V02State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); let address = Address::new([1; 32]); let account = state.get_account_by_address(&address); // Assert the target account only differs from the default account in the program owner field @@ -600,7 +600,7 @@ pub mod tests { #[test] fn test_program_should_fail_if_modifies_program_owner_with_only_non_default_balance() { let initial_data = []; - let mut state = V01State::new_with_genesis_accounts(&initial_data, &[]) + let mut state = V02State::new_with_genesis_accounts(&initial_data, &[]) .with_test_programs() .with_non_default_accounts_but_default_program_owners(); let address = Address::new([255; 32]); @@ -624,7 +624,7 @@ pub mod tests { #[test] fn test_program_should_fail_if_modifies_program_owner_with_only_non_default_nonce() { let initial_data = []; - let mut state = V01State::new_with_genesis_accounts(&initial_data, &[]) + let mut state = V02State::new_with_genesis_accounts(&initial_data, &[]) .with_test_programs() .with_non_default_accounts_but_default_program_owners(); let address = Address::new([254; 32]); @@ -648,7 +648,7 @@ pub mod tests { #[test] fn test_program_should_fail_if_modifies_program_owner_with_only_non_default_data() { let initial_data = []; - let mut state = V01State::new_with_genesis_accounts(&initial_data, &[]) + let mut state = V02State::new_with_genesis_accounts(&initial_data, &[]) .with_test_programs() .with_non_default_accounts_but_default_program_owners(); let address = Address::new([253; 32]); @@ -673,7 +673,7 @@ pub mod tests { fn test_program_should_fail_if_transfers_balance_from_non_owned_account() { let initial_data = [(Address::new([1; 32]), 100)]; let mut state = - V01State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); + V02State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); let sender_address = Address::new([1; 32]); let receiver_address = Address::new([2; 32]); let balance_to_move: u128 = 1; @@ -700,7 +700,7 @@ pub mod tests { #[test] fn test_program_should_fail_if_modifies_data_of_non_owned_account() { let initial_data = []; - let mut state = V01State::new_with_genesis_accounts(&initial_data, &[]) + let mut state = V02State::new_with_genesis_accounts(&initial_data, &[]) .with_test_programs() .with_non_default_accounts_but_default_program_owners(); let address = Address::new([255; 32]); @@ -725,7 +725,7 @@ pub mod tests { fn test_program_should_fail_if_does_not_preserve_total_balance_by_minting() { let initial_data = []; let mut state = - V01State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); + V02State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); let address = Address::new([1; 32]); let program_id = Program::minter().id(); @@ -742,7 +742,7 @@ pub mod tests { #[test] fn test_program_should_fail_if_does_not_preserve_total_balance_by_burning() { let initial_data = []; - let mut state = V01State::new_with_genesis_accounts(&initial_data, &[]) + let mut state = V02State::new_with_genesis_accounts(&initial_data, &[]) .with_test_programs() .with_account_owned_by_burner_program(); let program_id = Program::burner().id(); @@ -817,7 +817,7 @@ pub mod tests { sender_keys: &TestPublicKeys, recipient_keys: &TestPrivateKeys, balance_to_move: u128, - state: &V01State, + state: &V02State, ) -> PrivacyPreservingTransaction { let sender = AccountWithMetadata::new( state.get_account_by_address(&sender_keys.address()), @@ -862,7 +862,7 @@ pub mod tests { recipient_keys: &TestPrivateKeys, balance_to_move: u128, new_nonces: [Nonce; 2], - state: &V01State, + state: &V02State, ) -> PrivacyPreservingTransaction { let program = Program::authenticated_transfer_program(); let sender_commitment = Commitment::new(&sender_keys.npk(), sender_private_account); @@ -918,7 +918,7 @@ pub mod tests { recipient_address: &Address, balance_to_move: u128, new_nonce: Nonce, - state: &V01State, + state: &V02State, ) -> PrivacyPreservingTransaction { let program = Program::authenticated_transfer_program(); let sender_commitment = Commitment::new(&sender_keys.npk(), sender_private_account); @@ -966,7 +966,7 @@ pub mod tests { let sender_keys = test_public_account_keys_1(); let recipient_keys = test_private_account_keys_1(); - let mut state = V01State::new_with_genesis_accounts(&[(sender_keys.address(), 200)], &[]); + let mut state = V02State::new_with_genesis_accounts(&[(sender_keys.address(), 200)], &[]); let balance_to_move = 37; @@ -1012,7 +1012,7 @@ pub mod tests { }; let recipient_keys = test_private_account_keys_2(); - let mut state = V01State::new_with_genesis_accounts(&[], &[]) + let mut state = V02State::new_with_genesis_accounts(&[], &[]) .with_private_account(&sender_keys, &sender_private_account); let balance_to_move = 37; @@ -1078,7 +1078,7 @@ pub mod tests { }; let recipient_keys = test_public_account_keys_1(); let recipient_initial_balance = 400; - let mut state = V01State::new_with_genesis_accounts( + let mut state = V02State::new_with_genesis_accounts( &[(recipient_keys.address(), recipient_initial_balance)], &[], ) @@ -1966,7 +1966,7 @@ pub mod tests { }; let recipient_keys = test_private_account_keys_2(); - let mut state = V01State::new_with_genesis_accounts(&[], &[]) + let mut state = V02State::new_with_genesis_accounts(&[], &[]) .with_private_account(&sender_keys, &sender_private_account); let balance_to_move = 37; diff --git a/sequencer_core/src/sequencer_store/mod.rs b/sequencer_core/src/sequencer_store/mod.rs index ad2939a..4f18405 100644 --- a/sequencer_core/src/sequencer_store/mod.rs +++ b/sequencer_core/src/sequencer_store/mod.rs @@ -10,7 +10,7 @@ use crate::config::AccountInitialData; pub mod block_store; pub struct SequecerChainStore { - pub state: nssa::V01State, + pub state: nssa::V02State, pub block_store: SequecerBlockStore, } @@ -29,12 +29,12 @@ impl SequecerChainStore { .collect(); #[cfg(not(feature = "testnet"))] - let state = nssa::V01State::new_with_genesis_accounts(&init_accs, initial_commitments); + let state = nssa::V02State::new_with_genesis_accounts(&init_accs, initial_commitments); #[cfg(feature = "testnet")] let state = { let mut this = - nssa::V01State::new_with_genesis_accounts(&init_accs, initial_commitments); + nssa::V02State::new_with_genesis_accounts(&init_accs, initial_commitments); this.add_pinata_program("cafe".repeat(16).parse().unwrap()); this }; From 6157e3023b6b334e3159b66c269e854647ebad44 Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Thu, 16 Oct 2025 16:54:34 -0300 Subject: [PATCH 12/17] add execution of deployed program in integration test --- integration_tests/src/data_changer.bin | Bin 0 -> 366692 bytes integration_tests/src/lib.rs | 43 +++++++++++++++--- .../src/simple_balance_transfer.bin | Bin 368396 -> 0 bytes nssa/src/program.rs | 4 +- 4 files changed, 38 insertions(+), 9 deletions(-) create mode 100644 integration_tests/src/data_changer.bin delete mode 100644 integration_tests/src/simple_balance_transfer.bin diff --git a/integration_tests/src/data_changer.bin b/integration_tests/src/data_changer.bin new file mode 100644 index 0000000000000000000000000000000000000000..d201f91960c9f4739d4a4ee0c94fb4a356f50e24 GIT binary patch literal 366692 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

B~-L6NJ3?aewN!&u4eyGS%LZkCTt>^WC%Y92K94 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 diff --git a/nssa/src/program.rs b/nssa/src/program.rs index 4efd274..b4862ca 100644 --- a/nssa/src/program.rs +++ b/nssa/src/program.rs @@ -19,7 +19,7 @@ pub struct Program { } impl Program { - pub(crate) fn new(bytecode: Vec) -> Result { + pub fn new(bytecode: Vec) -> Result { let binary = risc0_binfmt::ProgramBinary::decode(&bytecode) .map_err(|_| NssaError::InvalidProgramBytecode)?; let id = binary @@ -33,7 +33,7 @@ impl Program { self.id } - pub(crate) fn elf(&self) -> &[u8] { + pub fn elf(&self) -> &[u8] { &self.elf } From 6b18168c3c520cf17f01f2a60cc4a43519c34ae1 Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Thu, 16 Oct 2025 17:03:01 -0300 Subject: [PATCH 13/17] remove unused type alias --- common/src/transaction.rs | 7 ------- 1 file changed, 7 deletions(-) diff --git a/common/src/transaction.rs b/common/src/transaction.rs index 0a6c057..c99cf31 100644 --- a/common/src/transaction.rs +++ b/common/src/transaction.rs @@ -5,12 +5,6 @@ use serde::{Deserialize, Serialize}; use sha2::{Digest, digest::FixedOutput}; -use elliptic_curve::{ - consts::{B0, B1}, - generic_array::GenericArray, -}; -use sha2::digest::typenum::{UInt, UTerm}; - #[derive(Debug, Clone, PartialEq, Eq)] pub enum NSSATransaction { Public(nssa::PublicTransaction), @@ -39,7 +33,6 @@ impl From for NSSATransaction { use crate::TreeHashType; pub type CipherText = Vec; -pub type Nonce = GenericArray, B1>, B0>, B0>>; pub type Tag = u8; #[derive( From 25ecfa733f208a8a778a018423b076f6ea546c4e Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Fri, 17 Oct 2025 07:59:32 -0300 Subject: [PATCH 14/17] remove double test in ci --- ci_scripts/test-ubuntu.sh | 1 - 1 file changed, 1 deletion(-) diff --git a/ci_scripts/test-ubuntu.sh b/ci_scripts/test-ubuntu.sh index 5c19b36..78761df 100755 --- a/ci_scripts/test-ubuntu.sh +++ b/ci_scripts/test-ubuntu.sh @@ -9,7 +9,6 @@ RISC0_DEV_MODE=1 cargo test --release cd integration_tests export NSSA_WALLET_HOME_DIR=$(pwd)/configs/debug/wallet/ export RUST_LOG=info -cargo run $(pwd)/configs/debug all echo "Try test valid proof at least once" cargo run $(pwd)/configs/debug test_success_private_transfer_to_another_owned_account echo "Continuing in dev mode" From 323f58d56616fce50f888839c0381e7851605c71 Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Fri, 17 Oct 2025 09:12:08 -0300 Subject: [PATCH 15/17] clippy --- integration_tests/src/lib.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/integration_tests/src/lib.rs b/integration_tests/src/lib.rs index deeb579..78eadec 100644 --- a/integration_tests/src/lib.rs +++ b/integration_tests/src/lib.rs @@ -9,10 +9,7 @@ use common::{ transaction::{EncodedTransaction, NSSATransaction}, }; use log::{info, warn}; -use nssa::{ - Address, PrivacyPreservingTransaction, PrivateKey, ProgramDeploymentTransaction, - privacy_preserving_transaction::witness_set, program::Program, -}; +use nssa::{Address, PrivacyPreservingTransaction, ProgramDeploymentTransaction, program::Program}; use nssa_core::{ Commitment, NullifierPublicKey, encryption::shared_key_derivation::Secp256k1Point, }; From ff448cbb3ca824fe79d78d39558d0f220caf77b9 Mon Sep 17 00:00:00 2001 From: Oleksandr Pravdyvyi Date: Mon, 20 Oct 2025 09:20:22 +0300 Subject: [PATCH 16/17] fix: fmt --- integration_tests/src/lib.rs | 77 ++++++++++++++++++++++++------------ 1 file changed, 52 insertions(+), 25 deletions(-) diff --git a/integration_tests/src/lib.rs b/integration_tests/src/lib.rs index f86553a..bf919da 100644 --- a/integration_tests/src/lib.rs +++ b/integration_tests/src/lib.rs @@ -18,6 +18,7 @@ use sequencer_runner::startup_sequencer; use tempfile::TempDir; use tokio::task::JoinHandle; use wallet::{ + Command, SubcommandReturnValue, WalletCore, cli::{ chain::{ChainSubcommand, FetchSubcommand, RegisterSubcommand}, native_token_transfer_program::{ @@ -28,9 +29,13 @@ use wallet::{ PinataProgramSubcommand, PinataProgramSubcommandPrivate, PinataProgramSubcommandPublic, }, token_program::{ - TokenProgramSubcommand, TokenProgramSubcommandDeshielded, TokenProgramSubcommandPrivate, TokenProgramSubcommandPublic, TokenProgramSubcommandShielded + TokenProgramSubcommand, TokenProgramSubcommandDeshielded, + TokenProgramSubcommandPrivate, TokenProgramSubcommandPublic, + TokenProgramSubcommandShielded, }, - }, config::PersistentAccountData, helperfunctions::{fetch_config, fetch_persistent_accounts}, Command, SubcommandReturnValue, WalletCore + }, + config::PersistentAccountData, + helperfunctions::{fetch_config, fetch_persistent_accounts}, }; #[derive(Parser, Debug)] @@ -769,26 +774,32 @@ pub async fn test_success_token_program_shielded_owned() { // Create new account for the token definition (public) let SubcommandReturnValue::RegisterAccount { addr: definition_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register(RegisterSubcommand::RegisterAccountPublic {}))) - .await - .unwrap() + } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPublic {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for the token supply holder (private) let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = - wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register(RegisterSubcommand::RegisterAccountPublic {}))) - .await - .unwrap() + wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPublic {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for receiving a token transaction let SubcommandReturnValue::RegisterAccount { addr: recipient_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register(RegisterSubcommand::RegisterAccountPrivate {}))) - .await - .unwrap() + } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPrivate {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; @@ -844,7 +855,9 @@ pub async fn test_success_token_program_shielded_owned() { tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; let wallet_config = fetch_config().await.unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment2 = wallet_storage .get_private_account_commitment(&recipient_addr) @@ -868,7 +881,9 @@ pub async fn test_success_token_program_shielded_owned() { tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; let wallet_config = fetch_config().await.unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment2 = wallet_storage .get_private_account_commitment(&recipient_addr) @@ -884,26 +899,32 @@ pub async fn test_success_token_program_deshielded_owned() { // Create new account for the token definition (public) let SubcommandReturnValue::RegisterAccount { addr: definition_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register(RegisterSubcommand::RegisterAccountPublic {}))) - .await - .unwrap() + } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPublic {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for the token supply holder (private) let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = - wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register(RegisterSubcommand::RegisterAccountPrivate {}))) - .await - .unwrap() + wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPrivate {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for receiving a token transaction let SubcommandReturnValue::RegisterAccount { addr: recipient_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register(RegisterSubcommand::RegisterAccountPublic {}))) - .await - .unwrap() + } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( + RegisterSubcommand::RegisterAccountPublic {}, + ))) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; @@ -945,7 +966,9 @@ pub async fn test_success_token_program_deshielded_owned() { ); let wallet_config = fetch_config().await.unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&supply_addr) @@ -969,7 +992,9 @@ pub async fn test_success_token_program_deshielded_owned() { tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; let wallet_config = fetch_config().await.unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&supply_addr) @@ -993,7 +1018,9 @@ pub async fn test_success_token_program_deshielded_owned() { tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; let wallet_config = fetch_config().await.unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); let new_commitment1 = wallet_storage .get_private_account_commitment(&supply_addr) From 28c1fd39a47d95297172e23326f2107f1c8dcf7c Mon Sep 17 00:00:00 2001 From: Oleksandr Pravdyvyi Date: Mon, 20 Oct 2025 10:01:54 +0300 Subject: [PATCH 17/17] fix: suggestions added 1 --- integration_tests/src/lib.rs | 257 ++++++++--------- wallet/src/cli/account.rs | 253 +++++++++++++++++ wallet/src/cli/chain.rs | 250 ++-------------- wallet/src/cli/mod.rs | 1 + .../src/cli/native_token_transfer_program.rs | 266 +++++++++--------- wallet/src/cli/pinata_program.rs | 8 +- wallet/src/lib.rs | 10 +- wallet/src/main.rs | 5 +- 8 files changed, 539 insertions(+), 511 deletions(-) create mode 100644 wallet/src/cli/account.rs diff --git a/integration_tests/src/lib.rs b/integration_tests/src/lib.rs index bf919da..2c89fbd 100644 --- a/integration_tests/src/lib.rs +++ b/integration_tests/src/lib.rs @@ -20,7 +20,7 @@ use tokio::task::JoinHandle; use wallet::{ Command, SubcommandReturnValue, WalletCore, cli::{ - chain::{ChainSubcommand, FetchSubcommand, RegisterSubcommand}, + account::{AccountSubcommand, FetchSubcommand, RegisterSubcommand}, native_token_transfer_program::{ NativeTokenTransferProgramSubcommand, NativeTokenTransferProgramSubcommandPrivate, NativeTokenTransferProgramSubcommandShielded, @@ -112,13 +112,11 @@ pub async fn post_test(residual: (ServerHandle, JoinHandle>, TempDir) pub async fn test_success() { info!("test_success"); - let command = Command::Transfer( - NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { - from: ACC_SENDER.to_string(), - to: ACC_RECEIVER.to_string(), - amount: 100, - }, - ); + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Public { + from: ACC_SENDER.to_string(), + to: ACC_RECEIVER.to_string(), + amount: 100, + }); let wallet_config = fetch_config().await.unwrap(); @@ -150,9 +148,7 @@ pub async fn test_success() { pub async fn test_success_move_to_another_account() { info!("test_success_move_to_another_account"); - let command = Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPublic {}, - )); + let command = Command::Account(AccountSubcommand::Register(RegisterSubcommand::Public {})); let wallet_config = fetch_config().await.unwrap(); @@ -176,13 +172,11 @@ pub async fn test_success_move_to_another_account() { panic!("Failed to produce new account, not present in persistent accounts"); } - let command = Command::Transfer( - NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { - from: ACC_SENDER.to_string(), - to: new_persistent_account_addr.clone(), - amount: 100, - }, - ); + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Public { + from: ACC_SENDER.to_string(), + to: new_persistent_account_addr.clone(), + amount: 100, + }); wallet::execute_subcommand(command).await.unwrap(); @@ -210,13 +204,11 @@ pub async fn test_success_move_to_another_account() { pub async fn test_failure() { info!("test_failure"); - let command = Command::Transfer( - NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { - from: ACC_SENDER.to_string(), - to: ACC_RECEIVER.to_string(), - amount: 1000000, - }, - ); + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Public { + from: ACC_SENDER.to_string(), + to: ACC_RECEIVER.to_string(), + amount: 1000000, + }); let wallet_config = fetch_config().await.unwrap(); @@ -250,13 +242,11 @@ pub async fn test_failure() { pub async fn test_success_two_transactions() { info!("test_success_two_transactions"); - let command = Command::Transfer( - NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { - from: ACC_SENDER.to_string(), - to: ACC_RECEIVER.to_string(), - amount: 100, - }, - ); + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Public { + from: ACC_SENDER.to_string(), + to: ACC_RECEIVER.to_string(), + amount: 100, + }); let wallet_config = fetch_config().await.unwrap(); @@ -285,13 +275,11 @@ pub async fn test_success_two_transactions() { info!("First TX Success!"); - let command = Command::Transfer( - NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { - from: ACC_SENDER.to_string(), - to: ACC_RECEIVER.to_string(), - amount: 100, - }, - ); + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Public { + from: ACC_SENDER.to_string(), + to: ACC_RECEIVER.to_string(), + amount: 100, + }); wallet::execute_subcommand(command).await.unwrap(); @@ -343,20 +331,20 @@ pub async fn test_success_token_program() { let wallet_config = fetch_config().await.unwrap(); // Create new account for the token definition - wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPublic {}, + wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Public {}, ))) .await .unwrap(); // Create new account for the token supply holder - wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPublic {}, + wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Public {}, ))) .await .unwrap(); // Create new account for receiving a token transaction - wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPublic {}, + wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Public {}, ))) .await .unwrap(); @@ -492,8 +480,8 @@ pub async fn test_success_token_program_private_owned() { // Create new account for the token definition (public) let SubcommandReturnValue::RegisterAccount { addr: definition_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPublic {}, + } = wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Public {}, ))) .await .unwrap() @@ -501,20 +489,18 @@ pub async fn test_success_token_program_private_owned() { panic!("invalid subcommand return value"); }; // Create new account for the token supply holder (private) - let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = - wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPrivate {}, - ))) - .await - .unwrap() - else { + let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = wallet::execute_subcommand( + Command::Account(AccountSubcommand::Register(RegisterSubcommand::Private {})), + ) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for receiving a token transaction let SubcommandReturnValue::RegisterAccount { addr: recipient_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPrivate {}, + } = wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Private {}, ))) .await .unwrap() @@ -637,8 +623,8 @@ pub async fn test_success_token_program_private_claiming_path() { // Create new account for the token definition (public) let SubcommandReturnValue::RegisterAccount { addr: definition_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPublic {}, + } = wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Public {}, ))) .await .unwrap() @@ -646,20 +632,18 @@ pub async fn test_success_token_program_private_claiming_path() { panic!("invalid subcommand return value"); }; // Create new account for the token supply holder (private) - let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = - wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPrivate {}, - ))) - .await - .unwrap() - else { + let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = wallet::execute_subcommand( + Command::Account(AccountSubcommand::Register(RegisterSubcommand::Private {})), + ) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for receiving a token transaction let SubcommandReturnValue::RegisterAccount { addr: recipient_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPrivate {}, + } = wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Private {}, ))) .await .unwrap() @@ -740,13 +724,11 @@ pub async fn test_success_token_program_private_claiming_path() { info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let command = Command::Chain(ChainSubcommand::Fetch( - FetchSubcommand::FetchPrivateAccount { - tx_hash, - acc_addr: recipient_addr.to_string(), - output_id: 1, - }, - )); + let command = Command::Account(AccountSubcommand::Fetch(FetchSubcommand::PrivateAccount { + tx_hash, + acc_addr: recipient_addr.to_string(), + output_id: 1, + })); wallet::execute_subcommand(command).await.unwrap(); @@ -774,29 +756,27 @@ pub async fn test_success_token_program_shielded_owned() { // Create new account for the token definition (public) let SubcommandReturnValue::RegisterAccount { addr: definition_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPublic {}, + } = wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Public {}, ))) .await .unwrap() else { panic!("invalid subcommand return value"); }; - // Create new account for the token supply holder (private) - let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = - wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPublic {}, - ))) - .await - .unwrap() - else { + // Create new account for the token supply holder (public) + let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = wallet::execute_subcommand( + Command::Account(AccountSubcommand::Register(RegisterSubcommand::Public {})), + ) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for receiving a token transaction let SubcommandReturnValue::RegisterAccount { addr: recipient_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPrivate {}, + } = wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Private {}, ))) .await .unwrap() @@ -899,8 +879,8 @@ pub async fn test_success_token_program_deshielded_owned() { // Create new account for the token definition (public) let SubcommandReturnValue::RegisterAccount { addr: definition_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPublic {}, + } = wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Public {}, ))) .await .unwrap() @@ -908,20 +888,18 @@ pub async fn test_success_token_program_deshielded_owned() { panic!("invalid subcommand return value"); }; // Create new account for the token supply holder (private) - let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = - wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPrivate {}, - ))) - .await - .unwrap() - else { + let SubcommandReturnValue::RegisterAccount { addr: supply_addr } = wallet::execute_subcommand( + Command::Account(AccountSubcommand::Register(RegisterSubcommand::Private {})), + ) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; // Create new account for receiving a token transaction let SubcommandReturnValue::RegisterAccount { addr: recipient_addr, - } = wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPublic {}, + } = wallet::execute_subcommand(Command::Account(AccountSubcommand::Register( + RegisterSubcommand::Public {}, ))) .await .unwrap() @@ -1034,7 +1012,7 @@ pub async fn test_success_private_transfer_to_another_owned_account() { let to: Address = ACC_RECEIVER_PRIVATE.parse().unwrap(); let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Private( - NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateOwnedAccount { + NativeTokenTransferProgramSubcommandPrivate::PrivateOwned { from: from.to_string(), to: to.to_string(), amount: 100, @@ -1071,7 +1049,7 @@ pub async fn test_success_private_transfer_to_another_foreign_account() { let to_ipk = Secp256k1Point::from_scalar(to_npk.0); let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Private( - NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateForeignAccount { + NativeTokenTransferProgramSubcommandPrivate::PrivateForeign { from: from.to_string(), to_npk: to_npk_string, to_ipk: hex::encode(to_ipk.0), @@ -1113,9 +1091,7 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat info!("test_success_private_transfer_to_another_owned_account_claiming_path"); let from: Address = ACC_SENDER_PRIVATE.parse().unwrap(); - let command = Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPrivate {}, - )); + let command = Command::Account(AccountSubcommand::Register(RegisterSubcommand::Private {})); let sub_ret = wallet::execute_subcommand(command).await.unwrap(); let SubcommandReturnValue::RegisterAccount { addr: to_addr } = sub_ret else { @@ -1137,7 +1113,7 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat .unwrap(); let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Private( - NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateForeignAccount { + NativeTokenTransferProgramSubcommandPrivate::PrivateForeign { from: from.to_string(), to_npk: hex::encode(to_keys.nullifer_public_key.0), to_ipk: hex::encode(to_keys.incoming_viewing_public_key.0), @@ -1152,13 +1128,11 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat let tx = fetch_privacy_preserving_tx(&seq_client, tx_hash.clone()).await; - let command = Command::Chain(ChainSubcommand::Fetch( - FetchSubcommand::FetchPrivateAccount { - tx_hash, - acc_addr: to_addr.to_string(), - output_id: 1, - }, - )); + let command = Command::Account(AccountSubcommand::Fetch(FetchSubcommand::PrivateAccount { + tx_hash, + acc_addr: to_addr.to_string(), + output_id: 1, + })); wallet::execute_subcommand(command).await.unwrap(); let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config) .await @@ -1187,9 +1161,7 @@ pub async fn test_success_private_transfer_to_another_owned_account_cont_run_pat let from: Address = ACC_SENDER_PRIVATE.parse().unwrap(); - let command = Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPrivate {}, - )); + let command = Command::Account(AccountSubcommand::Register(RegisterSubcommand::Private {})); let sub_ret = wallet::execute_subcommand(command).await.unwrap(); let SubcommandReturnValue::RegisterAccount { addr: to_addr } = sub_ret else { @@ -1211,7 +1183,7 @@ pub async fn test_success_private_transfer_to_another_owned_account_cont_run_pat .unwrap(); let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Private( - NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateForeignAccount { + NativeTokenTransferProgramSubcommandPrivate::PrivateForeign { from: from.to_string(), to_npk: hex::encode(to_keys.nullifer_public_key.0), to_ipk: hex::encode(to_keys.incoming_viewing_public_key.0), @@ -1257,13 +1229,11 @@ pub async fn test_success_deshielded_transfer_to_another_account() { info!("test_success_deshielded_transfer_to_another_account"); let from: Address = ACC_SENDER_PRIVATE.parse().unwrap(); let to: Address = ACC_RECEIVER.parse().unwrap(); - let command = Command::Transfer( - NativeTokenTransferProgramSubcommand::SendNativeTokenTransferDeshielded { - from: from.to_string(), - to: to.to_string(), - amount: 100, - }, - ); + let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Deshielded { + from: from.to_string(), + to: to.to_string(), + amount: 100, + }); let wallet_config = fetch_config().await.unwrap(); let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); @@ -1305,7 +1275,7 @@ pub async fn test_success_shielded_transfer_to_another_owned_account() { let from: Address = ACC_SENDER.parse().unwrap(); let to: Address = ACC_RECEIVER_PRIVATE.parse().unwrap(); let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Shielded( - NativeTokenTransferProgramSubcommandShielded::SendNativeTokenTransferShielded { + NativeTokenTransferProgramSubcommandShielded::ShieldedOwned { from: from.to_string(), to: to.to_string(), amount: 100, @@ -1348,12 +1318,13 @@ pub async fn test_success_shielded_transfer_to_another_foreign_account() { let from: Address = ACC_SENDER.parse().unwrap(); let command = Command::Transfer(NativeTokenTransferProgramSubcommand::Shielded( - NativeTokenTransferProgramSubcommandShielded::SendNativeTokenTransferShieldedForeignAccount { - from: from.to_string(), - to_npk: to_npk_string, - to_ipk: hex::encode(to_ipk.0), - amount: 100, - })); + NativeTokenTransferProgramSubcommandShielded::ShieldedForeign { + from: from.to_string(), + to_npk: to_npk_string, + to_ipk: hex::encode(to_ipk.0), + amount: 100, + }, + )); let wallet_config = fetch_config().await.unwrap(); @@ -1390,7 +1361,7 @@ pub async fn test_pinata() { let pinata_prize = 150; let solution = 989106; let command = Command::PinataProgram(PinataProgramSubcommand::Public( - PinataProgramSubcommandPublic::ClaimPinata { + PinataProgramSubcommandPublic::Claim { pinata_addr: pinata_addr.clone(), winner_addr: ACC_SENDER.to_string(), solution, @@ -1438,7 +1409,7 @@ pub async fn test_pinata_private_receiver() { let solution = 989106; let command = Command::PinataProgram(PinataProgramSubcommand::Private( - PinataProgramSubcommandPrivate::ClaimPinataPrivateReceiverOwned { + PinataProgramSubcommandPrivate::ClaimPrivateOwned { pinata_addr: pinata_addr.clone(), winner_addr: ACC_SENDER_PRIVATE.to_string(), solution, @@ -1471,13 +1442,11 @@ pub async fn test_pinata_private_receiver() { .unwrap() .balance; - let command = Command::Chain(ChainSubcommand::Fetch( - FetchSubcommand::FetchPrivateAccount { - tx_hash: tx_hash.clone(), - acc_addr: ACC_SENDER_PRIVATE.to_string(), - output_id: 0, - }, - )); + let command = Command::Account(AccountSubcommand::Fetch(FetchSubcommand::PrivateAccount { + tx_hash: tx_hash.clone(), + acc_addr: ACC_SENDER_PRIVATE.to_string(), + output_id: 0, + })); wallet::execute_subcommand(command).await.unwrap(); let wallet_config = fetch_config().await.unwrap(); @@ -1503,18 +1472,16 @@ pub async fn test_pinata_private_receiver_new_account() { let solution = 989106; // Create new account for the token supply holder (private) - let SubcommandReturnValue::RegisterAccount { addr: winner_addr } = - wallet::execute_subcommand(Command::Chain(ChainSubcommand::Register( - RegisterSubcommand::RegisterAccountPrivate {}, - ))) - .await - .unwrap() - else { + let SubcommandReturnValue::RegisterAccount { addr: winner_addr } = wallet::execute_subcommand( + Command::Account(AccountSubcommand::Register(RegisterSubcommand::Private {})), + ) + .await + .unwrap() else { panic!("invalid subcommand return value"); }; let command = Command::PinataProgram(PinataProgramSubcommand::Private( - PinataProgramSubcommandPrivate::ClaimPinataPrivateReceiverOwned { + PinataProgramSubcommandPrivate::ClaimPrivateOwned { pinata_addr: pinata_addr.clone(), winner_addr: winner_addr.to_string(), solution, diff --git a/wallet/src/cli/account.rs b/wallet/src/cli/account.rs new file mode 100644 index 0000000..9ec4b20 --- /dev/null +++ b/wallet/src/cli/account.rs @@ -0,0 +1,253 @@ +use std::str::FromStr; + +use anyhow::Result; +use clap::Subcommand; +use common::transaction::NSSATransaction; +use nssa::Address; + +use crate::{ + SubcommandReturnValue, WalletCore, cli::WalletSubcommand, helperfunctions::HumanReadableAccount, +}; + +///Represents generic chain CLI subcommand +#[derive(Subcommand, Debug, Clone)] +pub enum AccountSubcommand { + ///Get + #[command(subcommand)] + Get(GetSubcommand), + ///Fetch + #[command(subcommand)] + Fetch(FetchSubcommand), + ///Register + #[command(subcommand)] + Register(RegisterSubcommand), +} + +///Represents generic getter CLI subcommand +#[derive(Subcommand, Debug, Clone)] +pub enum GetSubcommand { + ///Get account `addr` balance + PublicAccountBalance { + #[arg(short, long)] + addr: String, + }, + ///Get account `addr` nonce + PublicAccountNonce { + #[arg(short, long)] + addr: String, + }, + ///Get account at address `addr` + PublicAccount { + #[arg(short, long)] + addr: String, + }, + ///Get private account with `addr` from storage + PrivateAccount { + #[arg(short, long)] + addr: String, + }, +} + +///Represents generic getter CLI subcommand +#[derive(Subcommand, Debug, Clone)] +pub enum FetchSubcommand { + ///Fetch transaction by `hash` + Tx { + #[arg(short, long)] + tx_hash: String, + }, + ///Claim account `acc_addr` generated in transaction `tx_hash`, using secret `sh_secret` at ciphertext id `ciph_id` + PrivateAccount { + ///tx_hash - valid 32 byte hex string + #[arg(long)] + tx_hash: String, + ///acc_addr - valid 32 byte hex string + #[arg(long)] + acc_addr: String, + ///output_id - id of the output in the transaction + #[arg(long)] + output_id: usize, + }, +} + +///Represents generic register CLI subcommand +#[derive(Subcommand, Debug, Clone)] +pub enum RegisterSubcommand { + ///Register new public account + Public {}, + ///Register new private account + Private {}, +} + +impl WalletSubcommand for GetSubcommand { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + GetSubcommand::PublicAccountBalance { addr } => { + let addr = Address::from_str(&addr)?; + + let balance = wallet_core.get_account_balance(addr).await?; + println!("Accounts {addr} balance is {balance}"); + + Ok(SubcommandReturnValue::Empty) + } + GetSubcommand::PublicAccountNonce { addr } => { + let addr = Address::from_str(&addr)?; + + let nonce = wallet_core.get_accounts_nonces(vec![addr]).await?[0]; + println!("Accounts {addr} nonce is {nonce}"); + + Ok(SubcommandReturnValue::Empty) + } + GetSubcommand::PublicAccount { addr } => { + let addr: Address = addr.parse()?; + let account = wallet_core.get_account_public(addr).await?; + let account_hr: HumanReadableAccount = account.clone().into(); + println!("{}", serde_json::to_string(&account_hr).unwrap()); + + Ok(SubcommandReturnValue::Account(account)) + } + GetSubcommand::PrivateAccount { addr } => { + let addr: Address = addr.parse()?; + if let Some(account) = wallet_core.get_account_private(&addr) { + println!("{}", serde_json::to_string(&account).unwrap()); + } else { + println!("Private account not found."); + } + Ok(SubcommandReturnValue::Empty) + } + } + } +} + +impl WalletSubcommand for FetchSubcommand { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + FetchSubcommand::Tx { tx_hash } => { + let tx_obj = wallet_core + .sequencer_client + .get_transaction_by_hash(tx_hash) + .await?; + + println!("Transaction object {tx_obj:#?}"); + + Ok(SubcommandReturnValue::Empty) + } + FetchSubcommand::PrivateAccount { + tx_hash, + acc_addr, + output_id: ciph_id, + } => { + let acc_addr: Address = acc_addr.parse().unwrap(); + + let account_key_chain = wallet_core + .storage + .user_data + .user_private_accounts + .get(&acc_addr); + + let Some((account_key_chain, _)) = account_key_chain else { + anyhow::bail!("Account not found"); + }; + + let transfer_tx = wallet_core.poll_native_token_transfer(tx_hash).await?; + + if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { + let to_ebc = tx.message.encrypted_private_post_states[ciph_id].clone(); + let to_comm = tx.message.new_commitments[ciph_id].clone(); + let shared_secret = + account_key_chain.calculate_shared_secret_receiver(to_ebc.epk); + + let res_acc_to = nssa_core::EncryptionScheme::decrypt( + &to_ebc.ciphertext, + &shared_secret, + &to_comm, + ciph_id as u32, + ) + .unwrap(); + + println!("RES acc to {res_acc_to:#?}"); + + println!("Transaction data is {:?}", tx.message); + + wallet_core + .storage + .insert_private_account_data(acc_addr, res_acc_to); + } + + let path = wallet_core.store_persistent_accounts().await?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::Empty) + } + } + } +} + +impl WalletSubcommand for RegisterSubcommand { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + RegisterSubcommand::Public {} => { + let addr = wallet_core.create_new_account_public(); + + println!("Generated new account with addr {addr}"); + + let path = wallet_core.store_persistent_accounts().await?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::RegisterAccount { addr }) + } + RegisterSubcommand::Private {} => { + let addr = wallet_core.create_new_account_private(); + + let (key, _) = wallet_core + .storage + .user_data + .get_private_account(&addr) + .unwrap(); + + println!("Generated new account with addr {addr}"); + println!("With npk {}", hex::encode(&key.nullifer_public_key)); + println!( + "With ipk {}", + hex::encode(key.incoming_viewing_public_key.to_bytes()) + ); + + let path = wallet_core.store_persistent_accounts().await?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::RegisterAccount { addr }) + } + } + } +} + +impl WalletSubcommand for AccountSubcommand { + async fn handle_subcommand( + self, + wallet_core: &mut WalletCore, + ) -> Result { + match self { + AccountSubcommand::Get(get_subcommand) => { + get_subcommand.handle_subcommand(wallet_core).await + } + AccountSubcommand::Fetch(fetch_subcommand) => { + fetch_subcommand.handle_subcommand(wallet_core).await + } + AccountSubcommand::Register(register_subcommand) => { + register_subcommand.handle_subcommand(wallet_core).await + } + } + } +} diff --git a/wallet/src/cli/chain.rs b/wallet/src/cli/chain.rs index 258c545..4db18fc 100644 --- a/wallet/src/cli/chain.rs +++ b/wallet/src/cli/chain.rs @@ -1,236 +1,20 @@ -use std::str::FromStr; - use anyhow::Result; use clap::Subcommand; -use common::transaction::NSSATransaction; -use nssa::Address; -use crate::{ - SubcommandReturnValue, WalletCore, cli::WalletSubcommand, helperfunctions::HumanReadableAccount, -}; +use crate::{SubcommandReturnValue, WalletCore, cli::WalletSubcommand}; ///Represents generic chain CLI subcommand #[derive(Subcommand, Debug, Clone)] pub enum ChainSubcommand { - ///Get - #[command(subcommand)] - Get(GetSubcommand), - ///Fetch - #[command(subcommand)] - Fetch(FetchSubcommand), - ///Register - #[command(subcommand)] - Register(RegisterSubcommand), -} - -///Represents generic getter CLI subcommand -#[derive(Subcommand, Debug, Clone)] -pub enum GetSubcommand { - ///Get account `addr` balance - GetPublicAccountBalance { + GetLatestBlockId {}, + GetBlockAtId { #[arg(short, long)] - addr: String, + id: u64, }, - ///Get account `addr` nonce - GetPublicAccountNonce { + GetTransactionAtHash { #[arg(short, long)] - addr: String, + hash: String, }, - ///Get account at address `addr` - GetPublicAccount { - #[arg(short, long)] - addr: String, - }, - ///Get private account with `addr` from storage - GetPrivateAccount { - #[arg(short, long)] - addr: String, - }, -} - -///Represents generic getter CLI subcommand -#[derive(Subcommand, Debug, Clone)] -pub enum FetchSubcommand { - ///Fetch transaction by `hash` - FetchTx { - #[arg(short, long)] - tx_hash: String, - }, - ///Claim account `acc_addr` generated in transaction `tx_hash`, using secret `sh_secret` at ciphertext id `ciph_id` - FetchPrivateAccount { - ///tx_hash - valid 32 byte hex string - #[arg(long)] - tx_hash: String, - ///acc_addr - valid 32 byte hex string - #[arg(long)] - acc_addr: String, - ///output_id - id of the output in the transaction - #[arg(long)] - output_id: usize, - }, -} - -///Represents generic register CLI subcommand -#[derive(Subcommand, Debug, Clone)] -pub enum RegisterSubcommand { - ///Register new public account - RegisterAccountPublic {}, - ///Register new private account - RegisterAccountPrivate {}, -} - -impl WalletSubcommand for GetSubcommand { - async fn handle_subcommand( - self, - wallet_core: &mut WalletCore, - ) -> Result { - match self { - GetSubcommand::GetPublicAccountBalance { addr } => { - let addr = Address::from_str(&addr)?; - - let balance = wallet_core.get_account_balance(addr).await?; - println!("Accounts {addr} balance is {balance}"); - - Ok(SubcommandReturnValue::Empty) - } - GetSubcommand::GetPublicAccountNonce { addr } => { - let addr = Address::from_str(&addr)?; - - let nonce = wallet_core.get_accounts_nonces(vec![addr]).await?[0]; - println!("Accounts {addr} nonce is {nonce}"); - - Ok(SubcommandReturnValue::Empty) - } - GetSubcommand::GetPublicAccount { addr } => { - let addr: Address = addr.parse()?; - let account = wallet_core.get_account_public(addr).await?; - let account_hr: HumanReadableAccount = account.clone().into(); - println!("{}", serde_json::to_string(&account_hr).unwrap()); - - Ok(SubcommandReturnValue::Account(account)) - } - GetSubcommand::GetPrivateAccount { addr } => { - let addr: Address = addr.parse()?; - if let Some(account) = wallet_core.get_account_private(&addr) { - println!("{}", serde_json::to_string(&account).unwrap()); - } else { - println!("Private account not found."); - } - Ok(SubcommandReturnValue::Empty) - } - } - } -} - -impl WalletSubcommand for FetchSubcommand { - async fn handle_subcommand( - self, - wallet_core: &mut WalletCore, - ) -> Result { - match self { - FetchSubcommand::FetchTx { tx_hash } => { - let tx_obj = wallet_core - .sequencer_client - .get_transaction_by_hash(tx_hash) - .await?; - - println!("Transaction object {tx_obj:#?}"); - - Ok(SubcommandReturnValue::Empty) - } - FetchSubcommand::FetchPrivateAccount { - tx_hash, - acc_addr, - output_id: ciph_id, - } => { - let acc_addr: Address = acc_addr.parse().unwrap(); - - let account_key_chain = wallet_core - .storage - .user_data - .user_private_accounts - .get(&acc_addr); - - let Some((account_key_chain, _)) = account_key_chain else { - anyhow::bail!("Account not found"); - }; - - let transfer_tx = wallet_core.poll_native_token_transfer(tx_hash).await?; - - if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { - let to_ebc = tx.message.encrypted_private_post_states[ciph_id].clone(); - let to_comm = tx.message.new_commitments[ciph_id].clone(); - let shared_secret = - account_key_chain.calculate_shared_secret_receiver(to_ebc.epk); - - let res_acc_to = nssa_core::EncryptionScheme::decrypt( - &to_ebc.ciphertext, - &shared_secret, - &to_comm, - ciph_id as u32, - ) - .unwrap(); - - println!("RES acc to {res_acc_to:#?}"); - - println!("Transaction data is {:?}", tx.message); - - wallet_core - .storage - .insert_private_account_data(acc_addr, res_acc_to); - } - - let path = wallet_core.store_persistent_accounts().await?; - - println!("Stored persistent accounts at {path:#?}"); - - Ok(SubcommandReturnValue::Empty) - } - } - } -} - -impl WalletSubcommand for RegisterSubcommand { - async fn handle_subcommand( - self, - wallet_core: &mut WalletCore, - ) -> Result { - match self { - RegisterSubcommand::RegisterAccountPublic {} => { - let addr = wallet_core.create_new_account_public(); - - println!("Generated new account with addr {addr}"); - - let path = wallet_core.store_persistent_accounts().await?; - - println!("Stored persistent accounts at {path:#?}"); - - Ok(SubcommandReturnValue::RegisterAccount { addr }) - } - RegisterSubcommand::RegisterAccountPrivate {} => { - let addr = wallet_core.create_new_account_private(); - - let (key, _) = wallet_core - .storage - .user_data - .get_private_account(&addr) - .unwrap(); - - println!("Generated new account with addr {addr}"); - println!("With npk {}", hex::encode(&key.nullifer_public_key)); - println!( - "With ipk {}", - hex::encode(key.incoming_viewing_public_key.to_bytes()) - ); - - let path = wallet_core.store_persistent_accounts().await?; - - println!("Stored persistent accounts at {path:#?}"); - - Ok(SubcommandReturnValue::RegisterAccount { addr }) - } - } - } } impl WalletSubcommand for ChainSubcommand { @@ -239,15 +23,25 @@ impl WalletSubcommand for ChainSubcommand { wallet_core: &mut WalletCore, ) -> Result { match self { - ChainSubcommand::Get(get_subcommand) => { - get_subcommand.handle_subcommand(wallet_core).await + ChainSubcommand::GetLatestBlockId {} => { + let latest_block_res = wallet_core.sequencer_client.get_last_block().await?; + + println!("Last block id is {}", latest_block_res.last_block); } - ChainSubcommand::Fetch(fetch_subcommand) => { - fetch_subcommand.handle_subcommand(wallet_core).await + ChainSubcommand::GetBlockAtId { id } => { + let block_res = wallet_core.sequencer_client.get_block(id).await?; + + println!("Last block id is {:#?}", block_res.block); } - ChainSubcommand::Register(register_subcommand) => { - register_subcommand.handle_subcommand(wallet_core).await + ChainSubcommand::GetTransactionAtHash { hash } => { + let tx_res = wallet_core + .sequencer_client + .get_transaction_by_hash(hash) + .await?; + + println!("Last block id is {:#?}", tx_res.transaction); } } + Ok(SubcommandReturnValue::Empty) } } diff --git a/wallet/src/cli/mod.rs b/wallet/src/cli/mod.rs index 093a501..3aa1b7f 100644 --- a/wallet/src/cli/mod.rs +++ b/wallet/src/cli/mod.rs @@ -2,6 +2,7 @@ use anyhow::Result; use crate::{SubcommandReturnValue, WalletCore}; +pub mod account; pub mod chain; pub mod native_token_transfer_program; pub mod pinata_program; diff --git a/wallet/src/cli/native_token_transfer_program.rs b/wallet/src/cli/native_token_transfer_program.rs index eb6310c..666ea68 100644 --- a/wallet/src/cli/native_token_transfer_program.rs +++ b/wallet/src/cli/native_token_transfer_program.rs @@ -11,7 +11,7 @@ pub enum NativeTokenTransferProgramSubcommand { ///Send native token transfer from `from` to `to` for `amount` /// /// Public operation - SendNativeTokenTransferPublic { + Public { ///from - valid 32 byte hex string #[arg(long)] from: String, @@ -28,7 +28,7 @@ pub enum NativeTokenTransferProgramSubcommand { ///Send native token transfer from `from` to `to` for `amount` /// /// Deshielded operation - SendNativeTokenTransferDeshielded { + Deshielded { ///from - valid 32 byte hex string #[arg(long)] from: String, @@ -50,7 +50,7 @@ pub enum NativeTokenTransferProgramSubcommandShielded { ///Send native token transfer from `from` to `to` for `amount` /// /// Shielded operation - SendNativeTokenTransferShielded { + ShieldedOwned { ///from - valid 32 byte hex string #[arg(long)] from: String, @@ -64,7 +64,7 @@ pub enum NativeTokenTransferProgramSubcommandShielded { ///Send native token transfer from `from` to `to` for `amount` /// /// Shielded operation - SendNativeTokenTransferShieldedForeignAccount { + ShieldedForeign { ///from - valid 32 byte hex string #[arg(long)] from: String, @@ -86,7 +86,7 @@ pub enum NativeTokenTransferProgramSubcommandPrivate { ///Send native token transfer from `from` to `to` for `amount` /// /// Private operation - SendNativeTokenTransferPrivateOwnedAccount { + PrivateOwned { ///from - valid 32 byte hex string #[arg(long)] from: String, @@ -100,7 +100,7 @@ pub enum NativeTokenTransferProgramSubcommandPrivate { ///Send native token transfer from `from` to `to` for `amount` /// /// Private operation - SendNativeTokenTransferPrivateForeignAccount { + PrivateForeign { ///from - valid 32 byte hex string #[arg(long)] from: String, @@ -122,84 +122,92 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommandPrivate { wallet_core: &mut WalletCore, ) -> Result { match self { - NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateOwnedAccount { from, to, amount } => { - let from: Address = from.parse().unwrap(); - let to: Address = to.parse().unwrap(); + NativeTokenTransferProgramSubcommandPrivate::PrivateOwned { from, to, amount } => { + let from: Address = from.parse().unwrap(); + let to: Address = to.parse().unwrap(); - let to_initialization = wallet_core.check_private_account_initialized(&to).await?; + let to_initialization = wallet_core.check_private_account_initialized(&to).await?; - let (res, [secret_from, secret_to]) = if let Some(to_proof) = to_initialization { - wallet_core - .send_private_native_token_transfer_owned_account_already_initialized(from, to, amount, to_proof) - .await? - } else { - wallet_core - .send_private_native_token_transfer_owned_account_not_initialized(from, to, amount) - .await? - }; + let (res, [secret_from, secret_to]) = if let Some(to_proof) = to_initialization { + wallet_core + .send_private_native_token_transfer_owned_account_already_initialized( + from, to, amount, to_proof, + ) + .await? + } else { + wallet_core + .send_private_native_token_transfer_owned_account_not_initialized( + from, to, amount, + ) + .await? + }; - println!("Results of tx send is {res:#?}"); + println!("Results of tx send is {res:#?}"); - let tx_hash = res.tx_hash; - let transfer_tx = wallet_core - .poll_native_token_transfer(tx_hash.clone()) - .await?; + let tx_hash = res.tx_hash; + let transfer_tx = wallet_core + .poll_native_token_transfer(tx_hash.clone()) + .await?; - if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { - let acc_decode_data = vec![(secret_from, from), (secret_to, to)]; + if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { + let acc_decode_data = vec![(secret_from, from), (secret_to, to)]; - wallet_core - .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; + wallet_core.decode_insert_privacy_preserving_transaction_results( + tx, + &acc_decode_data, + )?; + } + + let path = wallet_core.store_persistent_accounts().await?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) } + NativeTokenTransferProgramSubcommandPrivate::PrivateForeign { + from, + to_npk, + to_ipk, + amount, + } => { + let from: Address = from.parse().unwrap(); + let to_npk_res = hex::decode(to_npk)?; + let mut to_npk = [0; 32]; + to_npk.copy_from_slice(&to_npk_res); + let to_npk = nssa_core::NullifierPublicKey(to_npk); - let path = wallet_core.store_persistent_accounts().await?; + let to_ipk_res = hex::decode(to_ipk)?; + let mut to_ipk = [0u8; 33]; + to_ipk.copy_from_slice(&to_ipk_res); + let to_ipk = + nssa_core::encryption::shared_key_derivation::Secp256k1Point(to_ipk.to_vec()); - println!("Stored persistent accounts at {path:#?}"); + let (res, [secret_from, _]) = wallet_core + .send_private_native_token_transfer_outer_account(from, to_npk, to_ipk, amount) + .await?; - Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) - } - NativeTokenTransferProgramSubcommandPrivate::SendNativeTokenTransferPrivateForeignAccount { - from, - to_npk, - to_ipk, - amount, - } => { - let from: Address = from.parse().unwrap(); - let to_npk_res = hex::decode(to_npk)?; - let mut to_npk = [0; 32]; - to_npk.copy_from_slice(&to_npk_res); - let to_npk = nssa_core::NullifierPublicKey(to_npk); + println!("Results of tx send is {res:#?}"); - let to_ipk_res = hex::decode(to_ipk)?; - let mut to_ipk = [0u8; 33]; - to_ipk.copy_from_slice(&to_ipk_res); - let to_ipk = - nssa_core::encryption::shared_key_derivation::Secp256k1Point(to_ipk.to_vec()); + let tx_hash = res.tx_hash; + let transfer_tx = wallet_core + .poll_native_token_transfer(tx_hash.clone()) + .await?; - let (res, [secret_from, _]) = wallet_core - .send_private_native_token_transfer_outer_account(from, to_npk, to_ipk, amount) - .await?; + if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { + let acc_decode_data = vec![(secret_from, from)]; - println!("Results of tx send is {res:#?}"); + wallet_core.decode_insert_privacy_preserving_transaction_results( + tx, + &acc_decode_data, + )?; + } - let tx_hash = res.tx_hash; - let transfer_tx = wallet_core - .poll_native_token_transfer(tx_hash.clone()) - .await?; + let path = wallet_core.store_persistent_accounts().await?; - if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { - let acc_decode_data = vec![(secret_from, from)]; + println!("Stored persistent accounts at {path:#?}"); - wallet_core - .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; + Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) } - - let path = wallet_core.store_persistent_accounts().await?; - - println!("Stored persistent accounts at {path:#?}"); - - Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) - } } } } @@ -210,75 +218,79 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommandShielded { wallet_core: &mut WalletCore, ) -> Result { match self { - NativeTokenTransferProgramSubcommandShielded::SendNativeTokenTransferShielded { from, to, amount } => { - let from: Address = from.parse().unwrap(); - let to: Address = to.parse().unwrap(); + NativeTokenTransferProgramSubcommandShielded::ShieldedOwned { from, to, amount } => { + let from: Address = from.parse().unwrap(); + let to: Address = to.parse().unwrap(); - let to_initialization = wallet_core.check_private_account_initialized(&to).await?; + let to_initialization = wallet_core.check_private_account_initialized(&to).await?; - let (res, secret) = if let Some(to_proof) = to_initialization { - wallet_core - .send_shielded_native_token_transfer_already_initialized(from, to, amount, to_proof) - .await? - } else { - wallet_core - .send_shielded_native_token_transfer_not_initialized(from, to, amount) - .await? - }; + let (res, secret) = if let Some(to_proof) = to_initialization { + wallet_core + .send_shielded_native_token_transfer_already_initialized( + from, to, amount, to_proof, + ) + .await? + } else { + wallet_core + .send_shielded_native_token_transfer_not_initialized(from, to, amount) + .await? + }; - println!("Results of tx send is {res:#?}"); + println!("Results of tx send is {res:#?}"); - let tx_hash = res.tx_hash; - let transfer_tx = wallet_core - .poll_native_token_transfer(tx_hash.clone()) - .await?; + let tx_hash = res.tx_hash; + let transfer_tx = wallet_core + .poll_native_token_transfer(tx_hash.clone()) + .await?; - if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { - let acc_decode_data = vec![(secret, to)]; + if let NSSATransaction::PrivacyPreserving(tx) = transfer_tx { + let acc_decode_data = vec![(secret, to)]; - wallet_core - .decode_insert_privacy_preserving_transaction_results(tx, &acc_decode_data)?; + wallet_core.decode_insert_privacy_preserving_transaction_results( + tx, + &acc_decode_data, + )?; + } + + let path = wallet_core.store_persistent_accounts().await?; + + println!("Stored persistent accounts at {path:#?}"); + + Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) } + NativeTokenTransferProgramSubcommandShielded::ShieldedForeign { + from, + to_npk, + to_ipk, + amount, + } => { + let from: Address = from.parse().unwrap(); - let path = wallet_core.store_persistent_accounts().await?; + let to_npk_res = hex::decode(to_npk)?; + let mut to_npk = [0; 32]; + to_npk.copy_from_slice(&to_npk_res); + let to_npk = nssa_core::NullifierPublicKey(to_npk); - println!("Stored persistent accounts at {path:#?}"); + let to_ipk_res = hex::decode(to_ipk)?; + let mut to_ipk = [0u8; 33]; + to_ipk.copy_from_slice(&to_ipk_res); + let to_ipk = + nssa_core::encryption::shared_key_derivation::Secp256k1Point(to_ipk.to_vec()); - Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) - } - NativeTokenTransferProgramSubcommandShielded::SendNativeTokenTransferShieldedForeignAccount { - from, - to_npk, - to_ipk, - amount, - } => { - let from: Address = from.parse().unwrap(); + let (res, _) = wallet_core + .send_shielded_native_token_transfer_outer_account(from, to_npk, to_ipk, amount) + .await?; - let to_npk_res = hex::decode(to_npk)?; - let mut to_npk = [0; 32]; - to_npk.copy_from_slice(&to_npk_res); - let to_npk = nssa_core::NullifierPublicKey(to_npk); + println!("Results of tx send is {res:#?}"); - let to_ipk_res = hex::decode(to_ipk)?; - let mut to_ipk = [0u8; 33]; - to_ipk.copy_from_slice(&to_ipk_res); - let to_ipk = - nssa_core::encryption::shared_key_derivation::Secp256k1Point(to_ipk.to_vec()); + let tx_hash = res.tx_hash; - let (res, _) = wallet_core - .send_shielded_native_token_transfer_outer_account(from, to_npk, to_ipk, amount) - .await?; + let path = wallet_core.store_persistent_accounts().await?; - println!("Results of tx send is {res:#?}"); + println!("Stored persistent accounts at {path:#?}"); - let tx_hash = res.tx_hash; - - let path = wallet_core.store_persistent_accounts().await?; - - println!("Stored persistent accounts at {path:#?}"); - - Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) - } + Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) + } } } } @@ -295,11 +307,7 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommand { NativeTokenTransferProgramSubcommand::Shielded(shielded_subcommand) => { shielded_subcommand.handle_subcommand(wallet_core).await } - NativeTokenTransferProgramSubcommand::SendNativeTokenTransferDeshielded { - from, - to, - amount, - } => { + NativeTokenTransferProgramSubcommand::Deshielded { from, to, amount } => { let from: Address = from.parse().unwrap(); let to: Address = to.parse().unwrap(); @@ -329,11 +337,7 @@ impl WalletSubcommand for NativeTokenTransferProgramSubcommand { Ok(SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash }) } - NativeTokenTransferProgramSubcommand::SendNativeTokenTransferPublic { - from, - to, - amount, - } => { + NativeTokenTransferProgramSubcommand::Public { from, to, amount } => { let from: Address = from.parse().unwrap(); let to: Address = to.parse().unwrap(); diff --git a/wallet/src/cli/pinata_program.rs b/wallet/src/cli/pinata_program.rs index 6ccfb97..75d3d6a 100644 --- a/wallet/src/cli/pinata_program.rs +++ b/wallet/src/cli/pinata_program.rs @@ -21,7 +21,7 @@ pub enum PinataProgramSubcommand { pub enum PinataProgramSubcommandPublic { // TODO: Testnet only. Refactor to prevent compilation on mainnet. // Claim piñata prize - ClaimPinata { + Claim { ///pinata_addr - valid 32 byte hex string #[arg(long)] pinata_addr: String, @@ -39,7 +39,7 @@ pub enum PinataProgramSubcommandPublic { pub enum PinataProgramSubcommandPrivate { // TODO: Testnet only. Refactor to prevent compilation on mainnet. // Claim piñata prize - ClaimPinataPrivateReceiverOwned { + ClaimPrivateOwned { ///pinata_addr - valid 32 byte hex string #[arg(long)] pinata_addr: String, @@ -58,7 +58,7 @@ impl WalletSubcommand for PinataProgramSubcommandPublic { wallet_core: &mut WalletCore, ) -> Result { match self { - PinataProgramSubcommandPublic::ClaimPinata { + PinataProgramSubcommandPublic::Claim { pinata_addr, winner_addr, solution, @@ -84,7 +84,7 @@ impl WalletSubcommand for PinataProgramSubcommandPrivate { wallet_core: &mut WalletCore, ) -> Result { match self { - PinataProgramSubcommandPrivate::ClaimPinataPrivateReceiverOwned { + PinataProgramSubcommandPrivate::ClaimPrivateOwned { pinata_addr, winner_addr, solution, diff --git a/wallet/src/lib.rs b/wallet/src/lib.rs index ae96064..501d096 100644 --- a/wallet/src/lib.rs +++ b/wallet/src/lib.rs @@ -18,7 +18,7 @@ use nssa_core::{Commitment, MembershipProof}; use tokio::io::AsyncWriteExt; use crate::cli::{ - WalletSubcommand, chain::ChainSubcommand, + WalletSubcommand, account::AccountSubcommand, chain::ChainSubcommand, native_token_transfer_program::NativeTokenTransferProgramSubcommand, pinata_program::PinataProgramSubcommand, }; @@ -193,6 +193,9 @@ pub enum Command { ///Chain command #[command(subcommand)] Chain(ChainSubcommand), + ///Chain command + #[command(subcommand)] + Account(AccountSubcommand), ///Pinata command #[command(subcommand)] PinataProgram(PinataProgramSubcommand), @@ -234,6 +237,11 @@ pub async fn execute_subcommand(command: Command) -> Result { chain_subcommand.handle_subcommand(&mut wallet_core).await? } + Command::Account(account_subcommand) => { + account_subcommand + .handle_subcommand(&mut wallet_core) + .await? + } Command::PinataProgram(pinata_subcommand) => { pinata_subcommand .handle_subcommand(&mut wallet_core) diff --git a/wallet/src/main.rs b/wallet/src/main.rs index 9cab532..ecc50d2 100644 --- a/wallet/src/main.rs +++ b/wallet/src/main.rs @@ -1,5 +1,5 @@ use anyhow::Result; -use clap::Parser; +use clap::{CommandFactory, Parser}; use tokio::runtime::Builder; use wallet::{Args, execute_continious_run, execute_subcommand}; @@ -22,7 +22,8 @@ fn main() -> Result<()> { } else if args.continious_run { execute_continious_run().await.unwrap(); } else { - println!("NOTHING TO DO"); + let help = Args::command().render_long_help(); + println!("{help}"); } });