From 8f874a6b4ff6ba03757c2eba0bda0a1a3227fb0a Mon Sep 17 00:00:00 2001 From: Sergio Chouhy Date: Fri, 3 Oct 2025 15:59:27 -0300 Subject: [PATCH] refactor --- integration_tests/Cargo.toml | 2 +- integration_tests/src/lib.rs | 526 +++++++++-------------- wallet/src/chain_storage/mod.rs | 1 + wallet/src/helperfunctions.rs | 5 - wallet/src/lib.rs | 60 ++- wallet/src/token_transfers/deshielded.rs | 53 ++- wallet/src/token_transfers/private.rs | 142 +++--- wallet/src/token_transfers/public.rs | 21 +- wallet/src/token_transfers/shielded.rs | 115 +++-- 9 files changed, 395 insertions(+), 530 deletions(-) diff --git a/integration_tests/Cargo.toml b/integration_tests/Cargo.toml index a5f975b..75edf51 100644 --- a/integration_tests/Cargo.toml +++ b/integration_tests/Cargo.toml @@ -8,8 +8,8 @@ anyhow.workspace = true env_logger.workspace = true log.workspace = true actix.workspace = true - actix-web.workspace = true +base64.workspace = true tokio.workspace = true hex.workspace = true tempfile.workspace = true diff --git a/integration_tests/src/lib.rs b/integration_tests/src/lib.rs index 87df4b1..58d2edc 100644 --- a/integration_tests/src/lib.rs +++ b/integration_tests/src/lib.rs @@ -1,12 +1,18 @@ +use base64::{Engine, engine::general_purpose::STANDARD as BASE64}; use std::{path::PathBuf, time::Duration}; use actix_web::dev::ServerHandle; use anyhow::Result; use clap::Parser; -use common::sequencer_client::SequencerClient; +use common::{ + sequencer_client::SequencerClient, + transaction::{EncodedTransaction, NSSATransaction}, +}; use log::{info, warn}; -use nssa::program::Program; -use nssa_core::{NullifierPublicKey, encryption::shared_key_derivation::Secp256k1Point}; +use nssa::{Address, PrivacyPreservingTransaction, program::Program}; +use nssa_core::{ + Commitment, NullifierPublicKey, encryption::shared_key_derivation::Secp256k1Point, +}; use sequencer_core::config::SequencerConfig; use sequencer_runner::startup_sequencer; use tempfile::TempDir; @@ -14,7 +20,7 @@ use tokio::task::JoinHandle; use wallet::{ Command, SubcommandReturnValue, WalletCore, config::PersistentAccountData, - helperfunctions::{fetch_config, fetch_persistent_accounts, produce_account_addr_from_hex}, + helperfunctions::{fetch_config, fetch_persistent_accounts}, }; #[derive(Parser, Debug)] @@ -443,159 +449,118 @@ pub async fn test_success_token_program() { pub async fn test_success_private_transfer_to_another_owned_account() { info!("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: ACC_SENDER_PRIVATE.to_string(), - to: ACC_RECEIVER_PRIVATE.to_string(), + from: from.to_string(), + to: to.to_string(), amount: 100, }; - let from = produce_account_addr_from_hex(ACC_SENDER_PRIVATE.to_string()).unwrap(); - let to = produce_account_addr_from_hex(ACC_RECEIVER_PRIVATE.to_string()).unwrap(); - - let wallet_config = fetch_config().unwrap(); - - let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); - - let mut wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); - - wallet::execute_subcommand(command).await.unwrap(); + let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } = + wallet::execute_subcommand(command).await.unwrap() + else { + panic!("invalid subcommand return value"); + }; info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let new_commitment1 = { - let from_acc = wallet_storage - .storage - .user_data - .get_private_account_mut(&from) - .unwrap(); - - from_acc.1.program_owner = nssa::program::Program::authenticated_transfer_program().id(); - from_acc.1.balance -= 100; - from_acc.1.nonce += 1; - - nssa_core::Commitment::new(&from_acc.0.nullifer_public_key, &from_acc.1) + let command = Command::ClaimPrivateAccount { + tx_hash: tx_hash.clone(), + acc_addr: from.to_string(), + ciph_id: 0, }; + wallet::execute_subcommand(command).await.unwrap(); - let new_commitment2 = { - let to_acc = wallet_storage - .storage - .user_data - .get_private_account_mut(&to) - .unwrap(); - - to_acc.1.program_owner = nssa::program::Program::authenticated_transfer_program().id(); - to_acc.1.balance += 100; - to_acc.1.nonce += 1; - - nssa_core::Commitment::new(&to_acc.0.nullifer_public_key, &to_acc.1) + let command = Command::ClaimPrivateAccount { + tx_hash, + acc_addr: to.to_string(), + ciph_id: 1, }; + wallet::execute_subcommand(command).await.unwrap(); - let proof1 = seq_client - .get_proof_for_commitment(new_commitment1) - .await - .unwrap() - .unwrap(); - let proof2 = seq_client - .get_proof_for_commitment(new_commitment2) - .await - .unwrap() - .unwrap(); + let wallet_config = fetch_config().unwrap(); + let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); - println!("New proof is {proof1:#?}"); - println!("New proof is {proof2:#?}"); + let new_commitment1 = wallet_storage + .get_private_account_commitment(&from) + .unwrap(); + assert!(verify_commitment_is_in_state(new_commitment1, &seq_client).await); + + let new_commitment2 = wallet_storage.get_private_account_commitment(&to).unwrap(); + assert!(verify_commitment_is_in_state(new_commitment2, &seq_client).await); info!("Success!"); } pub async fn test_success_private_transfer_to_another_foreign_account() { info!("test_success_private_transfer_to_another_foreign_account"); - let to_npk_orig = NullifierPublicKey([42; 32]); - let to_npk = hex::encode(to_npk_orig.0); - let to_ipk = Secp256k1Point::from_scalar(to_npk_orig.0); + let from: Address = ACC_SENDER_PRIVATE.parse().unwrap(); + let to_npk = NullifierPublicKey([42; 32]); + let to_npk_string = hex::encode(to_npk.0); + let to_ipk = Secp256k1Point::from_scalar(to_npk.0); let command = Command::SendNativeTokenTransferPrivateForeignAccount { - from: ACC_SENDER_PRIVATE.to_string(), - to_npk, + from: from.to_string(), + to_npk: to_npk_string, to_ipk: hex::encode(to_ipk.0), amount: 100, }; - let from = produce_account_addr_from_hex(ACC_SENDER_PRIVATE.to_string()).unwrap(); - - let wallet_config = fetch_config().unwrap(); - - let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); - - let mut wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); - - let sub_ret = wallet::execute_subcommand(command).await.unwrap(); - - println!("SUB RET is {sub_ret:#?}"); + let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } = + wallet::execute_subcommand(command).await.unwrap() + else { + panic!("invalid subcommand return value"); + }; info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let new_commitment1 = { - let from_acc = wallet_storage - .storage - .user_data - .get_private_account_mut(&from) - .unwrap(); - - from_acc.1.program_owner = nssa::program::Program::authenticated_transfer_program().id(); - from_acc.1.balance -= 100; - from_acc.1.nonce += 1; - - nssa_core::Commitment::new(&from_acc.0.nullifer_public_key, &from_acc.1) + let command = Command::ClaimPrivateAccount { + tx_hash: tx_hash.clone(), + acc_addr: from.to_string(), + ciph_id: 0, }; + wallet::execute_subcommand(command).await.unwrap(); - let new_commitment2 = { - let to_acc = nssa_core::account::Account { - program_owner: nssa::program::Program::authenticated_transfer_program().id(), - balance: 100, - data: vec![], - nonce: 1, - }; + let wallet_config = fetch_config().unwrap(); + let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); - nssa_core::Commitment::new(&to_npk_orig, &to_acc) - }; - - let proof1 = seq_client - .get_proof_for_commitment(new_commitment1) - .await - .unwrap() - .unwrap(); - let proof2 = seq_client - .get_proof_for_commitment(new_commitment2) - .await - .unwrap() + let new_commitment1 = wallet_storage + .get_private_account_commitment(&from) .unwrap(); - println!("New proof is {proof1:#?}"); - println!("New proof is {proof2:#?}"); + let tx = fetch_privacy_preserving_tx(&seq_client, tx_hash.clone()).await; + 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); + } info!("Success!"); } pub async fn test_success_private_transfer_to_another_owned_account_claiming_path() { info!("test_success_private_transfer_to_another_owned_account_claiming_path"); + let from: Address = ACC_SENDER_PRIVATE.parse().unwrap(); + let command = Command::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().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 mut wallet_storage = - WalletCore::start_from_config_update_chain(wallet_config.clone()).unwrap(); - - let (to_keys, mut to_acc) = wallet_storage + let (to_keys, _) = wallet_storage .storage .user_data .user_private_accounts @@ -604,74 +569,38 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat .unwrap(); let command = Command::SendNativeTokenTransferPrivateForeignAccount { - from: ACC_SENDER_PRIVATE.to_string(), + 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 from = produce_account_addr_from_hex(ACC_SENDER_PRIVATE.to_string()).unwrap(); - let sub_ret = wallet::execute_subcommand(command).await.unwrap(); - let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } = sub_ret else { panic!("FAILED TO SEND TX"); }; - info!("Waiting for next block creation"); - tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - - let new_commitment1 = { - let from_acc = wallet_storage - .storage - .user_data - .get_private_account_mut(&from) - .unwrap(); - - from_acc.1.program_owner = nssa::program::Program::authenticated_transfer_program().id(); - from_acc.1.balance -= 100; - from_acc.1.nonce += 1; - - nssa_core::Commitment::new(&from_acc.0.nullifer_public_key, &from_acc.1) - }; - - let new_commitment2 = { - to_acc.program_owner = nssa::program::Program::authenticated_transfer_program().id(); - to_acc.balance = 100; - to_acc.nonce = 1; - - nssa_core::Commitment::new(&to_keys.nullifer_public_key, &to_acc) - }; - - let proof1 = seq_client - .get_proof_for_commitment(new_commitment1) - .await - .unwrap() - .unwrap(); - let proof2 = seq_client - .get_proof_for_commitment(new_commitment2) - .await - .unwrap() - .unwrap(); - - println!("New proof is {proof1:#?}"); - println!("New proof is {proof2:#?}"); + let tx = fetch_privacy_preserving_tx(&seq_client, tx_hash.clone()).await; let command = Command::ClaimPrivateAccount { tx_hash, - acc_addr: hex::encode(to_addr), + acc_addr: to_addr.to_string(), ciph_id: 1, }; - wallet::execute_subcommand(command).await.unwrap(); - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); - let (_, to_res_acc) = wallet_storage - .storage - .user_data - .get_private_account(&to_addr) + 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); @@ -680,51 +609,50 @@ pub async fn test_success_private_transfer_to_another_owned_account_claiming_pat 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: ACC_SENDER_PRIVATE.to_string(), - to: ACC_RECEIVER.to_string(), + from: from.to_string(), + to: to.to_string(), amount: 100, }; - let from = produce_account_addr_from_hex(ACC_SENDER_PRIVATE.to_string()).unwrap(); - let wallet_config = fetch_config().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 mut wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); + let from_acc = wallet_storage.get_account_private(&from).unwrap(); + assert_eq!(from_acc.balance, 10000); - wallet::execute_subcommand(command).await.unwrap(); + let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } = + wallet::execute_subcommand(command).await.unwrap() + else { + panic!("invalid subcommand return value"); + }; info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let new_commitment1 = { - let from_acc = wallet_storage - .storage - .user_data - .get_private_account_mut(&from) - .unwrap(); - - from_acc.1.program_owner = nssa::program::Program::authenticated_transfer_program().id(); - from_acc.1.balance -= 100; - from_acc.1.nonce += 1; - - nssa_core::Commitment::new(&from_acc.0.nullifer_public_key, &from_acc.1) + let command = Command::ClaimPrivateAccount { + tx_hash, + acc_addr: from.to_string(), + ciph_id: 0, }; + wallet::execute_subcommand(command).await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); - let proof1 = seq_client - .get_proof_for_commitment(new_commitment1) - .await - .unwrap() + let from_acc = wallet_storage.get_account_private(&from).unwrap(); + let new_commitment = wallet_storage + .get_private_account_commitment(&from) .unwrap(); + assert!(verify_commitment_is_in_state(new_commitment, &seq_client).await); let acc_2_balance = seq_client - .get_account_balance(ACC_RECEIVER.to_string()) + .get_account_balance(to.to_string()) .await .unwrap(); - println!("New proof is {proof1:#?}"); + assert_eq!(from_acc.balance, 10000 - 100); assert_eq!(acc_2_balance.balance, 20100); info!("Success!"); @@ -732,66 +660,59 @@ pub async fn test_success_deshielded_transfer_to_another_account() { 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: ACC_SENDER.to_string(), - to: ACC_RECEIVER_PRIVATE.to_string(), + from: from.to_string(), + to: to.to_string(), amount: 100, }; - let to = produce_account_addr_from_hex(ACC_RECEIVER_PRIVATE.to_string()).unwrap(); - let wallet_config = fetch_config().unwrap(); - let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); - let mut wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); - - wallet::execute_subcommand(command).await.unwrap(); + let SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } = + wallet::execute_subcommand(command).await.unwrap() + else { + panic!("invalid subcommand return value"); + }; info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let new_commitment2 = { - let to_acc = wallet_storage - .storage - .user_data - .get_private_account_mut(&to) - .unwrap(); - - to_acc.1.program_owner = nssa::program::Program::authenticated_transfer_program().id(); - to_acc.1.balance += 100; - to_acc.1.nonce += 1; - - nssa_core::Commitment::new(&to_acc.0.nullifer_public_key, &to_acc.1) + let command = Command::ClaimPrivateAccount { + tx_hash, + acc_addr: to.to_string(), + ciph_id: 0, }; + wallet::execute_subcommand(command).await.unwrap(); + let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); - let acc_1_balance = seq_client - .get_account_balance(ACC_SENDER.to_string()) + let acc_to = wallet_storage.get_account_private(&to).unwrap(); + let new_commitment = wallet_storage.get_private_account_commitment(&to).unwrap(); + assert!(verify_commitment_is_in_state(new_commitment, &seq_client).await); + + let acc_from_balance = seq_client + .get_account_balance(from.to_string()) .await .unwrap(); - let proof2 = seq_client - .get_proof_for_commitment(new_commitment2) - .await - .unwrap() - .unwrap(); - - assert_eq!(acc_1_balance.balance, 9900); - - println!("New proof is {proof2:#?}"); + assert_eq!(acc_from_balance.balance, 9900); + assert_eq!(acc_to.balance, 20000 + 100); info!("Success!"); } pub async fn test_success_shielded_transfer_to_another_foreign_account() { info!("test_success_shielded_transfer_to_another_foreign_account"); - let to_npk_orig = NullifierPublicKey([42; 32]); - let to_npk = hex::encode(to_npk_orig.0); - let to_ipk = Secp256k1Point::from_scalar(to_npk_orig.0); + let to_npk = NullifierPublicKey([42; 32]); + let to_npk_string = hex::encode(to_npk.0); + let to_ipk = Secp256k1Point::from_scalar(to_npk.0); + let from: Address = ACC_SENDER.parse().unwrap(); let command = Command::SendNativeTokenTransferShieldedForeignAccount { - from: ACC_SENDER.to_string(), - to_npk, + from: from.to_string(), + to_npk: to_npk_string, to_ipk: hex::encode(to_ipk.0), amount: 100, }; @@ -800,118 +721,27 @@ pub async fn test_success_shielded_transfer_to_another_foreign_account() { let seq_client = SequencerClient::new(wallet_config.sequencer_addr.clone()).unwrap(); - wallet::execute_subcommand(command).await.unwrap(); - - info!("Waiting for next block creation"); - tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - - let new_commitment2 = { - let to_acc = nssa_core::account::Account { - program_owner: nssa::program::Program::authenticated_transfer_program().id(), - balance: 100, - data: vec![], - nonce: 1, - }; - - nssa_core::Commitment::new(&to_npk_orig, &to_acc) - }; - - let acc_1_balance = seq_client - .get_account_balance(ACC_SENDER.to_string()) - .await - .unwrap(); - - let proof2 = seq_client - .get_proof_for_commitment(new_commitment2) - .await - .unwrap() - .unwrap(); - - assert_eq!(acc_1_balance.balance, 9900); - println!("New proof is {proof2:#?}"); - - info!("Success!"); -} - -pub async fn test_success_shielded_transfer_to_another_owned_account_claiming_path() { - info!("test_success_shielded_transfer_to_another_owned_account_claiming_path"); - let command = Command::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().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 (to_keys, mut to_acc) = wallet_storage - .storage - .user_data - .user_private_accounts - .get(&to_addr) - .cloned() - .unwrap(); - - let command = Command::SendNativeTokenTransferShieldedForeignAccount { - from: ACC_SENDER.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 SubcommandReturnValue::PrivacyPreservingTransfer { tx_hash } = + wallet::execute_subcommand(command).await.unwrap() + else { + panic!("invalid subcommand return value"); }; info!("Waiting for next block creation"); tokio::time::sleep(Duration::from_secs(TIME_TO_WAIT_FOR_BLOCK_SECONDS)).await; - let new_commitment2 = { - to_acc.program_owner = nssa::program::Program::authenticated_transfer_program().id(); - to_acc.balance = 100; - to_acc.nonce = 1; - - nssa_core::Commitment::new(&to_keys.nullifer_public_key, &to_acc) - }; + let tx = fetch_privacy_preserving_tx(&seq_client, tx_hash).await; let acc_1_balance = seq_client - .get_account_balance(ACC_SENDER.to_string()) + .get_account_balance(from.to_string()) .await .unwrap(); - let proof2 = seq_client - .get_proof_for_commitment(new_commitment2) - .await - .unwrap() - .unwrap(); + assert!( + verify_commitment_is_in_state(tx.message.new_commitments[0].clone(), &seq_client).await + ); assert_eq!(acc_1_balance.balance, 9900); - println!("New proof is {proof2:#?}"); - - let command = Command::ClaimPrivateAccount { - tx_hash, - acc_addr: hex::encode(to_addr), - ciph_id: 0, - }; - - wallet::execute_subcommand(command).await.unwrap(); - - let wallet_storage = WalletCore::start_from_config_update_chain(wallet_config).unwrap(); - - let (_, to_res_acc) = wallet_storage - .storage - .user_data - .get_private_account(&to_addr) - .unwrap(); - - assert_eq!(to_res_acc.balance, 100); info!("Success!"); } @@ -1038,12 +868,6 @@ pub async fn main_tests_runner() -> Result<()> { test_success_shielded_transfer_to_another_foreign_account ); } - "test_success_shielded_transfer_to_another_owned_account_claiming_path" => { - test_cleanup_wrap!( - home_dir, - test_success_shielded_transfer_to_another_owned_account_claiming_path - ); - } "test_pinata" => { test_cleanup_wrap!(home_dir, test_pinata); } @@ -1077,11 +901,33 @@ pub async fn main_tests_runner() -> Result<()> { home_dir, test_success_private_transfer_to_another_owned_account_claiming_path ); + test_cleanup_wrap!(home_dir, test_pinata); + } + "all_private" => { test_cleanup_wrap!( home_dir, - test_success_shielded_transfer_to_another_owned_account_claiming_path + test_success_private_transfer_to_another_owned_account + ); + test_cleanup_wrap!( + home_dir, + test_success_private_transfer_to_another_foreign_account + ); + test_cleanup_wrap!( + home_dir, + test_success_deshielded_transfer_to_another_account + ); + test_cleanup_wrap!( + home_dir, + test_success_shielded_transfer_to_another_owned_account + ); + test_cleanup_wrap!( + home_dir, + test_success_shielded_transfer_to_another_foreign_account + ); + test_cleanup_wrap!( + home_dir, + test_success_private_transfer_to_another_owned_account_claiming_path ); - test_cleanup_wrap!(home_dir, test_pinata); } _ => { anyhow::bail!("Unknown test name"); @@ -1090,3 +936,33 @@ pub async fn main_tests_runner() -> Result<()> { Ok(()) } + +async fn fetch_privacy_preserving_tx( + seq_client: &SequencerClient, + tx_hash: String, +) -> PrivacyPreservingTransaction { + let transaction_encoded = seq_client + .get_transaction_by_hash(tx_hash.clone()) + .await + .unwrap() + .transaction + .unwrap(); + + let tx_base64_decode = BASE64.decode(transaction_encoded).unwrap(); + match NSSATransaction::try_from(&EncodedTransaction::from_bytes(tx_base64_decode)).unwrap() { + NSSATransaction::PrivacyPreserving(privacy_preserving_transaction) => { + privacy_preserving_transaction + } + _ => panic!("Invalid tx type"), + } +} + +async fn verify_commitment_is_in_state( + commitment: Commitment, + seq_client: &SequencerClient, +) -> bool { + match seq_client.get_proof_for_commitment(commitment).await { + Ok(Some(_)) => true, + _ => false, + } +} diff --git a/wallet/src/chain_storage/mod.rs b/wallet/src/chain_storage/mod.rs index 825d51c..d4123d6 100644 --- a/wallet/src/chain_storage/mod.rs +++ b/wallet/src/chain_storage/mod.rs @@ -43,6 +43,7 @@ impl WalletChainStore { addr: nssa::Address, account: nssa_core::account::Account, ) { + println!("inserting at addres {}, this account {:?}", addr, account); self.user_data .user_private_accounts .entry(addr) diff --git a/wallet/src/helperfunctions.rs b/wallet/src/helperfunctions.rs index d08f206..5b2c456 100644 --- a/wallet/src/helperfunctions.rs +++ b/wallet/src/helperfunctions.rs @@ -30,11 +30,6 @@ pub fn fetch_config() -> Result { Ok(serde_json::from_reader(reader)?) } -// ToDo: Replace with structures conversion in future -pub fn produce_account_addr_from_hex(hex_str: String) -> Result
{ - Ok(hex_str.parse()?) -} - /// 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 diff --git a/wallet/src/lib.rs b/wallet/src/lib.rs index 3308248..e89a28a 100644 --- a/wallet/src/lib.rs +++ b/wallet/src/lib.rs @@ -14,11 +14,12 @@ use log::info; use nssa::{Account, Address}; use clap::{Parser, Subcommand}; +use nssa_core::Commitment; use crate::{ helperfunctions::{ HumanReadableAccount, fetch_config, fetch_persistent_accounts, get_home, - produce_account_addr_from_hex, produce_data_for_storage, + produce_data_for_storage, }, poller::TxPoller, }; @@ -180,11 +181,24 @@ impl WalletCore { } ///Get account - pub async fn get_account(&self, addr: Address) -> Result { + pub async fn get_account_public(&self, addr: Address) -> Result { let response = self.sequencer_client.get_account(addr.to_string()).await?; Ok(response.account) } + pub fn get_account_private(&self, addr: &Address) -> Option { + self.storage + .user_data + .user_private_accounts + .get(addr) + .map(|value| value.1.clone()) + } + + pub fn get_private_account_commitment(&self, addr: &Address) -> Option { + let (keys, account) = self.storage.user_data.user_private_accounts.get(addr)?; + Some(Commitment::new(&keys.nullifer_public_key, account)) + } + ///Poll transactions pub async fn poll_native_token_transfer(&self, hash: String) -> Result { let transaction_encoded = self.poller.poll_tx(hash).await?; @@ -301,6 +315,11 @@ pub enum Command { #[arg(long)] ciph_id: usize, }, + ///Get private account with `addr` from storage + GetPrivateAccount { + #[arg(short, long)] + addr: String, + }, ///Register new public account RegisterAccountPublic {}, ///Register new private account @@ -373,6 +392,7 @@ pub struct Args { pub enum SubcommandReturnValue { PrivacyPreservingTransfer { tx_hash: String }, RegisterAccount { addr: nssa::Address }, + Account(nssa::Account), Empty, } @@ -382,8 +402,8 @@ pub async fn execute_subcommand(command: Command) -> Result { - let from = produce_account_addr_from_hex(from)?; - let to = produce_account_addr_from_hex(to)?; + let from: Address = from.parse().unwrap(); + let to: Address = to.parse().unwrap(); let res = wallet_core .send_public_native_token_transfer(from, to, amount) @@ -402,8 +422,8 @@ pub async fn execute_subcommand(command: Command) -> Result { - let from = produce_account_addr_from_hex(from)?; - let to = produce_account_addr_from_hex(to)?; + 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) @@ -464,7 +484,7 @@ pub async fn execute_subcommand(command: Command) -> Result { - let from = produce_account_addr_from_hex(from)?; + 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); @@ -527,8 +547,8 @@ pub async fn execute_subcommand(command: Command) -> Result { - let from = produce_account_addr_from_hex(from)?; - let to = produce_account_addr_from_hex(to)?; + 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) @@ -569,8 +589,8 @@ pub async fn execute_subcommand(command: Command) -> Result { - let from = produce_account_addr_from_hex(from)?; - let to = produce_account_addr_from_hex(to)?; + 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) @@ -608,7 +628,7 @@ pub async fn execute_subcommand(command: Command) -> Result { - let from = produce_account_addr_from_hex(from)?; + let from: Address = from.parse().unwrap(); let to_npk_res = hex::decode(to_npk)?; let mut to_npk = [0; 32]; @@ -656,7 +676,7 @@ pub async fn execute_subcommand(command: Command) -> Result { - let acc_addr = produce_account_addr_from_hex(acc_addr)?; + let acc_addr: Address = acc_addr.parse().unwrap(); let account_key_chain = wallet_core .storage @@ -759,9 +779,19 @@ pub async fn execute_subcommand(command: Command) -> Result { let addr: Address = addr.parse()?; - let account: HumanReadableAccount = wallet_core.get_account(addr).await?.into(); - println!("{}", serde_json::to_string(&account).unwrap()); + 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::CreateNewToken { diff --git a/wallet/src/token_transfers/deshielded.rs b/wallet/src/token_transfers/deshielded.rs index 5c8415e..6bc812b 100644 --- a/wallet/src/token_transfers/deshielded.rs +++ b/wallet/src/token_transfers/deshielded.rs @@ -1,7 +1,11 @@ use common::{ExecutionFailureKind, sequencer_client::json::SendTxResponse}; use key_protocol::key_management::ephemeral_key_holder::EphemeralKeyHolder; -use nssa::Address; -use nssa_core::account::AccountWithMetadata; +use nssa::{ + Address, PrivacyPreservingTransaction, + privacy_preserving_transaction::{circuit, message::Message, witness_set::WitnessSet}, + program::Program, +}; +use nssa_core::{Commitment, account::AccountWithMetadata}; use crate::{WalletCore, helperfunctions::produce_random_nonces}; @@ -18,17 +22,17 @@ impl WalletCore { return Err(ExecutionFailureKind::KeyNotFoundError); }; - let Ok(to_acc) = self.get_account(to).await else { + let Ok(to_acc) = self.get_account_public(to).await else { return Err(ExecutionFailureKind::KeyNotFoundError); }; if from_acc.balance >= balance_to_move { - let program = nssa::program::Program::authenticated_transfer_program(); + let program = Program::authenticated_transfer_program(); let npk_from = from_keys.nullifer_public_key; let ipk_from = from_keys.incoming_viewing_public_key; - let sender_commitment = nssa_core::Commitment::new(&npk_from, &from_acc); + let sender_commitment = Commitment::new(&npk_from, &from_acc); let sender_pre = AccountWithMetadata::new(from_acc.clone(), true, &npk_from); let recipient_pre = AccountWithMetadata::new(to_acc.clone(), false, to); @@ -36,9 +40,9 @@ impl WalletCore { let eph_holder = EphemeralKeyHolder::new(&npk_from); let shared_secret = eph_holder.calculate_shared_secret_sender(&ipk_from); - let (output, proof) = nssa::privacy_preserving_transaction::circuit::execute_and_prove( + let (output, proof) = circuit::execute_and_prove( &[sender_pre, recipient_pre], - &nssa::program::Program::serialize_instruction(balance_to_move).unwrap(), + &Program::serialize_instruction(balance_to_move).unwrap(), &[1, 0], &produce_random_nonces(1), &[(npk_from.clone(), shared_secret.clone())], @@ -54,30 +58,21 @@ impl WalletCore { ) .unwrap(); - let message = - nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output( - vec![to], - vec![], - vec![( - npk_from.clone(), - ipk_from.clone(), - eph_holder.generate_ephemeral_public_key(), - )], - output, - ) - .unwrap(); + let message = Message::try_from_circuit_output( + vec![to], + vec![], + vec![( + npk_from.clone(), + ipk_from.clone(), + eph_holder.generate_ephemeral_public_key(), + )], + output, + ) + .unwrap(); - let witness_set = - nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message( - &message, - proof, - &[], - ); + let witness_set = WitnessSet::for_message(&message, proof, &[]); - let tx = nssa::privacy_preserving_transaction::PrivacyPreservingTransaction::new( - message, - witness_set, - ); + let tx = PrivacyPreservingTransaction::new(message, witness_set); Ok(( self.sequencer_client.send_tx_private(tx).await?, diff --git a/wallet/src/token_transfers/private.rs b/wallet/src/token_transfers/private.rs index 4b1c5fa..5253acd 100644 --- a/wallet/src/token_transfers/private.rs +++ b/wallet/src/token_transfers/private.rs @@ -1,7 +1,14 @@ use common::{ExecutionFailureKind, sequencer_client::json::SendTxResponse}; use key_protocol::key_management::ephemeral_key_holder::EphemeralKeyHolder; -use nssa::Address; -use nssa_core::account::AccountWithMetadata; +use nssa::{ + Address, PrivacyPreservingTransaction, + privacy_preserving_transaction::{circuit, message::Message, witness_set::WitnessSet}, + program::Program, +}; +use nssa_core::{ + Commitment, NullifierPublicKey, SharedSecretKey, account::AccountWithMetadata, + encryption::IncomingViewingPublicKey, +}; use crate::{WalletCore, helperfunctions::produce_random_nonces}; @@ -9,10 +16,10 @@ impl WalletCore { pub async fn send_private_native_token_transfer_outer_account( &self, from: Address, - to_npk: nssa_core::NullifierPublicKey, - to_ipk: nssa_core::encryption::IncomingViewingPublicKey, + to_npk: NullifierPublicKey, + to_ipk: IncomingViewingPublicKey, balance_to_move: u128, - ) -> Result<(SendTxResponse, [nssa_core::SharedSecretKey; 2]), ExecutionFailureKind> { + ) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> { let Some((from_keys, from_acc)) = self.storage.user_data.get_private_account(&from).cloned() else { @@ -22,27 +29,25 @@ impl WalletCore { let to_acc = nssa_core::account::Account::default(); if from_acc.balance >= balance_to_move { - let program = nssa::program::Program::authenticated_transfer_program(); + let program = Program::authenticated_transfer_program(); let from_npk = from_keys.nullifer_public_key; let from_ipk = from_keys.incoming_viewing_public_key; - let sender_commitment = nssa_core::Commitment::new(&from_npk, &from_acc); + let sender_commitment = Commitment::new(&from_npk, &from_acc); - let sender_pre = - nssa_core::account::AccountWithMetadata::new(from_acc.clone(), true, &from_npk); + let sender_pre = AccountWithMetadata::new(from_acc.clone(), true, &from_npk); - let recipient_pre = - nssa_core::account::AccountWithMetadata::new(to_acc.clone(), false, &to_npk); + let recipient_pre = AccountWithMetadata::new(to_acc.clone(), false, &to_npk); let eph_holder = EphemeralKeyHolder::new(&to_npk); let shared_secret_from = eph_holder.calculate_shared_secret_sender(&from_ipk); let shared_secret_to = eph_holder.calculate_shared_secret_sender(&to_ipk); - let (output, proof) = nssa::privacy_preserving_transaction::circuit::execute_and_prove( + let (output, proof) = circuit::execute_and_prove( &[sender_pre, recipient_pre], - &nssa::program::Program::serialize_instruction(balance_to_move).unwrap(), + &Program::serialize_instruction(balance_to_move).unwrap(), &[1, 2], &produce_random_nonces(2), &[ @@ -61,37 +66,28 @@ impl WalletCore { ) .unwrap(); - let message = - nssa::privacy_preserving_transaction::message::Message::try_from_circuit_output( - vec![], - vec![], - vec![ - ( - from_npk.clone(), - from_ipk.clone(), - eph_holder.generate_ephemeral_public_key(), - ), - ( - to_npk.clone(), - to_ipk.clone(), - eph_holder.generate_ephemeral_public_key(), - ), - ], - output, - ) - .unwrap(); + let message = Message::try_from_circuit_output( + vec![], + vec![], + vec![ + ( + from_npk.clone(), + from_ipk.clone(), + eph_holder.generate_ephemeral_public_key(), + ), + ( + to_npk.clone(), + to_ipk.clone(), + eph_holder.generate_ephemeral_public_key(), + ), + ], + output, + ) + .unwrap(); - let witness_set = - nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message( - &message, - proof, - &[], - ); + let witness_set = WitnessSet::for_message(&message, proof, &[]); - let tx = nssa::privacy_preserving_transaction::PrivacyPreservingTransaction::new( - message, - witness_set, - ); + let tx = PrivacyPreservingTransaction::new(message, witness_set); Ok(( self.sequencer_client.send_tx_private(tx).await?, @@ -107,7 +103,7 @@ impl WalletCore { from: Address, to: Address, balance_to_move: u128, - ) -> Result<(SendTxResponse, [nssa_core::SharedSecretKey; 2]), ExecutionFailureKind> { + ) -> Result<(SendTxResponse, [SharedSecretKey; 2]), ExecutionFailureKind> { let Some((from_keys, from_acc)) = self.storage.user_data.get_private_account(&from).cloned() else { @@ -125,10 +121,10 @@ impl WalletCore { let to_ipk = to_keys.incoming_viewing_public_key.clone(); if from_acc.balance >= balance_to_move { - let program = nssa::program::Program::authenticated_transfer_program(); + let program = Program::authenticated_transfer_program(); - let sender_commitment = nssa_core::Commitment::new(&from_npk, &from_acc); - let receiver_commitment = nssa_core::Commitment::new(&to_npk, &to_acc); + 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); @@ -139,9 +135,9 @@ impl WalletCore { let eph_holder_to = EphemeralKeyHolder::new(&to_npk); let shared_secret_to = eph_holder_to.calculate_shared_secret_sender(&to_ipk); - let (output, proof) = nssa::privacy_preserving_transaction::circuit::execute_and_prove( + let (output, proof) = circuit::execute_and_prove( &[sender_pre, recipient_pre], - &nssa::program::Program::serialize_instruction(balance_to_move).unwrap(), + &Program::serialize_instruction(balance_to_move).unwrap(), &[1, 1], &produce_random_nonces(2), &[ @@ -170,37 +166,27 @@ impl WalletCore { ) .unwrap(); - let message = - nssa::privacy_preserving_transaction::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 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 = - nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message( - &message, - proof, - &[], - ); - - let tx = nssa::privacy_preserving_transaction::PrivacyPreservingTransaction::new( - message, - witness_set, - ); + let witness_set = WitnessSet::for_message(&message, proof, &[]); + let tx = PrivacyPreservingTransaction::new(message, witness_set); Ok(( self.sequencer_client.send_tx_private(tx).await?, diff --git a/wallet/src/token_transfers/public.rs b/wallet/src/token_transfers/public.rs index 7a5a78e..22d50eb 100644 --- a/wallet/src/token_transfers/public.rs +++ b/wallet/src/token_transfers/public.rs @@ -1,5 +1,9 @@ use common::{ExecutionFailureKind, sequencer_client::json::SendTxResponse}; -use nssa::Address; +use nssa::{ + Address, PublicTransaction, + program::Program, + public_transaction::{Message, WitnessSet}, +}; use crate::WalletCore; @@ -20,14 +24,8 @@ impl WalletCore { }; let addresses = vec![from, to]; - let program_id = nssa::program::Program::authenticated_transfer_program().id(); - let message = nssa::public_transaction::Message::try_new( - program_id, - addresses, - nonces, - balance_to_move, - ) - .unwrap(); + let program_id = Program::authenticated_transfer_program().id(); + let message = Message::try_new(program_id, addresses, nonces, balance_to_move).unwrap(); let signing_key = self.storage.user_data.get_pub_account_signing_key(&from); @@ -35,10 +33,9 @@ impl WalletCore { return Err(ExecutionFailureKind::KeyNotFoundError); }; - let witness_set = - nssa::public_transaction::WitnessSet::for_message(&message, &[signing_key]); + let witness_set = WitnessSet::for_message(&message, &[signing_key]); - let tx = nssa::PublicTransaction::new(message, witness_set); + let tx = PublicTransaction::new(message, witness_set); Ok(self.sequencer_client.send_tx_public(tx).await?) } else { diff --git a/wallet/src/token_transfers/shielded.rs b/wallet/src/token_transfers/shielded.rs index c0a2d1c..1cf1cb7 100644 --- a/wallet/src/token_transfers/shielded.rs +++ b/wallet/src/token_transfers/shielded.rs @@ -1,7 +1,14 @@ use common::{ExecutionFailureKind, sequencer_client::json::SendTxResponse}; use key_protocol::key_management::ephemeral_key_holder::EphemeralKeyHolder; -use nssa::Address; -use nssa_core::account::AccountWithMetadata; +use nssa::{ + Account, Address, PrivacyPreservingTransaction, + privacy_preserving_transaction::{circuit, message::Message, witness_set::WitnessSet}, + program::Program, +}; +use nssa_core::{ + Commitment, NullifierPublicKey, SharedSecretKey, account::AccountWithMetadata, + encryption::IncomingViewingPublicKey, +}; use crate::{WalletCore, helperfunctions::produce_random_nonces}; @@ -11,8 +18,8 @@ impl WalletCore { from: Address, to: Address, balance_to_move: u128, - ) -> Result<(SendTxResponse, nssa_core::SharedSecretKey), ExecutionFailureKind> { - let Ok(from_acc) = self.get_account(from).await else { + ) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> { + let Ok(from_acc) = self.get_account_public(from).await else { return Err(ExecutionFailureKind::KeyNotFoundError); }; @@ -25,20 +32,17 @@ impl WalletCore { let to_ipk = to_keys.incoming_viewing_public_key.clone(); if from_acc.balance >= balance_to_move { - let program = nssa::program::Program::authenticated_transfer_program(); + let program = Program::authenticated_transfer_program(); - let receiver_commitment = - nssa_core::Commitment::new(&to_keys.nullifer_public_key, &to_acc); + let receiver_commitment = Commitment::new(&to_npk, &to_acc); - let sender_pre = - nssa_core::account::AccountWithMetadata::new(from_acc.clone(), true, from); - let recipient_pre = - nssa_core::account::AccountWithMetadata::new(to_acc.clone(), true, &to_npk); + 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) = nssa::privacy_preserving_transaction::circuit::execute_and_prove( + let (output, proof) = circuit::execute_and_prove( &[sender_pre, recipient_pre], &nssa::program::Program::serialize_instruction(balance_to_move).unwrap(), &[0, 1], @@ -56,18 +60,17 @@ impl WalletCore { ) .unwrap(); - let message = - nssa::privacy_preserving_transaction::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 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); @@ -75,17 +78,9 @@ impl WalletCore { return Err(ExecutionFailureKind::KeyNotFoundError); }; - let witness_set = - nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message( - &message, - proof, - &[signing_key], - ); + let witness_set = WitnessSet::for_message(&message, proof, &[signing_key]); - let tx = nssa::privacy_preserving_transaction::PrivacyPreservingTransaction::new( - message, - witness_set, - ); + let tx = PrivacyPreservingTransaction::new(message, witness_set); Ok(( self.sequencer_client.send_tx_private(tx).await?, @@ -99,18 +94,18 @@ impl WalletCore { pub async fn send_shielded_native_token_transfer_outer_account( &self, from: Address, - to_npk: nssa_core::NullifierPublicKey, - to_ipk: nssa_core::encryption::IncomingViewingPublicKey, + to_npk: NullifierPublicKey, + to_ipk: IncomingViewingPublicKey, balance_to_move: u128, - ) -> Result<(SendTxResponse, nssa_core::SharedSecretKey), ExecutionFailureKind> { - let Ok(from_acc) = self.get_account(from).await else { + ) -> Result<(SendTxResponse, SharedSecretKey), ExecutionFailureKind> { + let Ok(from_acc) = self.get_account_public(from).await else { return Err(ExecutionFailureKind::KeyNotFoundError); }; - let to_acc = nssa_core::account::Account::default(); + let to_acc = Account::default(); if from_acc.balance >= balance_to_move { - let program = nssa::program::Program::authenticated_transfer_program(); + let program = Program::authenticated_transfer_program(); let sender_pre = AccountWithMetadata::new(from_acc.clone(), true, from); let recipient_pre = AccountWithMetadata::new(to_acc.clone(), false, &to_npk); @@ -118,9 +113,9 @@ impl WalletCore { let eph_holder = EphemeralKeyHolder::new(&to_npk); let shared_secret = eph_holder.calculate_shared_secret_sender(&to_ipk); - let (output, proof) = nssa::privacy_preserving_transaction::circuit::execute_and_prove( + let (output, proof) = circuit::execute_and_prove( &[sender_pre, recipient_pre], - &nssa::program::Program::serialize_instruction(balance_to_move).unwrap(), + &Program::serialize_instruction(balance_to_move).unwrap(), &[0, 2], &produce_random_nonces(1), &[(to_npk.clone(), shared_secret.clone())], @@ -129,18 +124,17 @@ impl WalletCore { ) .unwrap(); - let message = - nssa::privacy_preserving_transaction::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 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); @@ -148,17 +142,8 @@ impl WalletCore { return Err(ExecutionFailureKind::KeyNotFoundError); }; - let witness_set = - nssa::privacy_preserving_transaction::witness_set::WitnessSet::for_message( - &message, - proof, - &[signing_key], - ); - - let tx = nssa::privacy_preserving_transaction::PrivacyPreservingTransaction::new( - message, - witness_set, - ); + 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?,