logos-blockchain/logos-execution-zone
1
0
Fork 0
mirror of https://github.com/logos-blockchain/logos-execution-zone.git synced 2026-05-25 09:29:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: account manager extension

Browse Source
This commit is contained in:
Pravdyvy 2026-05-18 13:44:03 +03:00
parent 4079b0c9c8
commit 3732f16df9
14 changed files with 260 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/program_deployment/src/bin/run_hello_world_private.rs
View File

@ -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<u8> = 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

4
examples/program_deployment/src/bin/run_hello_world_through_tail_call_private.rs
View File

@ -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 = ();

8
examples/program_deployment/src/bin/run_hello_world_with_move_function.rs
View File

@ -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

6
integration_tests/src/setup.rs
View File

@ -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,

10
integration_tests/tests/private_pda.rs
View File

@ -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,

22
wallet/src/privacy_preserving_tx.rs → wallet/src/account_manager.rs
View File

@ -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<PrivacyPreservingAccount>,
accounts: Vec<AccountManagerAccountIdentity>,
) -> Result<Self, ExecutionFailureKind> {
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]),

80
wallet/src/lib.rs
View File

@ -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<PrivacyPreservingAccount> {
) -> Option<AccountManagerAccountIdentity> {
// 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<PrivacyPreservingAccount>,
accounts: Vec<AccountManagerAccountIdentity>,
instruction_data: InstructionData,
program: &ProgramWithDependencies,
) -> Result<(HashType, Vec<SharedSecretKey>), ExecutionFailureKind> {
@ -553,12 +553,12 @@ impl WalletCore {
pub async fn send_privacy_preserving_tx_with_pre_check(
&self,
accounts: Vec<PrivacyPreservingAccount>,
accounts: Vec<AccountManagerAccountIdentity>,
instruction_data: InstructionData,
program: &ProgramWithDependencies,
tx_pre_check: impl FnOnce(&[&Account]) -> Result<(), ExecutionFailureKind>,
) -> Result<(HashType, Vec<SharedSecretKey>), 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<AccountManagerAccountIdentity>,
instruction_data: InstructionData,
program: &ProgramWithDependencies,
) -> Result<HashType, ExecutionFailureKind> {
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<AccountManagerAccountIdentity>,
instruction_data: InstructionData,
program: &ProgramWithDependencies,
tx_pre_check: impl FnOnce(&[&Account]) -> Result<(), ExecutionFailureKind>,
) -> Result<HashType, ExecutionFailureKind> {
// 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::<Vec<_>>(),
)?;
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<u64> {
let latest_block_id = self.sequencer_client.get_last_block_id().await?;
println!("Latest block is {latest_block_id}");

14
wallet/src/program_facades/ata.rs
View File

@ -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

4
wallet/src/program_facades/native_token_transfer/deshielded.rs
View File

@ -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(),

4
wallet/src/program_facades/native_token_transfer/private.rs
View File

@ -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,

225
wallet/src/program_facades/native_token_transfer/public.rs
View File

@ -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<HashType, ExecutionFailureKind> {
// 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<HashType, ExecutionFailureKind> {
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<HashType, ExecutionFailureKind> {
// 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<HashType, ExecutionFailureKind> {
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?)
}
}

8
wallet/src/program_facades/native_token_transfer/shielded.rs
View File

@ -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,

4
wallet/src/program_facades/pinata.rs
View File

@ -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)?,

30
wallet/src/program_facades/token.rs
View File

@ -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,