From 3732f16df974d2b985a035d9170b259c58810157 Mon Sep 17 00:00:00 2001 From: Pravdyvy Date: Mon, 18 May 2026 13:44:03 +0300 Subject: [PATCH] feat: account manager extension --- .../src/bin/run_hello_world_private.rs | 4 +- ...n_hello_world_through_tail_call_private.rs | 4 +- .../bin/run_hello_world_with_move_function.rs | 8 +- integration_tests/src/setup.rs | 6 +- integration_tests/tests/private_pda.rs | 10 +- ...cy_preserving_tx.rs => account_manager.rs} | 22 +- wallet/src/lib.rs | 80 ++++++- wallet/src/program_facades/ata.rs | 14 +- .../native_token_transfer/deshielded.rs | 4 +- .../native_token_transfer/private.rs | 4 +- .../native_token_transfer/public.rs | 225 ++++++++++-------- .../native_token_transfer/shielded.rs | 8 +- wallet/src/program_facades/pinata.rs | 4 +- wallet/src/program_facades/token.rs | 30 +-- 14 files changed, 260 insertions(+), 163 deletions(-) rename wallet/src/{privacy_preserving_tx.rs => account_manager.rs} (95%) diff --git a/examples/program_deployment/src/bin/run_hello_world_private.rs b/examples/program_deployment/src/bin/run_hello_world_private.rs index 27ac2079..4fa149ea 100644 --- a/examples/program_deployment/src/bin/run_hello_world_private.rs +++ b/examples/program_deployment/src/bin/run_hello_world_private.rs @@ -1,5 +1,5 @@ use nssa::{AccountId, program::Program}; -use wallet::{PrivacyPreservingAccount, WalletCore}; +use wallet::{AccountManagerAccountIdentity, WalletCore}; // Before running this example, compile the `hello_world.rs` guest program with: // @@ -44,7 +44,7 @@ async fn main() { // Define the desired greeting in ASCII let greeting: Vec = vec![72, 111, 108, 97, 32, 109, 117, 110, 100, 111, 33]; - let accounts = vec![PrivacyPreservingAccount::PrivateOwned(account_id)]; + let accounts = vec![AccountManagerAccountIdentity::PrivateOwned(account_id)]; // Construct and submit the privacy-preserving transaction wallet_core diff --git a/examples/program_deployment/src/bin/run_hello_world_through_tail_call_private.rs b/examples/program_deployment/src/bin/run_hello_world_through_tail_call_private.rs index 4fac3eec..60d5df7c 100644 --- a/examples/program_deployment/src/bin/run_hello_world_through_tail_call_private.rs +++ b/examples/program_deployment/src/bin/run_hello_world_through_tail_call_private.rs @@ -4,7 +4,7 @@ use nssa::{ AccountId, ProgramId, privacy_preserving_transaction::circuit::ProgramWithDependencies, program::Program, }; -use wallet::{PrivacyPreservingAccount, WalletCore}; +use wallet::{AccountManagerAccountIdentity, WalletCore}; // Before running this example, compile the `simple_tail_call.rs` guest program with: // @@ -51,7 +51,7 @@ async fn main() { std::iter::once((hello_world.id(), hello_world)).collect(); let program_with_dependencies = ProgramWithDependencies::new(simple_tail_call, dependencies); - let accounts = vec![PrivacyPreservingAccount::PrivateOwned(account_id)]; + let accounts = vec![AccountManagerAccountIdentity::PrivateOwned(account_id)]; // Construct and submit the privacy-preserving transaction let instruction = (); diff --git a/examples/program_deployment/src/bin/run_hello_world_with_move_function.rs b/examples/program_deployment/src/bin/run_hello_world_with_move_function.rs index a1c2517e..e2056c4c 100644 --- a/examples/program_deployment/src/bin/run_hello_world_with_move_function.rs +++ b/examples/program_deployment/src/bin/run_hello_world_with_move_function.rs @@ -2,7 +2,7 @@ use clap::{Parser, Subcommand}; use common::transaction::NSSATransaction; use nssa::{PublicTransaction, program::Program, public_transaction}; use sequencer_service_rpc::RpcClient as _; -use wallet::{PrivacyPreservingAccount, WalletCore}; +use wallet::{AccountManagerAccountIdentity, WalletCore}; // Before running this example, compile the `hello_world_with_move_function.rs` guest program with: // @@ -99,7 +99,7 @@ async fn main() { } => { let instruction: Instruction = (WRITE_FUNCTION_ID, greeting.into_bytes()); let account_id = account_id.parse().unwrap(); - let accounts = vec![PrivacyPreservingAccount::PrivateOwned(account_id)]; + let accounts = vec![AccountManagerAccountIdentity::PrivateOwned(account_id)]; wallet_core .send_privacy_preserving_tx( @@ -138,8 +138,8 @@ async fn main() { let to = to.parse().unwrap(); let accounts = vec![ - PrivacyPreservingAccount::Public(from), - PrivacyPreservingAccount::PrivateOwned(to), + AccountManagerAccountIdentity::Public(from), + AccountManagerAccountIdentity::PrivateOwned(to), ]; wallet_core diff --git a/integration_tests/src/setup.rs b/integration_tests/src/setup.rs index c43590d0..c1165285 100644 --- a/integration_tests/src/setup.rs +++ b/integration_tests/src/setup.rs @@ -10,7 +10,7 @@ use sequencer_service_rpc::RpcClient as _; use tempfile::TempDir; use testcontainers::compose::DockerCompose; use wallet::{ - AccDecodeData::Decode, PrivacyPreservingAccount, WalletCore, config::WalletConfigOverrides, + AccDecodeData::Decode, AccountManagerAccountIdentity, WalletCore, config::WalletConfigOverrides, }; use crate::{ @@ -293,8 +293,8 @@ async fn claim_funds_from_vault_to_private( let (tx_hash, mut secrets) = wallet .send_privacy_preserving_tx( vec![ - PrivacyPreservingAccount::PrivateOwned(owner_id), - PrivacyPreservingAccount::Public(owner_vault_id), + AccountManagerAccountIdentity::PrivateOwned(owner_id), + AccountManagerAccountIdentity::Public(owner_vault_id), ], instruction_data, &program_with_dependencies, diff --git a/integration_tests/tests/private_pda.rs b/integration_tests/tests/private_pda.rs index f9969d98..4cbc07d1 100644 --- a/integration_tests/tests/private_pda.rs +++ b/integration_tests/tests/private_pda.rs @@ -18,7 +18,7 @@ use nssa::{ use nssa_core::{NullifierPublicKey, encryption::ViewingPublicKey, program::PdaSeed}; use tokio::test; use wallet::{ - PrivacyPreservingAccount, WalletCore, + AccountManagerAccountIdentity, WalletCore, cli::{Command, account::AccountSubcommand}, }; @@ -46,8 +46,8 @@ async fn fund_private_pda( wallet .send_privacy_preserving_tx( vec![ - PrivacyPreservingAccount::Public(sender), - PrivacyPreservingAccount::PrivatePdaForeign { + AccountManagerAccountIdentity::Public(sender), + AccountManagerAccountIdentity::PrivatePdaForeign { account_id: pda_account_id, npk, vpk, @@ -83,8 +83,8 @@ async fn spend_private_pda( wallet .send_privacy_preserving_tx( vec![ - PrivacyPreservingAccount::PrivatePdaOwned(pda_account_id), - PrivacyPreservingAccount::PrivateForeign { + AccountManagerAccountIdentity::PrivatePdaOwned(pda_account_id), + AccountManagerAccountIdentity::PrivateForeign { npk: recipient_npk, vpk: recipient_vpk, identifier: 0, diff --git a/wallet/src/privacy_preserving_tx.rs b/wallet/src/account_manager.rs similarity index 95% rename from wallet/src/privacy_preserving_tx.rs rename to wallet/src/account_manager.rs index 005eaf75..0f43baf2 100644 --- a/wallet/src/privacy_preserving_tx.rs +++ b/wallet/src/account_manager.rs @@ -11,7 +11,7 @@ use nssa_core::{ use crate::{ExecutionFailureKind, WalletCore}; #[derive(Clone)] -pub enum PrivacyPreservingAccount { +pub enum AccountManagerAccountIdentity { Public(AccountId), PrivateOwned(AccountId), PrivateForeign { @@ -50,7 +50,7 @@ pub enum PrivacyPreservingAccount { }, } -impl PrivacyPreservingAccount { +impl AccountManagerAccountIdentity { #[must_use] pub const fn is_public(&self) -> bool { matches!(&self, Self::Public(_)) @@ -92,13 +92,13 @@ pub struct AccountManager { impl AccountManager { pub async fn new( wallet: &WalletCore, - accounts: Vec, + accounts: Vec, ) -> Result { let mut states = Vec::with_capacity(accounts.len()); for account in accounts { let state = match account { - PrivacyPreservingAccount::Public(account_id) => { + AccountManagerAccountIdentity::Public(account_id) => { let acc = wallet .get_account_public(account_id) .await @@ -109,12 +109,12 @@ impl AccountManager { State::Public { account, sk } } - PrivacyPreservingAccount::PrivateOwned(account_id) => { + AccountManagerAccountIdentity::PrivateOwned(account_id) => { let pre = private_key_tree_acc_preparation(wallet, account_id, false).await?; State::Private(pre) } - PrivacyPreservingAccount::PrivateForeign { + AccountManagerAccountIdentity::PrivateForeign { npk, vpk, identifier, @@ -138,11 +138,11 @@ impl AccountManager { State::Private(pre) } - PrivacyPreservingAccount::PrivatePdaOwned(account_id) => { + AccountManagerAccountIdentity::PrivatePdaOwned(account_id) => { let pre = private_key_tree_acc_preparation(wallet, account_id, true).await?; State::Private(pre) } - PrivacyPreservingAccount::PrivatePdaForeign { + AccountManagerAccountIdentity::PrivatePdaForeign { account_id, npk, vpk, @@ -166,7 +166,7 @@ impl AccountManager { }; State::Private(pre) } - PrivacyPreservingAccount::PrivateShared { + AccountManagerAccountIdentity::PrivateShared { nsk, npk, vpk, @@ -180,7 +180,7 @@ impl AccountManager { State::Private(pre) } - PrivacyPreservingAccount::PrivatePdaShared { + AccountManagerAccountIdentity::PrivatePdaShared { account_id, nsk, npk, @@ -410,7 +410,7 @@ mod tests { #[test] fn private_shared_is_private() { - let acc = PrivacyPreservingAccount::PrivateShared { + let acc = AccountManagerAccountIdentity::PrivateShared { nsk: [0; 32], npk: NullifierPublicKey([1; 32]), vpk: ViewingPublicKey::from_scalar([2; 32]), diff --git a/wallet/src/lib.rs b/wallet/src/lib.rs index bfbe7145..e1fec4d1 100644 --- a/wallet/src/lib.rs +++ b/wallet/src/lib.rs @@ -9,6 +9,7 @@ use std::path::PathBuf; +pub use account_manager::AccountManagerAccountIdentity; use anyhow::{Context as _, Result}; use bip39::Mnemonic; use common::{HashType, transaction::NSSATransaction}; @@ -24,7 +25,6 @@ use nssa::{ use nssa_core::{ Commitment, MembershipProof, SharedSecretKey, account::Nonce, program::InstructionData, }; -pub use privacy_preserving_tx::PrivacyPreservingAccount; use sequencer_service_rpc::{RpcClient as _, SequencerClient, SequencerClientBuilder}; use storage::Storage; use tokio::io::AsyncWriteExt as _; @@ -37,11 +37,11 @@ use crate::{ }; pub mod account; +mod account_manager; pub mod cli; pub mod config; pub mod helperfunctions; pub mod poller; -mod privacy_preserving_tx; pub mod program_facades; pub mod storage; @@ -276,7 +276,7 @@ impl WalletCore { pub fn resolve_private_account( &self, account_id: nssa::AccountId, - ) -> Option { + ) -> Option { // Check key tree first if self .storage @@ -284,7 +284,7 @@ impl WalletCore { .private_account(account_id) .is_some() { - return Some(PrivacyPreservingAccount::PrivateOwned(account_id)); + return Some(AccountManagerAccountIdentity::PrivateOwned(account_id)); } // Check shared private accounts @@ -299,7 +299,7 @@ impl WalletCore { if let (Some(pda_seed), Some(program_id)) = (entry.pda_seed, entry.pda_program_id) { let keys = holder.derive_keys_for_pda(&program_id, &pda_seed); - Some(PrivacyPreservingAccount::PrivatePdaShared { + Some(AccountManagerAccountIdentity::PrivatePdaShared { account_id, nsk: keys.nullifier_secret_key, npk: keys.generate_nullifier_public_key(), @@ -316,7 +316,7 @@ impl WalletCore { result }; let keys = holder.derive_keys_for_shared_account(&derivation_seed); - Some(PrivacyPreservingAccount::PrivateShared { + Some(AccountManagerAccountIdentity::PrivateShared { nsk: keys.nullifier_secret_key, npk: keys.generate_nullifier_public_key(), vpk: keys.generate_viewing_public_key(), @@ -541,7 +541,7 @@ impl WalletCore { pub async fn send_privacy_preserving_tx( &self, - accounts: Vec, + accounts: Vec, instruction_data: InstructionData, program: &ProgramWithDependencies, ) -> Result<(HashType, Vec), ExecutionFailureKind> { @@ -553,12 +553,12 @@ impl WalletCore { pub async fn send_privacy_preserving_tx_with_pre_check( &self, - accounts: Vec, + accounts: Vec, instruction_data: InstructionData, program: &ProgramWithDependencies, tx_pre_check: impl FnOnce(&[&Account]) -> Result<(), ExecutionFailureKind>, ) -> Result<(HashType, Vec), ExecutionFailureKind> { - let acc_manager = privacy_preserving_tx::AccountManager::new(self, accounts).await?; + let acc_manager = account_manager::AccountManager::new(self, accounts).await?; let pre_states = acc_manager.pre_states(); tx_pre_check( @@ -610,6 +610,68 @@ impl WalletCore { )) } + pub async fn send_pub_tx( + &self, + accounts: Vec, + instruction_data: InstructionData, + program: &ProgramWithDependencies, + ) -> Result { + self.send_pub_tx_with_pre_check(accounts, instruction_data, program, |_| Ok(())) + .await + } + + pub async fn send_pub_tx_with_pre_check( + &self, + accounts: Vec, + instruction_data: InstructionData, + program: &ProgramWithDependencies, + tx_pre_check: impl FnOnce(&[&Account]) -> Result<(), ExecutionFailureKind>, + ) -> Result { + // Public transaction, all accounts must be public + if accounts + .iter() + .any(AccountManagerAccountIdentity::is_private) + { + return Err(ExecutionFailureKind::TransactionBuildError( + nssa::error::NssaError::InvalidInput( + "Private accounts are not allowed in public transactions".to_owned(), + ), + )); + } + + let acc_manager = account_manager::AccountManager::new(self, accounts).await?; + + let pre_states = acc_manager.pre_states(); + tx_pre_check( + &pre_states + .iter() + .map(|pre| &pre.account) + .collect::>(), + )?; + + let account_ids = acc_manager.public_account_ids(); + let program_id = program.program.id(); + let nonces = acc_manager.public_account_nonces(); + let private_keys = acc_manager.public_account_auth(); + + let message = nssa::public_transaction::Message::new_preserialized( + program_id, + account_ids, + nonces, + instruction_data, + ); + + let witness_set = + nssa::public_transaction::WitnessSet::for_message(&message, &private_keys); + + let tx = nssa::public_transaction::PublicTransaction::new(message, witness_set); + + Ok(self + .sequencer_client + .send_transaction(NSSATransaction::Public(tx)) + .await?) + } + pub async fn sync_to_latest_block(&mut self) -> Result { let latest_block_id = self.sequencer_client.get_last_block_id().await?; println!("Latest block is {latest_block_id}"); diff --git a/wallet/src/program_facades/ata.rs b/wallet/src/program_facades/ata.rs index bdb72620..0a6a4eba 100644 --- a/wallet/src/program_facades/ata.rs +++ b/wallet/src/program_facades/ata.rs @@ -8,7 +8,7 @@ use nssa::{ use nssa_core::SharedSecretKey; use sequencer_service_rpc::RpcClient as _; -use crate::{ExecutionFailureKind, PrivacyPreservingAccount, WalletCore}; +use crate::{AccountManagerAccountIdentity, ExecutionFailureKind, WalletCore}; pub struct Ata<'wallet>(pub &'wallet WalletCore); @@ -176,8 +176,8 @@ impl Ata<'_> { self.0 .resolve_private_account(owner_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::Public(definition_id), - PrivacyPreservingAccount::Public(ata_id), + AccountManagerAccountIdentity::Public(definition_id), + AccountManagerAccountIdentity::Public(ata_id), ]; self.0 @@ -213,8 +213,8 @@ impl Ata<'_> { self.0 .resolve_private_account(owner_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::Public(sender_ata_id), - PrivacyPreservingAccount::Public(recipient_id), + AccountManagerAccountIdentity::Public(sender_ata_id), + AccountManagerAccountIdentity::Public(recipient_id), ]; self.0 @@ -249,8 +249,8 @@ impl Ata<'_> { self.0 .resolve_private_account(owner_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::Public(holder_ata_id), - PrivacyPreservingAccount::Public(definition_id), + AccountManagerAccountIdentity::Public(holder_ata_id), + AccountManagerAccountIdentity::Public(definition_id), ]; self.0 diff --git a/wallet/src/program_facades/native_token_transfer/deshielded.rs b/wallet/src/program_facades/native_token_transfer/deshielded.rs index d4bde39f..3cfaea1b 100644 --- a/wallet/src/program_facades/native_token_transfer/deshielded.rs +++ b/wallet/src/program_facades/native_token_transfer/deshielded.rs @@ -2,7 +2,7 @@ use common::HashType; use nssa::AccountId; use super::{NativeTokenTransfer, auth_transfer_preparation}; -use crate::{ExecutionFailureKind, PrivacyPreservingAccount}; +use crate::{AccountManagerAccountIdentity, ExecutionFailureKind}; impl NativeTokenTransfer<'_> { pub async fn send_deshielded_transfer( @@ -19,7 +19,7 @@ impl NativeTokenTransfer<'_> { self.0 .resolve_private_account(from) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::Public(to), + AccountManagerAccountIdentity::Public(to), ], instruction_data, &program.into(), diff --git a/wallet/src/program_facades/native_token_transfer/private.rs b/wallet/src/program_facades/native_token_transfer/private.rs index e8438d08..508bb62f 100644 --- a/wallet/src/program_facades/native_token_transfer/private.rs +++ b/wallet/src/program_facades/native_token_transfer/private.rs @@ -5,7 +5,7 @@ use nssa::{AccountId, program::Program}; use nssa_core::{Identifier, NullifierPublicKey, SharedSecretKey, encryption::ViewingPublicKey}; use super::{NativeTokenTransfer, auth_transfer_preparation}; -use crate::{ExecutionFailureKind, PrivacyPreservingAccount}; +use crate::{AccountManagerAccountIdentity, ExecutionFailureKind}; impl NativeTokenTransfer<'_> { pub async fn register_account_private( @@ -49,7 +49,7 @@ impl NativeTokenTransfer<'_> { self.0 .resolve_private_account(from) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::PrivateForeign { + AccountManagerAccountIdentity::PrivateForeign { npk: to_npk, vpk: to_vpk, identifier: to_identifier, diff --git a/wallet/src/program_facades/native_token_transfer/public.rs b/wallet/src/program_facades/native_token_transfer/public.rs index ca5c45f9..93d0f42d 100644 --- a/wallet/src/program_facades/native_token_transfer/public.rs +++ b/wallet/src/program_facades/native_token_transfer/public.rs @@ -1,117 +1,152 @@ use authenticated_transfer_core::Instruction as AuthTransferInstruction; -use common::{HashType, transaction::NSSATransaction}; -use nssa::{ - AccountId, PublicTransaction, - program::Program, - public_transaction::{Message, WitnessSet}, -}; -use sequencer_service_rpc::RpcClient as _; +use common::HashType; +use nssa::{AccountId, program::Program}; use super::NativeTokenTransfer; -use crate::ExecutionFailureKind; +use crate::{ + AccountManagerAccountIdentity, ExecutionFailureKind, + program_facades::native_token_transfer::auth_transfer_preparation, +}; impl NativeTokenTransfer<'_> { + // pub async fn send_public_transfer( + // &self, + // from: AccountId, + // to: AccountId, + // balance_to_move: u128, + // ) -> Result { + // let balance = self + // .0 + // .get_account_balance(from) + // .await + // .map_err(ExecutionFailureKind::SequencerError)?; + + // if balance >= balance_to_move { + // let account_ids = vec![from, to]; + // let program_id = Program::authenticated_transfer_program().id(); + + // let mut nonces = self + // .0 + // .get_accounts_nonces(vec![from]) + // .await + // .map_err(ExecutionFailureKind::SequencerError)?; + + // let mut private_keys = Vec::new(); + // let from_signing_key = self.0.storage.key_chain().pub_account_signing_key(from); + // let Some(from_signing_key) = from_signing_key else { + // return Err(ExecutionFailureKind::KeyNotFoundError); + // }; + // private_keys.push(from_signing_key); + + // let to_signing_key = self.0.storage.key_chain().pub_account_signing_key(to); + // if let Some(to_signing_key) = to_signing_key { + // private_keys.push(to_signing_key); + // let to_nonces = self + // .0 + // .get_accounts_nonces(vec![to]) + // .await + // .map_err(ExecutionFailureKind::SequencerError)?; + // nonces.extend(to_nonces); + // } else { + // println!( + // "Receiver's account ({to}) private key not found in wallet. Proceeding with + // only sender's key." ); + // } + + // let message = Message::try_new( + // program_id, + // account_ids, + // nonces, + // AuthTransferInstruction::Transfer { + // amount: balance_to_move, + // }, + // ) + // .unwrap(); + // let witness_set = WitnessSet::for_message(&message, &private_keys); + + // let tx = PublicTransaction::new(message, witness_set); + + // Ok(self + // .0 + // .sequencer_client + // .send_transaction(NSSATransaction::Public(tx)) + // .await?) + // } else { + // Err(ExecutionFailureKind::InsufficientFundsError) + // } + // } + pub async fn send_public_transfer( &self, from: AccountId, to: AccountId, balance_to_move: u128, ) -> Result { - let balance = self - .0 - .get_account_balance(from) - .await - .map_err(ExecutionFailureKind::SequencerError)?; + let (instruction_data, program, tx_pre_check) = auth_transfer_preparation(balance_to_move); - if balance >= balance_to_move { - let account_ids = vec![from, to]; - let program_id = Program::authenticated_transfer_program().id(); - - let mut nonces = self - .0 - .get_accounts_nonces(vec![from]) - .await - .map_err(ExecutionFailureKind::SequencerError)?; - - let mut private_keys = Vec::new(); - let from_signing_key = self.0.storage.key_chain().pub_account_signing_key(from); - let Some(from_signing_key) = from_signing_key else { - return Err(ExecutionFailureKind::KeyNotFoundError); - }; - private_keys.push(from_signing_key); - - let to_signing_key = self.0.storage.key_chain().pub_account_signing_key(to); - if let Some(to_signing_key) = to_signing_key { - private_keys.push(to_signing_key); - let to_nonces = self - .0 - .get_accounts_nonces(vec![to]) - .await - .map_err(ExecutionFailureKind::SequencerError)?; - nonces.extend(to_nonces); - } else { - println!( - "Receiver's account ({to}) private key not found in wallet. Proceeding with only sender's key." - ); - } - - let message = Message::try_new( - program_id, - account_ids, - nonces, - AuthTransferInstruction::Transfer { - amount: balance_to_move, - }, + self.0 + .send_pub_tx_with_pre_check( + vec![ + AccountManagerAccountIdentity::Public(from), + AccountManagerAccountIdentity::Public(to), + ], + instruction_data, + &program.into(), + tx_pre_check, ) - .unwrap(); - let witness_set = WitnessSet::for_message(&message, &private_keys); - - let tx = PublicTransaction::new(message, witness_set); - - Ok(self - .0 - .sequencer_client - .send_transaction(NSSATransaction::Public(tx)) - .await?) - } else { - Err(ExecutionFailureKind::InsufficientFundsError) - } + .await } + // pub async fn register_account( + // &self, + // from: AccountId, + // ) -> Result { + // let nonces = self + // .0 + // .get_accounts_nonces(vec![from]) + // .await + // .map_err(ExecutionFailureKind::SequencerError)?; + + // let account_ids = vec![from]; + // let program_id = Program::authenticated_transfer_program().id(); + // let message = Message::try_new( + // program_id, + // account_ids, + // nonces, + // AuthTransferInstruction::Initialize, + // ) + // .unwrap(); + + // let signing_key = self.0.storage.key_chain().pub_account_signing_key(from); + + // let Some(signing_key) = signing_key else { + // return Err(ExecutionFailureKind::KeyNotFoundError); + // }; + + // let witness_set = WitnessSet::for_message(&message, &[signing_key]); + + // let tx = PublicTransaction::new(message, witness_set); + + // Ok(self + // .0 + // .sequencer_client + // .send_transaction(NSSATransaction::Public(tx)) + // .await?) + // } + pub async fn register_account( &self, from: AccountId, ) -> Result { - let nonces = self - .0 - .get_accounts_nonces(vec![from]) + let instruction_data = Program::serialize_instruction(AuthTransferInstruction::Initialize)?; + let program = Program::authenticated_transfer_program(); + + self.0 + .send_pub_tx( + vec![AccountManagerAccountIdentity::Public(from)], + instruction_data, + &program.into(), + ) .await - .map_err(ExecutionFailureKind::SequencerError)?; - - let account_ids = vec![from]; - let program_id = Program::authenticated_transfer_program().id(); - let message = Message::try_new( - program_id, - account_ids, - nonces, - AuthTransferInstruction::Initialize, - ) - .unwrap(); - - let signing_key = self.0.storage.key_chain().pub_account_signing_key(from); - - let Some(signing_key) = signing_key else { - return Err(ExecutionFailureKind::KeyNotFoundError); - }; - - let witness_set = WitnessSet::for_message(&message, &[signing_key]); - - let tx = PublicTransaction::new(message, witness_set); - - Ok(self - .0 - .sequencer_client - .send_transaction(NSSATransaction::Public(tx)) - .await?) } } diff --git a/wallet/src/program_facades/native_token_transfer/shielded.rs b/wallet/src/program_facades/native_token_transfer/shielded.rs index 98dd0081..385187ce 100644 --- a/wallet/src/program_facades/native_token_transfer/shielded.rs +++ b/wallet/src/program_facades/native_token_transfer/shielded.rs @@ -3,7 +3,7 @@ use nssa::AccountId; use nssa_core::{Identifier, NullifierPublicKey, SharedSecretKey, encryption::ViewingPublicKey}; use super::{NativeTokenTransfer, auth_transfer_preparation}; -use crate::{ExecutionFailureKind, PrivacyPreservingAccount}; +use crate::{AccountManagerAccountIdentity, ExecutionFailureKind}; impl NativeTokenTransfer<'_> { pub async fn send_shielded_transfer( @@ -17,7 +17,7 @@ impl NativeTokenTransfer<'_> { self.0 .send_privacy_preserving_tx_with_pre_check( vec![ - PrivacyPreservingAccount::Public(from), + AccountManagerAccountIdentity::Public(from), self.0 .resolve_private_account(to) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, @@ -49,8 +49,8 @@ impl NativeTokenTransfer<'_> { self.0 .send_privacy_preserving_tx_with_pre_check( vec![ - PrivacyPreservingAccount::Public(from), - PrivacyPreservingAccount::PrivateForeign { + AccountManagerAccountIdentity::Public(from), + AccountManagerAccountIdentity::PrivateForeign { npk: to_npk, vpk: to_vpk, identifier: to_identifier, diff --git a/wallet/src/program_facades/pinata.rs b/wallet/src/program_facades/pinata.rs index 0575455e..28767366 100644 --- a/wallet/src/program_facades/pinata.rs +++ b/wallet/src/program_facades/pinata.rs @@ -3,7 +3,7 @@ use nssa::AccountId; use nssa_core::{MembershipProof, SharedSecretKey}; use sequencer_service_rpc::RpcClient as _; -use crate::{ExecutionFailureKind, PrivacyPreservingAccount, WalletCore}; +use crate::{AccountManagerAccountIdentity, ExecutionFailureKind, WalletCore}; pub struct Pinata<'wallet>(pub &'wallet WalletCore); @@ -55,7 +55,7 @@ impl Pinata<'_> { self.0 .send_privacy_preserving_tx( vec![ - PrivacyPreservingAccount::Public(pinata_account_id), + AccountManagerAccountIdentity::Public(pinata_account_id), self.0 .resolve_private_account(winner_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, diff --git a/wallet/src/program_facades/token.rs b/wallet/src/program_facades/token.rs index 7197b1f0..096ea40c 100644 --- a/wallet/src/program_facades/token.rs +++ b/wallet/src/program_facades/token.rs @@ -4,7 +4,7 @@ use nssa_core::{Identifier, NullifierPublicKey, SharedSecretKey, encryption::Vie use sequencer_service_rpc::RpcClient as _; use token_core::Instruction; -use crate::{ExecutionFailureKind, PrivacyPreservingAccount, WalletCore}; +use crate::{AccountManagerAccountIdentity, ExecutionFailureKind, WalletCore}; pub struct Token<'wallet>(pub &'wallet WalletCore); @@ -73,7 +73,7 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - PrivacyPreservingAccount::Public(definition_account_id), + AccountManagerAccountIdentity::Public(definition_account_id), self.0 .resolve_private_account(supply_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, @@ -108,7 +108,7 @@ impl Token<'_> { self.0 .resolve_private_account(definition_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::Public(supply_account_id), + AccountManagerAccountIdentity::Public(supply_account_id), ], instruction_data, &Program::token().into(), @@ -274,7 +274,7 @@ impl Token<'_> { self.0 .resolve_private_account(sender_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::PrivateForeign { + AccountManagerAccountIdentity::PrivateForeign { npk: recipient_npk, vpk: recipient_vpk, identifier: recipient_identifier, @@ -310,7 +310,7 @@ impl Token<'_> { self.0 .resolve_private_account(sender_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::Public(recipient_account_id), + AccountManagerAccountIdentity::Public(recipient_account_id), ], instruction_data, &Program::token().into(), @@ -340,7 +340,7 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - PrivacyPreservingAccount::Public(sender_account_id), + AccountManagerAccountIdentity::Public(sender_account_id), self.0 .resolve_private_account(recipient_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, @@ -375,8 +375,8 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - PrivacyPreservingAccount::Public(sender_account_id), - PrivacyPreservingAccount::PrivateForeign { + AccountManagerAccountIdentity::Public(sender_account_id), + AccountManagerAccountIdentity::PrivateForeign { npk: recipient_npk, vpk: recipient_vpk, identifier: recipient_identifier, @@ -489,7 +489,7 @@ impl Token<'_> { self.0 .resolve_private_account(definition_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::Public(holder_account_id), + AccountManagerAccountIdentity::Public(holder_account_id), ], instruction_data, &Program::token().into(), @@ -519,7 +519,7 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - PrivacyPreservingAccount::Public(definition_account_id), + AccountManagerAccountIdentity::Public(definition_account_id), self.0 .resolve_private_account(holder_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, @@ -655,7 +655,7 @@ impl Token<'_> { self.0 .resolve_private_account(definition_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::PrivateForeign { + AccountManagerAccountIdentity::PrivateForeign { npk: holder_npk, vpk: holder_vpk, identifier: holder_identifier, @@ -691,7 +691,7 @@ impl Token<'_> { self.0 .resolve_private_account(definition_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - PrivacyPreservingAccount::Public(holder_account_id), + AccountManagerAccountIdentity::Public(holder_account_id), ], instruction_data, &Program::token().into(), @@ -721,7 +721,7 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - PrivacyPreservingAccount::Public(definition_account_id), + AccountManagerAccountIdentity::Public(definition_account_id), self.0 .resolve_private_account(holder_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, @@ -756,8 +756,8 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - PrivacyPreservingAccount::Public(definition_account_id), - PrivacyPreservingAccount::PrivateForeign { + AccountManagerAccountIdentity::Public(definition_account_id), + AccountManagerAccountIdentity::PrivateForeign { npk: holder_npk, vpk: holder_vpk, identifier: holder_identifier,