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 4fa149ea..725019f1 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::{AccountManagerAccountIdentity, WalletCore}; +use wallet::{AccountIdentity, 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![AccountManagerAccountIdentity::PrivateOwned(account_id)]; + let accounts = vec![AccountIdentity::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 60d5df7c..d68e99dc 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::{AccountManagerAccountIdentity, WalletCore}; +use wallet::{AccountIdentity, 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![AccountManagerAccountIdentity::PrivateOwned(account_id)]; + let accounts = vec![AccountIdentity::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 e2056c4c..e6f667a6 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::{AccountManagerAccountIdentity, WalletCore}; +use wallet::{AccountIdentity, 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![AccountManagerAccountIdentity::PrivateOwned(account_id)]; + let accounts = vec![AccountIdentity::PrivateOwned(account_id)]; wallet_core .send_privacy_preserving_tx( @@ -138,8 +138,8 @@ async fn main() { let to = to.parse().unwrap(); let accounts = vec![ - AccountManagerAccountIdentity::Public(from), - AccountManagerAccountIdentity::PrivateOwned(to), + AccountIdentity::Public(from), + AccountIdentity::PrivateOwned(to), ]; wallet_core diff --git a/integration_tests/src/setup.rs b/integration_tests/src/setup.rs index c1165285..8ec9c466 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, AccountManagerAccountIdentity, WalletCore, config::WalletConfigOverrides, + AccDecodeData::Decode, AccountIdentity, 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![ - AccountManagerAccountIdentity::PrivateOwned(owner_id), - AccountManagerAccountIdentity::Public(owner_vault_id), + AccountIdentity::PrivateOwned(owner_id), + AccountIdentity::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 4cbc07d1..0f8d7b8d 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::{ - AccountManagerAccountIdentity, WalletCore, + AccountIdentity, WalletCore, cli::{Command, account::AccountSubcommand}, }; @@ -46,8 +46,8 @@ async fn fund_private_pda( wallet .send_privacy_preserving_tx( vec![ - AccountManagerAccountIdentity::Public(sender), - AccountManagerAccountIdentity::PrivatePdaForeign { + AccountIdentity::Public(sender), + AccountIdentity::PrivatePdaForeign { account_id: pda_account_id, npk, vpk, @@ -83,8 +83,8 @@ async fn spend_private_pda( wallet .send_privacy_preserving_tx( vec![ - AccountManagerAccountIdentity::PrivatePdaOwned(pda_account_id), - AccountManagerAccountIdentity::PrivateForeign { + AccountIdentity::PrivatePdaOwned(pda_account_id), + AccountIdentity::PrivateForeign { npk: recipient_npk, vpk: recipient_vpk, identifier: 0, diff --git a/wallet-ffi/src/keys.rs b/wallet-ffi/src/keys.rs index b676ffab..29fe8184 100644 --- a/wallet-ffi/src/keys.rs +++ b/wallet-ffi/src/keys.rs @@ -3,11 +3,13 @@ use std::ptr; use nssa::{AccountId, PublicKey}; +use wallet::AccountIdentity; use crate::{ error::{print_error, WalletFfiError}, types::{FfiBytes32, FfiPrivateAccountKeys, FfiPublicAccountKey, WalletHandle}, wallet::get_wallet, + FfiAccountIdentity, }; /// Get the public key for a public account. @@ -250,3 +252,85 @@ pub unsafe extern "C" fn wallet_ffi_account_id_from_base58( WalletFfiError::Success } + +/// Resolve public account. +/// +/// # Parameters +/// - `account_id`: 32 bytes of the public account ID +/// - `needs_sign`: does account needs signing +/// - `out_account_identity`: valid pointer, where output will be written +/// +/// # Returns +/// - `Success` on successful retrieval +/// +/// # Safety +/// - `out_account_identity` must be a valid pointer to a `FfiAccountManagerAccountIdentity` struct +#[no_mangle] +pub unsafe extern "C" fn wallet_ffi_resolve_public_account( + account_id: FfiBytes32, + needs_sign: bool, + out_account_identity: *mut FfiAccountIdentity, +) -> WalletFfiError { + let resolved_account = if needs_sign { + AccountIdentity::Public(account_id.into()) + } else { + AccountIdentity::PublicNoSign(account_id.into()) + }; + + unsafe { + *out_account_identity = resolved_account.into(); + } + + WalletFfiError::Success +} + +/// Resolve private account. +/// +/// # Parameters +/// - `handle`: Valid wallet handle +/// - `account_id`: 32 bytes of the public account ID +/// - `out_account_identity`: valid pointer, where output will be written +/// +/// # Returns +/// - `Success` on successful retrieval +/// - `InternalError` if wailed to lock wallet +/// - `AccountNotFound` if failed to found account +/// +/// # Safety +/// - `handle` must be a valid wallet handle from `wallet_ffi_create_new` or `wallet_ffi_open` +/// - `out_account_identity` must be a valid pointer to a `FfiAccountManagerAccountIdentity` struct +#[no_mangle] +pub unsafe extern "C" fn wallet_ffi_resolve_private_account( + handle: *mut WalletHandle, + account_id: FfiBytes32, + out_account_identity: *mut FfiAccountIdentity, +) -> WalletFfiError { + let wrapper = match get_wallet(handle) { + Ok(w) => w, + Err(e) => return e, + }; + + let wallet = match wrapper.core.lock() { + Ok(w) => w, + Err(e) => { + print_error(format!("Failed to lock wallet: {e}")); + return WalletFfiError::InternalError; + } + }; + + let account_id = account_id.into(); + + let resolved_account = match wallet.resolve_private_account(account_id) { + Some(v) => v, + None => { + print_error(format!("Account not found")); + return WalletFfiError::AccountNotFound; + } + }; + + unsafe { + *out_account_identity = resolved_account.into(); + } + + WalletFfiError::Success +} diff --git a/wallet-ffi/src/types.rs b/wallet-ffi/src/types.rs index b970a8d3..06833f74 100644 --- a/wallet-ffi/src/types.rs +++ b/wallet-ffi/src/types.rs @@ -4,7 +4,8 @@ use core::slice; use std::{ffi::c_char, ptr}; use nssa::Data; -use nssa_core::encryption::shared_key_derivation::Secp256k1Point; +use nssa_core::{encryption::shared_key_derivation::Secp256k1Point, NullifierPublicKey}; +use wallet::AccountIdentity; use crate::error::WalletFfiError; @@ -172,6 +173,45 @@ impl FfiPrivateAccountKeys { } } +/// Enumeration to represent kinds of FfiAccountManagerAccountIdentity +#[repr(C)] +pub enum FfiAccountIdentityKind { + Public = 0, + PublicNoSign = 1, + PrivateOwned = 2, + PrivateForeign = 3, + PrivatePdaOwned = 4, + PrivatePdaForeign = 5, + PrivateShared = 6, + PrivatePdaShared = 7, +} + +/// Struct representing of account identity, given to `AccountManager` at intialization +#[repr(C)] +pub struct FfiAccountIdentity { + kind: FfiAccountIdentityKind, + pub account_id: FfiBytes32, + pub nullifier_secret_key: FfiBytes32, + pub nullifier_public_key: FfiBytes32, + pub viewing_public_key: *const u8, + pub viewing_public_key_len: usize, + pub identifier: FfiU128, +} + +impl Default for FfiAccountIdentity { + fn default() -> Self { + Self { + kind: FfiAccountIdentityKind::Public, + account_id: FfiBytes32::default(), + nullifier_secret_key: FfiBytes32::default(), + nullifier_public_key: FfiBytes32::default(), + viewing_public_key: std::ptr::null(), + viewing_public_key_len: 0, + identifier: FfiU128::default(), + } + } +} + impl From for FfiU128 { fn from(value: u128) -> Self { Self { @@ -192,6 +232,12 @@ impl From for FfiBytes32 { } } +impl From<[u8; 32]> for FfiBytes32 { + fn from(value: [u8; 32]) -> Self { + Self { data: value } + } +} + impl From for nssa::AccountId { fn from(bytes: FfiBytes32) -> Self { Self::new(bytes.data) @@ -266,3 +312,230 @@ impl TryFrom<&FfiPublicAccountKey> for nssa::PublicKey { Ok(public_key) } } + +impl From for FfiAccountIdentity { + fn from(value: AccountIdentity) -> Self { + match value { + AccountIdentity::Public(account_id) => Self { + kind: FfiAccountIdentityKind::Public, + account_id: account_id.into(), + ..Default::default() + }, + AccountIdentity::PublicNoSign(account_id) => Self { + kind: FfiAccountIdentityKind::PublicNoSign, + account_id: account_id.into(), + ..Default::default() + }, + AccountIdentity::PrivateOwned(account_id) => Self { + kind: FfiAccountIdentityKind::PrivateOwned, + account_id: account_id.into(), + ..Default::default() + }, + AccountIdentity::PrivateForeign { + npk, + vpk, + identifier, + } => { + let vpk_vec = vpk.0; + let vpk_len = vpk_vec.len(); + let vpk_data = if vpk_len > 0 { + let vpk_data_boxed = vpk_vec.into_boxed_slice(); + Box::into_raw(vpk_data_boxed) as *const u8 + } else { + ptr::null() + }; + + Self { + kind: FfiAccountIdentityKind::PrivateForeign, + nullifier_public_key: npk.0.into(), + viewing_public_key: vpk_data, + viewing_public_key_len: vpk_len, + identifier: identifier.into(), + ..Default::default() + } + } + AccountIdentity::PrivatePdaOwned(account_id) => Self { + kind: FfiAccountIdentityKind::PrivatePdaOwned, + account_id: account_id.into(), + ..Default::default() + }, + AccountIdentity::PrivatePdaForeign { + account_id, + npk, + vpk, + identifier, + } => { + let vpk_vec = vpk.0; + let vpk_len = vpk_vec.len(); + let vpk_data = if vpk_len > 0 { + let vpk_data_boxed = vpk_vec.into_boxed_slice(); + Box::into_raw(vpk_data_boxed) as *const u8 + } else { + ptr::null() + }; + + Self { + kind: FfiAccountIdentityKind::PrivatePdaForeign, + account_id: account_id.into(), + nullifier_public_key: npk.0.into(), + viewing_public_key: vpk_data, + viewing_public_key_len: vpk_len, + identifier: identifier.into(), + ..Default::default() + } + } + AccountIdentity::PrivateShared { + nsk, + npk, + vpk, + identifier, + } => { + let vpk_vec = vpk.0; + let vpk_len = vpk_vec.len(); + let vpk_data = if vpk_len > 0 { + let vpk_data_boxed = vpk_vec.into_boxed_slice(); + Box::into_raw(vpk_data_boxed) as *const u8 + } else { + ptr::null() + }; + + Self { + kind: FfiAccountIdentityKind::PrivateShared, + nullifier_secret_key: nsk.into(), + nullifier_public_key: npk.0.into(), + viewing_public_key: vpk_data, + viewing_public_key_len: vpk_len, + identifier: identifier.into(), + ..Default::default() + } + } + AccountIdentity::PrivatePdaShared { + account_id, + nsk, + npk, + vpk, + identifier, + } => { + let vpk_vec = vpk.0; + let vpk_len = vpk_vec.len(); + let vpk_data = if vpk_len > 0 { + let vpk_data_boxed = vpk_vec.into_boxed_slice(); + Box::into_raw(vpk_data_boxed) as *const u8 + } else { + ptr::null() + }; + + Self { + kind: FfiAccountIdentityKind::PrivateShared, + account_id: account_id.into(), + nullifier_secret_key: nsk.into(), + nullifier_public_key: npk.0.into(), + viewing_public_key: vpk_data, + viewing_public_key_len: vpk_len, + identifier: identifier.into(), + } + } + } + } +} + +impl TryFrom<&FfiAccountIdentity> for AccountIdentity { + type Error = WalletFfiError; + + fn try_from(value: &FfiAccountIdentity) -> Result { + match value.kind { + FfiAccountIdentityKind::Public => Ok( + AccountIdentity::Public(value.account_id.into()), + ), + FfiAccountIdentityKind::PublicNoSign => Ok( + AccountIdentity::PublicNoSign(value.account_id.into()), + ), + FfiAccountIdentityKind::PrivateOwned => Ok( + AccountIdentity::PrivateOwned(value.account_id.into()), + ), + FfiAccountIdentityKind::PrivateForeign => { + let vpk = if value.viewing_public_key_len == 33 { + let slice = unsafe { + slice::from_raw_parts( + value.viewing_public_key, + value.viewing_public_key_len, + ) + }; + Ok(Secp256k1Point(slice.to_vec())) + } else { + Err(WalletFfiError::InvalidKeyValue) + }?; + + Ok(AccountIdentity::PrivateForeign { + npk: NullifierPublicKey(value.nullifier_public_key.data), + vpk, + identifier: value.identifier.into(), + }) + } + FfiAccountIdentityKind::PrivatePdaOwned => Ok( + AccountIdentity::PrivatePdaOwned(value.account_id.into()), + ), + FfiAccountIdentityKind::PrivatePdaForeign => { + let vpk = if value.viewing_public_key_len == 33 { + let slice = unsafe { + slice::from_raw_parts( + value.viewing_public_key, + value.viewing_public_key_len, + ) + }; + Ok(Secp256k1Point(slice.to_vec())) + } else { + Err(WalletFfiError::InvalidKeyValue) + }?; + + Ok(AccountIdentity::PrivatePdaForeign { + account_id: value.account_id.into(), + npk: NullifierPublicKey(value.nullifier_public_key.data), + vpk, + identifier: value.identifier.into(), + }) + } + FfiAccountIdentityKind::PrivateShared => { + let vpk = if value.viewing_public_key_len == 33 { + let slice = unsafe { + slice::from_raw_parts( + value.viewing_public_key, + value.viewing_public_key_len, + ) + }; + Ok(Secp256k1Point(slice.to_vec())) + } else { + Err(WalletFfiError::InvalidKeyValue) + }?; + + Ok(AccountIdentity::PrivateShared { + nsk: value.nullifier_secret_key.data, + npk: NullifierPublicKey(value.nullifier_public_key.data), + vpk, + identifier: value.identifier.into(), + }) + } + FfiAccountIdentityKind::PrivatePdaShared => { + let vpk = if value.viewing_public_key_len == 33 { + let slice = unsafe { + slice::from_raw_parts( + value.viewing_public_key, + value.viewing_public_key_len, + ) + }; + Ok(Secp256k1Point(slice.to_vec())) + } else { + Err(WalletFfiError::InvalidKeyValue) + }?; + + Ok(AccountIdentity::PrivatePdaShared { + account_id: value.account_id.into(), + nsk: value.nullifier_secret_key.data, + npk: NullifierPublicKey(value.nullifier_public_key.data), + vpk, + identifier: value.identifier.into(), + }) + } + } + } +} diff --git a/wallet-ffi/wallet_ffi.h b/wallet-ffi/wallet_ffi.h index adbb7b50..211d6513 100644 --- a/wallet-ffi/wallet_ffi.h +++ b/wallet-ffi/wallet_ffi.h @@ -109,6 +109,20 @@ typedef enum WalletFfiError { INTERNAL_ERROR = 99, } WalletFfiError; +/** + * Enumeration to represent kinds of FfiAccountManagerAccountIdentity + */ +typedef enum FfiAccountIdentityKind { + PUBLIC = 0, + PUBLIC_NO_SIGN = 1, + PRIVATE_OWNED = 2, + PRIVATE_FOREIGN = 3, + PRIVATE_PDA_OWNED = 4, + PRIVATE_PDA_FOREIGN = 5, + PRIVATE_SHARED = 6, + PRIVATE_PDA_SHARED = 7, +} FfiAccountIdentityKind; + /** * Opaque pointer to the Wallet instance. * @@ -207,6 +221,19 @@ typedef struct FfiPublicAccountKey { struct FfiBytes32 public_key; } FfiPublicAccountKey; +/** + * Struct representing of account identity, given to `AccountManager` at intialization + */ +typedef struct FfiAccountIdentity { + enum FfiAccountIdentityKind kind; + struct FfiBytes32 account_id; + struct FfiBytes32 nullifier_secret_key; + struct FfiBytes32 nullifier_public_key; + const uint8_t *viewing_public_key; + uintptr_t viewing_public_key_len; + struct FfiU128 identifier; +} FfiAccountIdentity; + /** * Result of a transfer operation. */ @@ -552,6 +579,45 @@ char *wallet_ffi_account_id_to_base58(const struct FfiBytes32 *account_id); enum WalletFfiError wallet_ffi_account_id_from_base58(const char *base58_str, struct FfiBytes32 *out_account_id); +/** + * Resolve public account. + * + * # Parameters + * - `account_id`: 32 bytes of the public account ID + * - `needs_sign`: does account needs signing + * - `out_account_identity`: valid pointer, where output will be written + * + * # Returns + * - `Success` on successful retrieval + * + * # Safety + * - `out_account_identity` must be a valid pointer to a `FfiAccountManagerAccountIdentity` struct + */ +enum WalletFfiError wallet_ffi_resolve_public_account(struct FfiBytes32 account_id, + bool needs_sign, + struct FfiAccountIdentity *out_account_identity); + +/** + * Resolve private account. + * + * # Parameters + * - `handle`: Valid wallet handle + * - `account_id`: 32 bytes of the public account ID + * - `out_account_identity`: valid pointer, where output will be written + * + * # Returns + * - `Success` on successful retrieval + * - `InternalError` if wailed to lock wallet + * - `AccountNotFound` if failed to found account + * + * # Safety + * - `handle` must be a valid wallet handle from `wallet_ffi_create_new` or `wallet_ffi_open` + * - `out_account_identity` must be a valid pointer to a `FfiAccountManagerAccountIdentity` struct + */ +enum WalletFfiError wallet_ffi_resolve_private_account(struct WalletHandle *handle, + struct FfiBytes32 account_id, + struct FfiAccountIdentity *out_account_identity); + /** * Claim a pinata reward using a public transaction. * diff --git a/wallet/src/account_manager.rs b/wallet/src/account_manager.rs index 5a209d27..a088bcd6 100644 --- a/wallet/src/account_manager.rs +++ b/wallet/src/account_manager.rs @@ -11,7 +11,7 @@ use nssa_core::{ use crate::{ExecutionFailureKind, WalletCore}; #[derive(Clone)] -pub enum AccountManagerAccountIdentity { +pub enum AccountIdentity { Public(AccountId), /// A public account without signing. Would not try to sign, even if account is owned. PublicNoSign(AccountId), @@ -52,7 +52,7 @@ pub enum AccountManagerAccountIdentity { }, } -impl AccountManagerAccountIdentity { +impl AccountIdentity { #[must_use] pub const fn is_public(&self) -> bool { matches!(&self, Self::Public(_) | Self::PublicNoSign(_)) @@ -94,13 +94,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 { - AccountManagerAccountIdentity::Public(account_id) => { + AccountIdentity::Public(account_id) => { let acc = wallet .get_account_public(account_id) .await @@ -111,7 +111,7 @@ impl AccountManager { State::Public { account, sk } } - AccountManagerAccountIdentity::PublicNoSign(account_id) => { + AccountIdentity::PublicNoSign(account_id) => { let acc = wallet .get_account_public(account_id) .await @@ -122,12 +122,12 @@ impl AccountManager { State::Public { account, sk } } - AccountManagerAccountIdentity::PrivateOwned(account_id) => { + AccountIdentity::PrivateOwned(account_id) => { let pre = private_key_tree_acc_preparation(wallet, account_id, false).await?; State::Private(pre) } - AccountManagerAccountIdentity::PrivateForeign { + AccountIdentity::PrivateForeign { npk, vpk, identifier, @@ -151,11 +151,11 @@ impl AccountManager { State::Private(pre) } - AccountManagerAccountIdentity::PrivatePdaOwned(account_id) => { + AccountIdentity::PrivatePdaOwned(account_id) => { let pre = private_key_tree_acc_preparation(wallet, account_id, true).await?; State::Private(pre) } - AccountManagerAccountIdentity::PrivatePdaForeign { + AccountIdentity::PrivatePdaForeign { account_id, npk, vpk, @@ -179,7 +179,7 @@ impl AccountManager { }; State::Private(pre) } - AccountManagerAccountIdentity::PrivateShared { + AccountIdentity::PrivateShared { nsk, npk, vpk, @@ -193,7 +193,7 @@ impl AccountManager { State::Private(pre) } - AccountManagerAccountIdentity::PrivatePdaShared { + AccountIdentity::PrivatePdaShared { account_id, nsk, npk, @@ -423,7 +423,7 @@ mod tests { #[test] fn private_shared_is_private() { - let acc = AccountManagerAccountIdentity::PrivateShared { + let acc = AccountIdentity::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 e1fec4d1..50fb993f 100644 --- a/wallet/src/lib.rs +++ b/wallet/src/lib.rs @@ -9,7 +9,7 @@ use std::path::PathBuf; -pub use account_manager::AccountManagerAccountIdentity; +pub use account_manager::AccountIdentity; use anyhow::{Context as _, Result}; use bip39::Mnemonic; use common::{HashType, transaction::NSSATransaction}; @@ -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(AccountManagerAccountIdentity::PrivateOwned(account_id)); + return Some(AccountIdentity::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(AccountManagerAccountIdentity::PrivatePdaShared { + Some(AccountIdentity::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(AccountManagerAccountIdentity::PrivateShared { + Some(AccountIdentity::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,7 +553,7 @@ 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>, @@ -612,7 +612,7 @@ impl WalletCore { pub async fn send_pub_tx( &self, - accounts: Vec, + accounts: Vec, instruction_data: InstructionData, program: &ProgramWithDependencies, ) -> Result { @@ -622,7 +622,7 @@ impl WalletCore { pub async fn send_pub_tx_with_pre_check( &self, - accounts: Vec, + accounts: Vec, instruction_data: InstructionData, program: &ProgramWithDependencies, tx_pre_check: impl FnOnce(&[&Account]) -> Result<(), ExecutionFailureKind>, @@ -630,7 +630,7 @@ impl WalletCore { // Public transaction, all accounts must be public if accounts .iter() - .any(AccountManagerAccountIdentity::is_private) + .any(AccountIdentity::is_private) { return Err(ExecutionFailureKind::TransactionBuildError( nssa::error::NssaError::InvalidInput( diff --git a/wallet/src/program_facades/amm.rs b/wallet/src/program_facades/amm.rs index 43352386..2dbab6c5 100644 --- a/wallet/src/program_facades/amm.rs +++ b/wallet/src/program_facades/amm.rs @@ -3,7 +3,7 @@ use common::HashType; use nssa::{AccountId, program::Program}; use token_core::TokenHolding; -use crate::{AccountManagerAccountIdentity, ExecutionFailureKind, WalletCore}; +use crate::{AccountIdentity, ExecutionFailureKind, WalletCore}; pub struct Amm<'wallet>(pub &'wallet WalletCore); impl Amm<'_> { @@ -51,13 +51,13 @@ impl Amm<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::PublicNoSign(amm_pool), - AccountManagerAccountIdentity::PublicNoSign(vault_holding_a), - AccountManagerAccountIdentity::PublicNoSign(vault_holding_b), - AccountManagerAccountIdentity::PublicNoSign(pool_lp), - AccountManagerAccountIdentity::Public(user_holding_a), - AccountManagerAccountIdentity::Public(user_holding_b), - AccountManagerAccountIdentity::Public(user_holding_lp), + AccountIdentity::PublicNoSign(amm_pool), + AccountIdentity::PublicNoSign(vault_holding_a), + AccountIdentity::PublicNoSign(vault_holding_b), + AccountIdentity::PublicNoSign(pool_lp), + AccountIdentity::Public(user_holding_a), + AccountIdentity::Public(user_holding_b), + AccountIdentity::Public(user_holding_lp), ], instruction_data, &program.into(), @@ -114,23 +114,23 @@ impl Amm<'_> { } let user_a_signing_indentity = if token_definition_id_in == definition_token_a_id { - AccountManagerAccountIdentity::Public(user_holding_a) + AccountIdentity::Public(user_holding_a) } else { - AccountManagerAccountIdentity::PublicNoSign(user_holding_a) + AccountIdentity::PublicNoSign(user_holding_a) }; let user_b_signing_indentity = if token_definition_id_in == definition_token_b_id { - AccountManagerAccountIdentity::Public(user_holding_b) + AccountIdentity::Public(user_holding_b) } else { - AccountManagerAccountIdentity::PublicNoSign(user_holding_b) + AccountIdentity::PublicNoSign(user_holding_b) }; self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::PublicNoSign(amm_pool), - AccountManagerAccountIdentity::PublicNoSign(vault_holding_a), - AccountManagerAccountIdentity::PublicNoSign(vault_holding_b), + AccountIdentity::PublicNoSign(amm_pool), + AccountIdentity::PublicNoSign(vault_holding_a), + AccountIdentity::PublicNoSign(vault_holding_b), user_a_signing_indentity, user_b_signing_indentity, ], @@ -189,23 +189,23 @@ impl Amm<'_> { } let user_a_signing_indentity = if token_definition_id_in == definition_token_a_id { - AccountManagerAccountIdentity::Public(user_holding_a) + AccountIdentity::Public(user_holding_a) } else { - AccountManagerAccountIdentity::PublicNoSign(user_holding_a) + AccountIdentity::PublicNoSign(user_holding_a) }; let user_b_signing_indentity = if token_definition_id_in == definition_token_b_id { - AccountManagerAccountIdentity::Public(user_holding_b) + AccountIdentity::Public(user_holding_b) } else { - AccountManagerAccountIdentity::PublicNoSign(user_holding_b) + AccountIdentity::PublicNoSign(user_holding_b) }; self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::Public(amm_pool), - AccountManagerAccountIdentity::Public(vault_holding_a), - AccountManagerAccountIdentity::Public(vault_holding_b), + AccountIdentity::Public(amm_pool), + AccountIdentity::Public(vault_holding_a), + AccountIdentity::Public(vault_holding_b), user_a_signing_indentity, user_b_signing_indentity, ], @@ -260,13 +260,13 @@ impl Amm<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::PublicNoSign(amm_pool), - AccountManagerAccountIdentity::PublicNoSign(vault_holding_a), - AccountManagerAccountIdentity::PublicNoSign(vault_holding_b), - AccountManagerAccountIdentity::PublicNoSign(pool_lp), - AccountManagerAccountIdentity::Public(user_holding_a), - AccountManagerAccountIdentity::Public(user_holding_b), - AccountManagerAccountIdentity::PublicNoSign(user_holding_lp), + AccountIdentity::PublicNoSign(amm_pool), + AccountIdentity::PublicNoSign(vault_holding_a), + AccountIdentity::PublicNoSign(vault_holding_b), + AccountIdentity::PublicNoSign(pool_lp), + AccountIdentity::Public(user_holding_a), + AccountIdentity::Public(user_holding_b), + AccountIdentity::PublicNoSign(user_holding_lp), ], instruction_data, &program.into(), @@ -319,13 +319,13 @@ impl Amm<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::PublicNoSign(amm_pool), - AccountManagerAccountIdentity::PublicNoSign(vault_holding_a), - AccountManagerAccountIdentity::PublicNoSign(vault_holding_b), - AccountManagerAccountIdentity::PublicNoSign(pool_lp), - AccountManagerAccountIdentity::PublicNoSign(user_holding_a), - AccountManagerAccountIdentity::PublicNoSign(user_holding_b), - AccountManagerAccountIdentity::Public(user_holding_lp), + AccountIdentity::PublicNoSign(amm_pool), + AccountIdentity::PublicNoSign(vault_holding_a), + AccountIdentity::PublicNoSign(vault_holding_b), + AccountIdentity::PublicNoSign(pool_lp), + AccountIdentity::PublicNoSign(user_holding_a), + AccountIdentity::PublicNoSign(user_holding_b), + AccountIdentity::Public(user_holding_lp), ], instruction_data, &program.into(), diff --git a/wallet/src/program_facades/ata.rs b/wallet/src/program_facades/ata.rs index e7131b39..68d45bbe 100644 --- a/wallet/src/program_facades/ata.rs +++ b/wallet/src/program_facades/ata.rs @@ -7,7 +7,7 @@ use nssa::{ }; use nssa_core::SharedSecretKey; -use crate::{AccountManagerAccountIdentity, ExecutionFailureKind, WalletCore}; +use crate::{AccountIdentity, ExecutionFailureKind, WalletCore}; pub struct Ata<'wallet>(pub &'wallet WalletCore); @@ -30,9 +30,9 @@ impl Ata<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::Public(owner_id), - AccountManagerAccountIdentity::PublicNoSign(definition_id), - AccountManagerAccountIdentity::PublicNoSign(ata_id), + AccountIdentity::Public(owner_id), + AccountIdentity::PublicNoSign(definition_id), + AccountIdentity::PublicNoSign(ata_id), ], instruction_data, &program.into(), @@ -63,9 +63,9 @@ impl Ata<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::Public(owner_id), - AccountManagerAccountIdentity::PublicNoSign(sender_ata_id), - AccountManagerAccountIdentity::PublicNoSign(recipient_id), + AccountIdentity::Public(owner_id), + AccountIdentity::PublicNoSign(sender_ata_id), + AccountIdentity::PublicNoSign(recipient_id), ], instruction_data, &program.into(), @@ -95,9 +95,9 @@ impl Ata<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::Public(owner_id), - AccountManagerAccountIdentity::PublicNoSign(holder_ata_id), - AccountManagerAccountIdentity::PublicNoSign(definition_id), + AccountIdentity::Public(owner_id), + AccountIdentity::PublicNoSign(holder_ata_id), + AccountIdentity::PublicNoSign(definition_id), ], instruction_data, &program.into(), @@ -124,8 +124,8 @@ impl Ata<'_> { self.0 .resolve_private_account(owner_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - AccountManagerAccountIdentity::Public(definition_id), - AccountManagerAccountIdentity::Public(ata_id), + AccountIdentity::Public(definition_id), + AccountIdentity::Public(ata_id), ]; self.0 @@ -161,8 +161,8 @@ impl Ata<'_> { self.0 .resolve_private_account(owner_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - AccountManagerAccountIdentity::Public(sender_ata_id), - AccountManagerAccountIdentity::Public(recipient_id), + AccountIdentity::Public(sender_ata_id), + AccountIdentity::Public(recipient_id), ]; self.0 @@ -197,8 +197,8 @@ impl Ata<'_> { self.0 .resolve_private_account(owner_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - AccountManagerAccountIdentity::Public(holder_ata_id), - AccountManagerAccountIdentity::Public(definition_id), + AccountIdentity::Public(holder_ata_id), + AccountIdentity::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 3cfaea1b..31374f99 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::{AccountManagerAccountIdentity, ExecutionFailureKind}; +use crate::{AccountIdentity, 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)?, - AccountManagerAccountIdentity::Public(to), + AccountIdentity::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 508bb62f..481e4a5f 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::{AccountManagerAccountIdentity, ExecutionFailureKind}; +use crate::{AccountIdentity, 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)?, - AccountManagerAccountIdentity::PrivateForeign { + AccountIdentity::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 6054383c..03fccc9d 100644 --- a/wallet/src/program_facades/native_token_transfer/public.rs +++ b/wallet/src/program_facades/native_token_transfer/public.rs @@ -4,7 +4,7 @@ use nssa::{AccountId, program::Program}; use super::NativeTokenTransfer; use crate::{ - AccountManagerAccountIdentity, ExecutionFailureKind, + AccountIdentity, ExecutionFailureKind, program_facades::native_token_transfer::auth_transfer_preparation, }; @@ -20,8 +20,8 @@ impl NativeTokenTransfer<'_> { self.0 .send_pub_tx_with_pre_check( vec![ - AccountManagerAccountIdentity::Public(from), - AccountManagerAccountIdentity::Public(to), + AccountIdentity::Public(from), + AccountIdentity::Public(to), ], instruction_data, &program.into(), @@ -39,7 +39,7 @@ impl NativeTokenTransfer<'_> { self.0 .send_pub_tx( - vec![AccountManagerAccountIdentity::Public(from)], + vec![AccountIdentity::Public(from)], instruction_data, &program.into(), ) diff --git a/wallet/src/program_facades/native_token_transfer/shielded.rs b/wallet/src/program_facades/native_token_transfer/shielded.rs index 385187ce..44916529 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::{AccountManagerAccountIdentity, ExecutionFailureKind}; +use crate::{AccountIdentity, 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![ - AccountManagerAccountIdentity::Public(from), + AccountIdentity::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![ - AccountManagerAccountIdentity::Public(from), - AccountManagerAccountIdentity::PrivateForeign { + AccountIdentity::Public(from), + AccountIdentity::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 0c3a599b..2e40e78b 100644 --- a/wallet/src/program_facades/pinata.rs +++ b/wallet/src/program_facades/pinata.rs @@ -2,7 +2,7 @@ use common::HashType; use nssa::{AccountId, program::Program}; use nssa_core::{MembershipProof, SharedSecretKey}; -use crate::{AccountManagerAccountIdentity, ExecutionFailureKind, WalletCore}; +use crate::{AccountIdentity, ExecutionFailureKind, WalletCore}; pub struct Pinata<'wallet>(pub &'wallet WalletCore); @@ -21,8 +21,8 @@ impl Pinata<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::PublicNoSign(pinata_account_id), - AccountManagerAccountIdentity::PublicNoSign(winner_account_id), + AccountIdentity::PublicNoSign(pinata_account_id), + AccountIdentity::PublicNoSign(winner_account_id), ], instruction_data, &program.into(), @@ -55,7 +55,7 @@ impl Pinata<'_> { self.0 .send_privacy_preserving_tx( vec![ - AccountManagerAccountIdentity::Public(pinata_account_id), + AccountIdentity::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 2de2b796..8e9b4f8f 100644 --- a/wallet/src/program_facades/token.rs +++ b/wallet/src/program_facades/token.rs @@ -3,7 +3,7 @@ use nssa::{AccountId, program::Program}; use nssa_core::{Identifier, NullifierPublicKey, SharedSecretKey, encryption::ViewingPublicKey}; use token_core::Instruction; -use crate::{AccountManagerAccountIdentity, ExecutionFailureKind, WalletCore}; +use crate::{AccountIdentity, ExecutionFailureKind, WalletCore}; pub struct Token<'wallet>(pub &'wallet WalletCore); @@ -23,8 +23,8 @@ impl Token<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::Public(definition_account_id), - AccountManagerAccountIdentity::Public(supply_account_id), + AccountIdentity::Public(definition_account_id), + AccountIdentity::Public(supply_account_id), ], instruction_data, &program.into(), @@ -46,7 +46,7 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - AccountManagerAccountIdentity::Public(definition_account_id), + AccountIdentity::Public(definition_account_id), self.0 .resolve_private_account(supply_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, @@ -81,7 +81,7 @@ impl Token<'_> { self.0 .resolve_private_account(definition_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - AccountManagerAccountIdentity::Public(supply_account_id), + AccountIdentity::Public(supply_account_id), ], instruction_data, &Program::token().into(), @@ -145,8 +145,8 @@ impl Token<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::Public(sender_account_id), - AccountManagerAccountIdentity::Public(recipient_account_id), + AccountIdentity::Public(sender_account_id), + AccountIdentity::Public(recipient_account_id), ], instruction_data, &program.into(), @@ -208,7 +208,7 @@ impl Token<'_> { self.0 .resolve_private_account(sender_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - AccountManagerAccountIdentity::PrivateForeign { + AccountIdentity::PrivateForeign { npk: recipient_npk, vpk: recipient_vpk, identifier: recipient_identifier, @@ -244,7 +244,7 @@ impl Token<'_> { self.0 .resolve_private_account(sender_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - AccountManagerAccountIdentity::Public(recipient_account_id), + AccountIdentity::Public(recipient_account_id), ], instruction_data, &Program::token().into(), @@ -274,7 +274,7 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - AccountManagerAccountIdentity::Public(sender_account_id), + AccountIdentity::Public(sender_account_id), self.0 .resolve_private_account(recipient_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, @@ -309,8 +309,8 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - AccountManagerAccountIdentity::Public(sender_account_id), - AccountManagerAccountIdentity::PrivateForeign { + AccountIdentity::Public(sender_account_id), + AccountIdentity::PrivateForeign { npk: recipient_npk, vpk: recipient_vpk, identifier: recipient_identifier, @@ -345,8 +345,8 @@ impl Token<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::PublicNoSign(definition_account_id), - AccountManagerAccountIdentity::Public(holder_account_id), + AccountIdentity::PublicNoSign(definition_account_id), + AccountIdentity::Public(holder_account_id), ], instruction_data, &program.into(), @@ -406,7 +406,7 @@ impl Token<'_> { self.0 .resolve_private_account(definition_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - AccountManagerAccountIdentity::Public(holder_account_id), + AccountIdentity::Public(holder_account_id), ], instruction_data, &Program::token().into(), @@ -436,7 +436,7 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - AccountManagerAccountIdentity::Public(definition_account_id), + AccountIdentity::Public(definition_account_id), self.0 .resolve_private_account(holder_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, @@ -470,8 +470,8 @@ impl Token<'_> { self.0 .send_pub_tx( vec![ - AccountManagerAccountIdentity::Public(definition_account_id), - AccountManagerAccountIdentity::Public(holder_account_id), + AccountIdentity::Public(definition_account_id), + AccountIdentity::Public(holder_account_id), ], instruction_data, &program.into(), @@ -533,7 +533,7 @@ impl Token<'_> { self.0 .resolve_private_account(definition_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - AccountManagerAccountIdentity::PrivateForeign { + AccountIdentity::PrivateForeign { npk: holder_npk, vpk: holder_vpk, identifier: holder_identifier, @@ -569,7 +569,7 @@ impl Token<'_> { self.0 .resolve_private_account(definition_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, - AccountManagerAccountIdentity::Public(holder_account_id), + AccountIdentity::Public(holder_account_id), ], instruction_data, &Program::token().into(), @@ -599,7 +599,7 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - AccountManagerAccountIdentity::Public(definition_account_id), + AccountIdentity::Public(definition_account_id), self.0 .resolve_private_account(holder_account_id) .ok_or(ExecutionFailureKind::KeyNotFoundError)?, @@ -634,8 +634,8 @@ impl Token<'_> { self.0 .send_privacy_preserving_tx( vec![ - AccountManagerAccountIdentity::Public(definition_account_id), - AccountManagerAccountIdentity::PrivateForeign { + AccountIdentity::Public(definition_account_id), + AccountIdentity::PrivateForeign { npk: holder_npk, vpk: holder_vpk, identifier: holder_identifier,