From c0c1228e10e0eeb1f66dc88a7e6fa6fe810c1cf1 Mon Sep 17 00:00:00 2001 From: jonesmarvin8 <83104039+jonesmarvin8@users.noreply.github.com> Date: Tue, 2 Dec 2025 15:20:16 -0500 Subject: [PATCH] fixed accountId --- nssa/core/Cargo.toml | 2 +- nssa/core/src/account.rs | 11 +- nssa/program_methods/guest/src/bin/amm.rs | 21 +- nssa/src/program.rs | 2 +- nssa/src/state.rs | 595 +++++++++++----------- 5 files changed, 320 insertions(+), 311 deletions(-) diff --git a/nssa/core/Cargo.toml b/nssa/core/Cargo.toml index 67f40b2..0e16a3f 100644 --- a/nssa/core/Cargo.toml +++ b/nssa/core/Cargo.toml @@ -12,7 +12,7 @@ chacha20 = { version = "0.9", default-features = false } k256 = { version = "0.13.3", optional = true } base58 = { version = "0.2.0", optional = true } anyhow = { version = "1.0.98", optional = true } -borsh.workspace = true +borsh = "1.5.7" [features] default = [] diff --git a/nssa/core/src/account.rs b/nssa/core/src/account.rs index 35b22b2..944769e 100644 --- a/nssa/core/src/account.rs +++ b/nssa/core/src/account.rs @@ -41,10 +41,10 @@ impl AccountWithMetadata { } } -#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash, BorshSerialize, BorshDeserialize)] +#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash, BorshSerialize, BorshDeserialize, Default)] #[cfg_attr( any(feature = "host", test), - derive(Debug, Copy, PartialOrd, Ord, Default) + derive(Debug, Copy, PartialOrd, Ord) )] pub struct AccountId { value: [u8; 32], @@ -175,4 +175,11 @@ mod tests { let result = base58_str.parse::().unwrap_err(); assert!(matches!(result, AccountIdError::InvalidLength(_))); } + + #[test] + fn default_account_id() { + let default_account_id = AccountId::default(); + let expected_account_id = AccountId::new([0;32]); + assert!(default_account_id == expected_account_id); + } } diff --git a/nssa/program_methods/guest/src/bin/amm.rs b/nssa/program_methods/guest/src/bin/amm.rs index 534ef2b..f4ed7a3 100644 --- a/nssa/program_methods/guest/src/bin/amm.rs +++ b/nssa/program_methods/guest/src/bin/amm.rs @@ -1,5 +1,4 @@ use nssa_core::{ - address::Address, account::{Account, AccountId, AccountWithMetadata, Data}, program::{ProgramId, ProgramInput, ChainedCall, read_nssa_inputs, write_nssa_outputs_with_chained_call}, }; @@ -37,8 +36,8 @@ use bytemuck; const POOL_DEFINITION_DATA_SIZE: usize = 240; struct PoolDefinition{ - definition_token_a_id: Address, - definition_token_b_id: Address, + definition_token_a_id: AccountId, + definition_token_b_id: AccountId, vault_a_addr: AccountId, vault_b_addr: AccountId, liquidity_pool_id: AccountId, @@ -166,7 +165,7 @@ fn main() { let mut token_addr: [u8;32] = [0;32]; token_addr[0..].copy_from_slice(&instruction[17..49]); - let token_addr = Address::new(token_addr); + let token_addr = AccountId::new(token_addr); let amount = u128::from_le_bytes(instruction[1..17].try_into().unwrap()); @@ -181,7 +180,7 @@ fn main() { let mut token_addr: [u8;32] = [0;32]; token_addr[0..].copy_from_slice(&instruction[33..65]); - let token_addr = Address::new(token_addr); + let token_addr = AccountId::new(token_addr); let (post_states, chained_call) = add_liquidity(&pre_states, &[balance_a, balance_b], token_addr.clone()); @@ -320,12 +319,14 @@ fn new_definition( fn swap( pre_states: &[AccountWithMetadata], amount: u128, - token_id: Address, + token_id: AccountId, ) -> (Vec, Vec) { if pre_states.len() != 5 { panic!("Invalid number of input accounts"); } + //TODO: get rid of + let pool = &pre_states[0]; let vault1 = &pre_states[1]; @@ -357,7 +358,7 @@ fn swap( true } else if token_id == pool_def_data.definition_token_b_id { false } else { - panic!("Address is not a token type for the pool"); + panic!("AccountId is not a token type for the pool"); }; let deposit_a = if a_to_b { amount } else { 0 }; @@ -469,7 +470,7 @@ fn swap( fn add_liquidity(pre_states: &[AccountWithMetadata], max_balance_in: &[u128], - main_token: Address) -> (Vec, Vec) { + main_token: AccountId) -> (Vec, Vec) { if pre_states.len() != 7 { panic!("Invalid number of input accounts"); @@ -943,7 +944,7 @@ mod tests { let pre_states = vec![AccountWithMetadata { account: pool, is_authorized: true, - account_id: AccountId::default()}, + account_id: AccountId::new([0;32])}, AccountWithMetadata { account: Account::default(), is_authorized: true, @@ -3574,7 +3575,7 @@ mod tests { let _post_states = swap(&pre_states, amount, vault_addr); } - #[should_panic(expected = "Address is not a token type for the pool")] + #[should_panic(expected = "AccountId is not a token type for the pool")] #[test] fn test_call_swap_incorrect_token_type() { let mut pool = Account::default(); diff --git a/nssa/src/program.rs b/nssa/src/program.rs index c524a17..1839690 100644 --- a/nssa/src/program.rs +++ b/nssa/src/program.rs @@ -99,7 +99,7 @@ impl Program { pub fn amm() -> Self { // This unwrap wont panic since the `AMM_ELF` comes from risc0 build of // `program_methods` - Self::new(AMM_ELF.to_vec()).unwrap() + Self::new(AMM_ELF.to_vec()).expect("The AMM program must be a valid Risc0 program") } } diff --git a/nssa/src/state.rs b/nssa/src/state.rs index bc6f3c1..9c373ed 100644 --- a/nssa/src/state.rs +++ b/nssa/src/state.rs @@ -249,7 +249,7 @@ pub mod tests { use nssa_core::{ Commitment, Nullifier, NullifierPublicKey, NullifierSecretKey, SharedSecretKey, - account::{Account, AccountId, AccountWithMetadata, Nonce}, + account::{Account, AccountId, AccountWithMetadata, Data, Nonce}, encryption::{EphemeralPublicKey, IncomingViewingPublicKey, Scalar}, program::ProgramId, }; @@ -2288,58 +2288,58 @@ pub mod tests { /// Used for each amm test to initialize /// an AMM pool - fn initialize_amm() -> (V02State, Vec, Vec
, Vec) { + fn initialize_amm() -> (V02State, Vec, Vec, Vec) { let initial_data = []; let mut state = V02State::new_with_genesis_accounts(&initial_data, &[]).with_test_programs(); let token_a_holding_key = PrivateKey::try_new([1; 32]).unwrap(); let token_a_definition_key = PrivateKey::try_new([2; 32]).unwrap(); - let token_a_holding_address = - Address::from(&PublicKey::new_from_private_key(&token_a_holding_key)); - let token_a_definition_address = - Address::from(&PublicKey::new_from_private_key(&token_a_definition_key)); + let token_a_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&token_a_holding_key)); + let token_a_definition_id = + AccountId::from(&PublicKey::new_from_private_key(&token_a_definition_key)); let token_a_supply: u128 = 30000; let token_b_holding_key = PrivateKey::try_new([3; 32]).unwrap(); let token_b_definition_key = PrivateKey::try_new([4; 32]).unwrap(); - let token_b_holding_address = - Address::from(&PublicKey::new_from_private_key(&token_b_holding_key)); - let token_b_definition_address = - Address::from(&PublicKey::new_from_private_key(&token_b_definition_key)); + let token_b_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&token_b_holding_key)); + let token_b_definition_id = + AccountId::from(&PublicKey::new_from_private_key(&token_b_definition_key)); let token_b_supply: u128 = 50000; let pool_lp_holding_key = PrivateKey::try_new([5; 32]).unwrap(); let pool_lp_definition_key = PrivateKey::try_new([6; 32]).unwrap(); - let pool_lp_holding_address = - Address::from(&PublicKey::new_from_private_key(&pool_lp_holding_key)); - let pool_lp_definition_address = - Address::from(&PublicKey::new_from_private_key(&pool_lp_definition_key)); + let pool_lp_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&pool_lp_holding_key)); + let pool_lp_definition_id = + AccountId::from(&PublicKey::new_from_private_key(&pool_lp_definition_key)); let token_lp_supply: u128 = 300000; let user_a_holding_key = PrivateKey::try_new([7; 32]).unwrap(); - let user_a_holding_address = - Address::from(&PublicKey::new_from_private_key(&user_a_holding_key)); + let user_a_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&user_a_holding_key)); let user_a_amount: u128 = 10000; let user_b_holding_key = PrivateKey::try_new([8; 32]).unwrap(); - let user_b_holding_address = - Address::from(&PublicKey::new_from_private_key(&user_b_holding_key)); + let user_b_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&user_b_holding_key)); let user_b_amount: u128 = 10000; let vault_a_key = PrivateKey::try_new([9; 32]).unwrap(); - let vault_a_address = Address::from(&PublicKey::new_from_private_key(&vault_a_key)); + let vault_a_id = AccountId::from(&PublicKey::new_from_private_key(&vault_a_key)); let vault_b_key = PrivateKey::try_new([10; 32]).unwrap(); - let vault_b_address = Address::from(&PublicKey::new_from_private_key(&vault_b_key)); + let vault_b_id = AccountId::from(&PublicKey::new_from_private_key(&vault_b_key)); let user_lp_holding_key = PrivateKey::try_new([11; 32]).unwrap(); - let user_lp_holding_address = - Address::from(&PublicKey::new_from_private_key(&user_lp_holding_key)); + let user_lp_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&user_lp_holding_key)); let pool_key = PrivateKey::try_new([13; 32]).unwrap(); - let pool_address = Address::from(&PublicKey::new_from_private_key(&pool_key)); + let pool_id = AccountId::from(&PublicKey::new_from_private_key(&pool_key)); //initialize Token A let mut instruction: [u8; 23] = [0; 23]; @@ -2349,7 +2349,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_a_definition_address, token_a_holding_address], + vec![token_a_definition_id, token_a_holding_id], vec![], instruction, ) @@ -2366,7 +2366,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_b_definition_address, token_b_holding_address], + vec![token_b_definition_id, token_b_holding_id], vec![], instruction, ) @@ -2384,7 +2384,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![pool_lp_definition_address, pool_lp_holding_address], + vec![pool_lp_definition_id, pool_lp_holding_id], vec![], instruction, ) @@ -2401,7 +2401,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_a_holding_address, user_a_holding_address], + vec![token_a_holding_id, user_a_holding_id], vec![0], instruction, ) @@ -2419,7 +2419,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_b_holding_address, user_b_holding_address], + vec![token_b_holding_id, user_b_holding_id], vec![0], instruction, ) @@ -2439,7 +2439,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_a_holding_address, vault_a_address], + vec![token_a_holding_id, vault_a_id], vec![1], instruction, ) @@ -2456,7 +2456,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_b_holding_address, vault_b_address], + vec![token_b_holding_id, vault_b_id], vec![1], instruction, ) @@ -2473,7 +2473,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![pool_lp_holding_address, user_lp_holding_address], + vec![pool_lp_holding_id, user_lp_holding_id], vec![0], instruction, ) @@ -2498,13 +2498,13 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::amm().id(), vec![ - pool_address, - vault_a_address, - vault_b_address, - pool_lp_holding_address, - user_a_holding_address, - user_b_holding_address, - user_lp_holding_address, + pool_id, + vault_a_id, + vault_b_id, + pool_lp_holding_id, + user_a_holding_id, + user_b_holding_id, + user_lp_holding_id, ], vec![0, 1, 0, 0], instruction, @@ -2524,19 +2524,19 @@ pub mod tests { let tx = PublicTransaction::new(message, witness_set); state.transition_from_public_transaction(&tx).unwrap(); - let mut vec_address = Vec::new(); - vec_address.push(token_a_holding_address); - vec_address.push(token_a_definition_address); - vec_address.push(token_b_holding_address); - vec_address.push(token_b_definition_address); - vec_address.push(pool_lp_definition_address); - vec_address.push(user_a_holding_address); - vec_address.push(user_b_holding_address); - vec_address.push(vault_a_address); - vec_address.push(vault_b_address); - vec_address.push(user_lp_holding_address); - vec_address.push(pool_address); - vec_address.push(pool_lp_holding_address); + let mut vec_id = Vec::new(); + vec_id.push(token_a_holding_id); + vec_id.push(token_a_definition_id); + vec_id.push(token_b_holding_id); + vec_id.push(token_b_definition_id); + vec_id.push(pool_lp_definition_id); + vec_id.push(user_a_holding_id); + vec_id.push(user_b_holding_id); + vec_id.push(vault_a_id); + vec_id.push(vault_b_id); + vec_id.push(user_lp_holding_id); + vec_id.push(pool_id); + vec_id.push(pool_lp_holding_id); let mut vec_private_keys = Vec::new(); vec_private_keys.push(token_a_holding_key); @@ -2559,12 +2559,12 @@ pub mod tests { vec_amounts.push(user_a_amount); vec_amounts.push(user_b_amount); - (state, vec_private_keys, vec_address, vec_amounts) + (state, vec_private_keys, vec_id, vec_amounts) } #[test] fn test_simple_amm_initialize() { - let (state, _vec_private_keys, vec_address, vec_amounts) = initialize_amm(); + let (state, _vec_private_keys, vec_id, vec_amounts) = initialize_amm(); let temp_amt = vec_amounts[0]; let init_balance_a = vec_amounts[1]; @@ -2572,36 +2572,36 @@ pub mod tests { let user_a_amount = vec_amounts[3]; let user_b_amount = vec_amounts[4]; - let token_a_holding_address = vec_address[0]; - let token_a_definition_address = vec_address[1]; - let token_b_holding_address = vec_address[2]; - let token_b_definition_address = vec_address[3]; - let token_lp_definition_address = vec_address[4]; - let user_a_holding_address = vec_address[5]; - let user_b_holding_address = vec_address[6]; - let vault_a_address = vec_address[7]; - let vault_b_address = vec_address[8]; - let user_lp_holding_address = vec_address[9]; - let pool_address = vec_address[10]; - let pool_lp_holding_address = vec_address[11]; + let token_a_holding_id = vec_id[0]; + let token_a_definition_id = vec_id[1]; + let token_b_holding_id = vec_id[2]; + let token_b_definition_id = vec_id[3]; + let token_lp_definition_id = vec_id[4]; + let user_a_holding_id = vec_id[5]; + let user_b_holding_id = vec_id[6]; + let vault_a_id = vec_id[7]; + let vault_b_id = vec_id[8]; + let user_lp_holding_id = vec_id[9]; + let pool_id = vec_id[10]; + let pool_lp_holding_id = vec_id[11]; - let pool_post = state.get_account_by_address(&pool_address); - let vault_a_post = state.get_account_by_address(&vault_a_address); - let vault_b_post = state.get_account_by_address(&vault_b_address); - let user_a_post = state.get_account_by_address(&user_a_holding_address); - let user_b_post = state.get_account_by_address(&user_b_holding_address); - let user_lp_post = state.get_account_by_address(&user_lp_holding_address); + let pool_post = state.get_account_by_id(&pool_id); + let vault_a_post = state.get_account_by_id(&vault_a_id); + let vault_b_post = state.get_account_by_id(&vault_b_id); + let user_a_post = state.get_account_by_id(&user_a_holding_id); + let user_b_post = state.get_account_by_id(&user_b_holding_id); + let user_lp_post = state.get_account_by_id(&user_lp_holding_id); let expected_pool = Account { program_owner: Program::amm().id(), balance: 0u128, data: PoolDefinition::into_data( PoolDefinition { - definition_token_a_id: token_a_definition_address, - definition_token_b_id: token_b_definition_address, - vault_a_addr: vault_a_address, - vault_b_addr: vault_b_address, - liquidity_pool_id: token_lp_definition_address, + definition_token_a_id: token_a_definition_id, + definition_token_b_id: token_b_definition_id, + vault_a_addr: vault_a_id, + vault_b_addr: vault_b_id, + liquidity_pool_id: token_lp_definition_id, liquidity_pool_cap: init_balance_a, reserve_a: init_balance_a, reserve_b: init_balance_b, @@ -2616,7 +2616,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: init_balance_a + temp_amt, }), nonce: 0 @@ -2628,7 +2628,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: init_balance_b + temp_amt, }), nonce: 0 @@ -2640,7 +2640,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: user_a_amount - init_balance_a, }), nonce: 1 @@ -2652,7 +2652,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: user_b_amount - init_balance_b, }), nonce: 1 @@ -2664,7 +2664,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_lp_definition_address, + definition_id: token_lp_definition_id, balance: init_balance_a + temp_amt, }), nonce: 0 @@ -2680,7 +2680,7 @@ pub mod tests { #[test] fn test_simple_amm_remove() { - let (state, vec_private_keys, vec_address, vec_amounts) = initialize_amm(); + let (state, vec_private_keys, vec_id, vec_amounts) = initialize_amm(); let mut state: V02State = state; let temp_amt = vec_amounts[0]; @@ -2702,18 +2702,18 @@ pub mod tests { let pool_key = &vec_private_keys[10]; let pool_lp_holding_key = &vec_private_keys[11]; - let token_a_holding_address = vec_address[0]; - let token_a_definition_address = vec_address[1]; - let token_b_holding_address = vec_address[2]; - let token_b_definition_address = vec_address[3]; - let token_lp_definition_address = vec_address[4]; - let user_a_holding_address = vec_address[5]; - let user_b_holding_address = vec_address[6]; - let vault_a_address = vec_address[7]; - let vault_b_address = vec_address[8]; - let user_lp_holding_address = vec_address[9]; - let pool_address = vec_address[10]; - let pool_lp_holding_address = vec_address[11]; + let token_a_holding_id = vec_id[0]; + let token_a_definition_id = vec_id[1]; + let token_b_holding_id = vec_id[2]; + let token_b_definition_id = vec_id[3]; + let token_lp_definition_id = vec_id[4]; + let user_a_holding_id = vec_id[5]; + let user_b_holding_id = vec_id[6]; + let vault_a_id = vec_id[7]; + let vault_b_id = vec_id[8]; + let user_lp_holding_id = vec_id[9]; + let pool_id = vec_id[10]; + let pool_lp_holding_id = vec_id[11]; let mut instruction: Vec = Vec::new(); instruction.push(3); @@ -2721,19 +2721,19 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::amm().id(), vec![ - pool_address, - vault_a_address, - vault_b_address, - pool_lp_holding_address, - user_a_holding_address, - user_b_holding_address, - user_lp_holding_address, + pool_id, + vault_a_id, + vault_b_id, + pool_lp_holding_id, + user_a_holding_id, + user_b_holding_id, + user_lp_holding_id, ], vec![ - state.get_account_by_address(&pool_address).nonce, - state.get_account_by_address(&user_lp_holding_address).nonce, - state.get_account_by_address(&vault_a_address).nonce, - state.get_account_by_address(&vault_b_address).nonce, + state.get_account_by_id(&pool_id).nonce, + state.get_account_by_id(&user_lp_holding_id).nonce, + state.get_account_by_id(&vault_a_id).nonce, + state.get_account_by_id(&vault_b_id).nonce, ], instruction, ) @@ -2747,12 +2747,12 @@ pub mod tests { let tx = PublicTransaction::new(message, witness_set); state.transition_from_public_transaction(&tx).unwrap(); - let pool_post = state.get_account_by_address(&pool_address); - let vault_a_post = state.get_account_by_address(&vault_a_address); - let vault_b_post = state.get_account_by_address(&vault_b_address); - let user_a_post = state.get_account_by_address(&user_a_holding_address); - let user_b_post = state.get_account_by_address(&user_b_holding_address); - let user_lp_post = state.get_account_by_address(&user_lp_holding_address); + let pool_post = state.get_account_by_id(&pool_id); + let vault_a_post = state.get_account_by_id(&vault_a_id); + let vault_b_post = state.get_account_by_id(&vault_b_id); + let user_a_post = state.get_account_by_id(&user_a_holding_id); + let user_b_post = state.get_account_by_id(&user_b_holding_id); + let user_lp_post = state.get_account_by_id(&user_lp_holding_id); //TODO: this accounts for the initial balance for User_LP let delta_lp : u128 = (init_balance_a*(init_balance_a + temp_amt))/init_balance_a; @@ -2762,11 +2762,11 @@ pub mod tests { balance: 0u128, data: PoolDefinition::into_data( PoolDefinition { - definition_token_a_id: token_a_definition_address, - definition_token_b_id: token_b_definition_address, - vault_a_addr: vault_a_address, - vault_b_addr: vault_b_address, - liquidity_pool_id: token_lp_definition_address, + definition_token_a_id: token_a_definition_id, + definition_token_b_id: token_b_definition_id, + vault_a_addr: vault_a_id, + vault_b_addr: vault_b_id, + liquidity_pool_id: token_lp_definition_id, liquidity_pool_cap: init_balance_a - delta_lp, reserve_a: 0, reserve_b: 0, @@ -2781,7 +2781,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: temp_amt, }), nonce: 1 @@ -2793,7 +2793,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: temp_amt, }), nonce: 1 @@ -2805,7 +2805,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: user_a_amount, }), nonce: 1 @@ -2817,7 +2817,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: user_b_amount, }), nonce: 1 @@ -2829,7 +2829,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_lp_definition_address, + definition_id: token_lp_definition_id, balance: 0, }), nonce: 1 @@ -2845,7 +2845,7 @@ pub mod tests { #[test] fn test_simple_amm_add() { - let (state, vec_private_keys, vec_address, vec_amounts) = initialize_amm(); + let (state, vec_private_keys, vec_id, vec_amounts) = initialize_amm(); let mut state: V02State = state; let temp_amt = vec_amounts[0]; @@ -2867,23 +2867,23 @@ pub mod tests { let pool_key = &vec_private_keys[10]; let pool_lp_holding_key = &vec_private_keys[11]; - let token_a_holding_address = vec_address[0]; - let token_a_definition_address = vec_address[1]; - let token_b_holding_address = vec_address[2]; - let token_b_definition_address = vec_address[3]; - let token_lp_definition_address = vec_address[4]; - let user_a_holding_address = vec_address[5]; - let user_b_holding_address = vec_address[6]; - let vault_a_address = vec_address[7]; - let vault_b_address = vec_address[8]; - let user_lp_holding_address = vec_address[9]; - let pool_address = vec_address[10]; - let pool_lp_holding_address = vec_address[11]; + let token_a_holding_id = vec_id[0]; + let token_a_definition_id = vec_id[1]; + let token_b_holding_id = vec_id[2]; + let token_b_definition_id = vec_id[3]; + let token_lp_definition_id = vec_id[4]; + let user_a_holding_id = vec_id[5]; + let user_b_holding_id = vec_id[6]; + let vault_a_id = vec_id[7]; + let vault_b_id = vec_id[8]; + let user_lp_holding_id = vec_id[9]; + let pool_id = vec_id[10]; + let pool_lp_holding_id = vec_id[11]; let add_a: u128 = 500; let add_b: u128 = 500; - let main_addr = token_a_definition_address; + let main_addr = token_a_definition_id; let mut instruction: Vec = Vec::new(); instruction.push(2); instruction.extend_from_slice(&add_a.to_le_bytes()); @@ -2893,19 +2893,19 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::amm().id(), vec![ - pool_address, - vault_a_address, - vault_b_address, - pool_lp_holding_address, - user_a_holding_address, - user_b_holding_address, - user_lp_holding_address, + pool_id, + vault_a_id, + vault_b_id, + pool_lp_holding_id, + user_a_holding_id, + user_b_holding_id, + user_lp_holding_id, ], vec![ - state.get_account_by_address(&pool_address).nonce, - state.get_account_by_address(&pool_lp_holding_address).nonce, - state.get_account_by_address(&user_a_holding_address).nonce, - state.get_account_by_address(&user_b_holding_address).nonce, + state.get_account_by_id(&pool_id).nonce, + state.get_account_by_id(&pool_lp_holding_id).nonce, + state.get_account_by_id(&user_a_holding_id).nonce, + state.get_account_by_id(&user_b_holding_id).nonce, ], instruction, ) @@ -2924,23 +2924,23 @@ pub mod tests { let tx = PublicTransaction::new(message, witness_set); state.transition_from_public_transaction(&tx).unwrap(); - let pool_post = state.get_account_by_address(&pool_address); - let vault_a_post = state.get_account_by_address(&vault_a_address); - let vault_b_post = state.get_account_by_address(&vault_b_address); - let user_a_post = state.get_account_by_address(&user_a_holding_address); - let user_b_post = state.get_account_by_address(&user_b_holding_address); - let user_lp_post = state.get_account_by_address(&user_lp_holding_address); + let pool_post = state.get_account_by_id(&pool_id); + let vault_a_post = state.get_account_by_id(&vault_a_id); + let vault_b_post = state.get_account_by_id(&vault_b_id); + let user_a_post = state.get_account_by_id(&user_a_holding_id); + let user_b_post = state.get_account_by_id(&user_b_holding_id); + let user_lp_post = state.get_account_by_id(&user_lp_holding_id); let expected_pool = Account { program_owner: Program::amm().id(), balance: 0u128, data: PoolDefinition::into_data( PoolDefinition { - definition_token_a_id: token_a_definition_address, - definition_token_b_id: token_b_definition_address, - vault_a_addr: vault_a_address, - vault_b_addr: vault_b_address, - liquidity_pool_id: token_lp_definition_address, + definition_token_a_id: token_a_definition_id, + definition_token_b_id: token_b_definition_id, + vault_a_addr: vault_a_id, + vault_b_addr: vault_b_id, + liquidity_pool_id: token_lp_definition_id, liquidity_pool_cap: init_balance_a + add_a, reserve_a: init_balance_a + add_a, reserve_b: init_balance_b + add_b, @@ -2955,7 +2955,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: init_balance_a + temp_amt + add_a, }), nonce: 0 @@ -2967,7 +2967,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: init_balance_b + temp_amt + add_b, }), nonce: 0 @@ -2979,7 +2979,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: user_a_amount - init_balance_a - add_a, }), nonce: 2 @@ -2991,7 +2991,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: user_b_amount - init_balance_b - add_b, }), nonce: 2 @@ -3003,7 +3003,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_lp_definition_address, + definition_id: token_lp_definition_id, balance: temp_amt + init_balance_a + add_a, }), nonce: 0 @@ -3020,7 +3020,7 @@ pub mod tests { #[test] fn test_simple_amm_swap_1() { - let (state, vec_private_keys, vec_address, vec_amounts) = initialize_amm(); + let (state, vec_private_keys, vec_id, vec_amounts) = initialize_amm(); let mut state: V02State = state; let temp_amt = vec_amounts[0]; @@ -3042,28 +3042,28 @@ pub mod tests { let pool_key = &vec_private_keys[10]; let pool_lp_holding_key = &vec_private_keys[11]; - let token_a_holding_address = vec_address[0]; - let token_a_definition_address = vec_address[1]; - let token_b_holding_address = vec_address[2]; - let token_b_definition_address = vec_address[3]; - let token_lp_definition_address = vec_address[4]; - let user_a_holding_address = vec_address[5]; - let user_b_holding_address = vec_address[6]; - let vault_a_address = vec_address[7]; - let vault_b_address = vec_address[8]; - let user_lp_holding_address = vec_address[9]; - let pool_address = vec_address[10]; - let pool_lp_holding_address = vec_address[11]; + let token_a_holding_id = vec_id[0]; + let token_a_definition_id = vec_id[1]; + let token_b_holding_id = vec_id[2]; + let token_b_definition_id = vec_id[3]; + let token_lp_definition_id = vec_id[4]; + let user_a_holding_id = vec_id[5]; + let user_b_holding_id = vec_id[6]; + let vault_a_id = vec_id[7]; + let vault_b_id = vec_id[8]; + let user_lp_holding_id = vec_id[9]; + let pool_id = vec_id[10]; + let pool_lp_holding_id = vec_id[11]; //Initialize swap user accounts let swap_user_a_holding_key = PrivateKey::try_new([21; 32]).unwrap(); - let swap_user_a_holding_address = - Address::from(&PublicKey::new_from_private_key(&swap_user_a_holding_key)); + let swap_user_a_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&swap_user_a_holding_key)); let swap_user_a_amount: u128 = 5000; let swap_user_b_holding_key = PrivateKey::try_new([22; 32]).unwrap(); - let swap_user_b_holding_address = - Address::from(&PublicKey::new_from_private_key(&swap_user_b_holding_key)); + let swap_user_b_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&swap_user_b_holding_key)); let swap_user_b_amount: u128 = 5000; // Initialize Swap User account for Token A @@ -3073,7 +3073,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_a_holding_address, swap_user_a_holding_address], + vec![token_a_holding_id, swap_user_a_holding_id], vec![2], instruction, ) @@ -3091,8 +3091,8 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_b_holding_address, swap_user_b_holding_address], - vec![state.get_account_by_address(&token_b_holding_address).nonce], + vec![token_b_holding_id, swap_user_b_holding_id], + vec![state.get_account_by_id(&token_b_holding_id).nonce], instruction, ) .unwrap(); @@ -3103,7 +3103,7 @@ pub mod tests { state.transition_from_public_transaction(&tx).unwrap(); // Initialize Swap - let main_addr = token_a_definition_address; + let main_addr = token_a_definition_id; let swap_a: u128 = 500; let mut instruction: Vec = Vec::new(); @@ -3114,21 +3114,21 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::amm().id(), vec![ - pool_address, - vault_a_address, - vault_b_address, - swap_user_a_holding_address, - swap_user_b_holding_address, + pool_id, + vault_a_id, + vault_b_id, + swap_user_a_holding_id, + swap_user_b_holding_id, ], vec![ - state.get_account_by_address(&pool_address).nonce, - state.get_account_by_address(&vault_a_address).nonce, - state.get_account_by_address(&vault_b_address).nonce, + state.get_account_by_id(&pool_id).nonce, + state.get_account_by_id(&vault_a_id).nonce, + state.get_account_by_id(&vault_b_id).nonce, state - .get_account_by_address(&swap_user_a_holding_address) + .get_account_by_id(&swap_user_a_holding_id) .nonce, state - .get_account_by_address(&swap_user_b_holding_address) + .get_account_by_id(&swap_user_b_holding_id) .nonce, ], instruction, @@ -3150,11 +3150,11 @@ pub mod tests { state.transition_from_public_transaction(&tx).unwrap(); - let pool_post = state.get_account_by_address(&pool_address); - let vault_a_post = state.get_account_by_address(&vault_a_address); - let vault_b_post = state.get_account_by_address(&vault_b_address); - let swap_user_a_post = state.get_account_by_address(&swap_user_a_holding_address); - let swap_user_b_post = state.get_account_by_address(&swap_user_b_holding_address); + let pool_post = state.get_account_by_id(&pool_id); + let vault_a_post = state.get_account_by_id(&vault_a_id); + let vault_b_post = state.get_account_by_id(&vault_b_id); + let swap_user_a_post = state.get_account_by_id(&swap_user_a_holding_id); + let swap_user_b_post = state.get_account_by_id(&swap_user_b_holding_id); let withdraw_b = (init_balance_b * swap_a)/(init_balance_a + swap_a); @@ -3164,11 +3164,11 @@ pub mod tests { balance: 0u128, data: PoolDefinition::into_data( PoolDefinition { - definition_token_a_id: token_a_definition_address, - definition_token_b_id: token_b_definition_address, - vault_a_addr: vault_a_address, - vault_b_addr: vault_b_address, - liquidity_pool_id: token_lp_definition_address, + definition_token_a_id: token_a_definition_id, + definition_token_b_id: token_b_definition_id, + vault_a_addr: vault_a_id, + vault_b_addr: vault_b_id, + liquidity_pool_id: token_lp_definition_id, liquidity_pool_cap: init_balance_a, reserve_a: init_balance_a + swap_a, reserve_b: init_balance_b - withdraw_b, @@ -3183,7 +3183,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: init_balance_a + temp_amt + swap_a, }), nonce: 1 @@ -3195,7 +3195,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: init_balance_b + temp_amt - withdraw_b, }), nonce: 1 @@ -3207,7 +3207,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: swap_user_a_amount - swap_a, }), nonce: 1 @@ -3219,7 +3219,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: swap_user_b_amount + withdraw_b, }), nonce: 1 @@ -3235,7 +3235,7 @@ pub mod tests { #[test] fn test_simple_amm_swap_2() { - let (state, vec_private_keys, vec_address, vec_amounts) = initialize_amm(); + let (state, vec_private_keys, vec_id, vec_amounts) = initialize_amm(); let mut state: V02State = state; let temp_amt = vec_amounts[0]; @@ -3257,28 +3257,28 @@ pub mod tests { let pool_key = &vec_private_keys[10]; let pool_lp_holding_key = &vec_private_keys[11]; - let token_a_holding_address = vec_address[0]; - let token_a_definition_address = vec_address[1]; - let token_b_holding_address = vec_address[2]; - let token_b_definition_address = vec_address[3]; - let token_lp_definition_address = vec_address[4]; - let user_a_holding_address = vec_address[5]; - let user_b_holding_address = vec_address[6]; - let vault_a_address = vec_address[7]; - let vault_b_address = vec_address[8]; - let user_lp_holding_address = vec_address[9]; - let pool_address = vec_address[10]; - let pool_lp_holding_address = vec_address[11]; + let token_a_holding_id = vec_id[0]; + let token_a_definition_id = vec_id[1]; + let token_b_holding_id = vec_id[2]; + let token_b_definition_id = vec_id[3]; + let token_lp_definition_id = vec_id[4]; + let user_a_holding_id = vec_id[5]; + let user_b_holding_id = vec_id[6]; + let vault_a_id = vec_id[7]; + let vault_b_id = vec_id[8]; + let user_lp_holding_id = vec_id[9]; + let pool_id = vec_id[10]; + let pool_lp_holding_id = vec_id[11]; //Initialize swap user accounts let swap_user_a_holding_key = PrivateKey::try_new([21; 32]).unwrap(); - let swap_user_a_holding_address = - Address::from(&PublicKey::new_from_private_key(&swap_user_a_holding_key)); + let swap_user_a_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&swap_user_a_holding_key)); let swap_user_a_amount: u128 = 5000; let swap_user_b_holding_key = PrivateKey::try_new([22; 32]).unwrap(); - let swap_user_b_holding_address = - Address::from(&PublicKey::new_from_private_key(&swap_user_b_holding_key)); + let swap_user_b_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&swap_user_b_holding_key)); let swap_user_b_amount: u128 = 5000; // Initialize Swap User account for Token A @@ -3288,7 +3288,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_a_holding_address, swap_user_a_holding_address], + vec![token_a_holding_id, swap_user_a_holding_id], vec![2], instruction, ) @@ -3306,8 +3306,8 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_b_holding_address, swap_user_b_holding_address], - vec![state.get_account_by_address(&token_b_holding_address).nonce], + vec![token_b_holding_id, swap_user_b_holding_id], + vec![state.get_account_by_id(&token_b_holding_id).nonce], instruction, ) .unwrap(); @@ -3318,7 +3318,7 @@ pub mod tests { state.transition_from_public_transaction(&tx).unwrap(); // Swap - let main_addr = token_b_definition_address; + let main_addr = token_b_definition_id; let swap_b: u128 = 500; let mut instruction: Vec = Vec::new(); @@ -3329,21 +3329,21 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::amm().id(), vec![ - pool_address, - vault_a_address, - vault_b_address, - swap_user_a_holding_address, - swap_user_b_holding_address, + pool_id, + vault_a_id, + vault_b_id, + swap_user_a_holding_id, + swap_user_b_holding_id, ], vec![ - state.get_account_by_address(&pool_address).nonce, - state.get_account_by_address(&vault_a_address).nonce, - state.get_account_by_address(&vault_b_address).nonce, + state.get_account_by_id(&pool_id).nonce, + state.get_account_by_id(&vault_a_id).nonce, + state.get_account_by_id(&vault_b_id).nonce, state - .get_account_by_address(&swap_user_a_holding_address) + .get_account_by_id(&swap_user_a_holding_id) .nonce, state - .get_account_by_address(&swap_user_b_holding_address) + .get_account_by_id(&swap_user_b_holding_id) .nonce, ], instruction, @@ -3364,11 +3364,11 @@ pub mod tests { let tx = PublicTransaction::new(message, witness_set); state.transition_from_public_transaction(&tx).unwrap(); - let pool_post = state.get_account_by_address(&pool_address); - let vault_a_post = state.get_account_by_address(&vault_a_address); - let vault_b_post = state.get_account_by_address(&vault_b_address); - let swap_user_a_post = state.get_account_by_address(&swap_user_a_holding_address); - let swap_user_b_post = state.get_account_by_address(&swap_user_b_holding_address); + let pool_post = state.get_account_by_id(&pool_id); + let vault_a_post = state.get_account_by_id(&vault_a_id); + let vault_b_post = state.get_account_by_id(&vault_b_id); + let swap_user_a_post = state.get_account_by_id(&swap_user_a_holding_id); + let swap_user_b_post = state.get_account_by_id(&swap_user_b_holding_id); let withdraw_a = (init_balance_a * swap_b)/(init_balance_b + swap_b); @@ -3377,11 +3377,11 @@ pub mod tests { balance: 0u128, data: PoolDefinition::into_data( PoolDefinition { - definition_token_a_id: token_a_definition_address, - definition_token_b_id: token_b_definition_address, - vault_a_addr: vault_a_address, - vault_b_addr: vault_b_address, - liquidity_pool_id: token_lp_definition_address, + definition_token_a_id: token_a_definition_id, + definition_token_b_id: token_b_definition_id, + vault_a_addr: vault_a_id, + vault_b_addr: vault_b_id, + liquidity_pool_id: token_lp_definition_id, liquidity_pool_cap: init_balance_a, reserve_a: init_balance_a - withdraw_a, reserve_b: init_balance_b + swap_b, @@ -3396,7 +3396,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: init_balance_a + temp_amt - withdraw_a, }), nonce: 1 @@ -3408,7 +3408,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: init_balance_b + temp_amt + swap_b, }), nonce: 1 @@ -3420,7 +3420,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: swap_user_a_amount + withdraw_a, }), nonce: 1 @@ -3432,7 +3432,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: swap_user_b_amount - swap_b, }), nonce: 1 @@ -3448,7 +3448,7 @@ pub mod tests { #[test] fn test_simple_amm_swap_3() { - let (state, vec_private_keys, vec_address, vec_amounts) = initialize_amm(); + let (state, vec_private_keys, vec_id, vec_amounts) = initialize_amm(); let mut state: V02State = state; let temp_amt = vec_amounts[0]; @@ -3470,28 +3470,28 @@ pub mod tests { let pool_key = &vec_private_keys[10]; let pool_lp_holding_key = &vec_private_keys[11]; - let token_a_holding_address = vec_address[0]; - let token_a_definition_address = vec_address[1]; - let token_b_holding_address = vec_address[2]; - let token_b_definition_address = vec_address[3]; - let token_lp_definition_address = vec_address[4]; - let user_a_holding_address = vec_address[5]; - let user_b_holding_address = vec_address[6]; - let vault_a_address = vec_address[7]; - let vault_b_address = vec_address[8]; - let user_lp_holding_address = vec_address[9]; - let pool_address = vec_address[10]; - let pool_lp_holding_address = vec_address[11]; + let token_a_holding_id = vec_id[0]; + let token_a_definition_id = vec_id[1]; + let token_b_holding_id = vec_id[2]; + let token_b_definition_id = vec_id[3]; + let token_lp_definition_id = vec_id[4]; + let user_a_holding_id = vec_id[5]; + let user_b_holding_id = vec_id[6]; + let vault_a_id = vec_id[7]; + let vault_b_id = vec_id[8]; + let user_lp_holding_id = vec_id[9]; + let pool_id = vec_id[10]; + let pool_lp_holding_id = vec_id[11]; //Initialize swap user accounts let swap_user_a_holding_key = PrivateKey::try_new([21; 32]).unwrap(); - let swap_user_a_holding_address = - Address::from(&PublicKey::new_from_private_key(&swap_user_a_holding_key)); + let swap_user_a_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&swap_user_a_holding_key)); let swap_user_a_amount: u128 = 5000; let swap_user_b_holding_key = PrivateKey::try_new([22; 32]).unwrap(); - let swap_user_b_holding_address = - Address::from(&PublicKey::new_from_private_key(&swap_user_b_holding_key)); + let swap_user_b_holding_id = + AccountId::from(&PublicKey::new_from_private_key(&swap_user_b_holding_key)); let swap_user_b_amount: u128 = 5000; // Initialize Swap User account for Token A @@ -3501,7 +3501,7 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_a_holding_address, swap_user_a_holding_address], + vec![token_a_holding_id, swap_user_a_holding_id], vec![2], instruction, ) @@ -3519,8 +3519,8 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::token().id(), - vec![token_b_holding_address, swap_user_b_holding_address], - vec![state.get_account_by_address(&token_b_holding_address).nonce], + vec![token_b_holding_id, swap_user_b_holding_id], + vec![state.get_account_by_id(&token_b_holding_id).nonce], instruction, ) .unwrap(); @@ -3531,7 +3531,7 @@ pub mod tests { state.transition_from_public_transaction(&tx).unwrap(); // Swap - let main_addr = token_b_definition_address; + let main_addr = token_b_definition_id; let swap_b: u128 = 500; let mut instruction: Vec = Vec::new(); @@ -3543,21 +3543,21 @@ pub mod tests { let message = public_transaction::Message::try_new( Program::amm().id(), vec![ - pool_address, - vault_b_address, - vault_a_address, - swap_user_a_holding_address, - swap_user_b_holding_address, + pool_id, + vault_b_id, + vault_a_id, + swap_user_a_holding_id, + swap_user_b_holding_id, ], vec![ - state.get_account_by_address(&pool_address).nonce, - state.get_account_by_address(&vault_b_address).nonce, - state.get_account_by_address(&vault_a_address).nonce, + state.get_account_by_id(&pool_id).nonce, + state.get_account_by_id(&vault_b_id).nonce, + state.get_account_by_id(&vault_a_id).nonce, state - .get_account_by_address(&swap_user_a_holding_address) + .get_account_by_id(&swap_user_a_holding_id) .nonce, state - .get_account_by_address(&swap_user_b_holding_address) + .get_account_by_id(&swap_user_b_holding_id) .nonce, ], instruction, @@ -3578,11 +3578,11 @@ pub mod tests { let tx = PublicTransaction::new(message, witness_set); state.transition_from_public_transaction(&tx).unwrap(); - let pool_post = state.get_account_by_address(&pool_address); - let vault_a_post = state.get_account_by_address(&vault_a_address); - let vault_b_post = state.get_account_by_address(&vault_b_address); - let swap_user_a_post = state.get_account_by_address(&swap_user_a_holding_address); - let swap_user_b_post = state.get_account_by_address(&swap_user_b_holding_address); + let pool_post = state.get_account_by_id(&pool_id); + let vault_a_post = state.get_account_by_id(&vault_a_id); + let vault_b_post = state.get_account_by_id(&vault_b_id); + let swap_user_a_post = state.get_account_by_id(&swap_user_a_holding_id); + let swap_user_b_post = state.get_account_by_id(&swap_user_b_holding_id); let withdraw_a = (init_balance_a * swap_b)/(init_balance_b + swap_b); @@ -3591,11 +3591,11 @@ pub mod tests { balance: 0u128, data: PoolDefinition::into_data( PoolDefinition { - definition_token_a_id: token_a_definition_address, - definition_token_b_id: token_b_definition_address, - vault_a_addr: vault_a_address, - vault_b_addr: vault_b_address, - liquidity_pool_id: token_lp_definition_address, + definition_token_a_id: token_a_definition_id, + definition_token_b_id: token_b_definition_id, + vault_a_addr: vault_a_id, + vault_b_addr: vault_b_id, + liquidity_pool_id: token_lp_definition_id, liquidity_pool_cap: init_balance_a, reserve_a: init_balance_a - withdraw_a, reserve_b: init_balance_b + swap_b, @@ -3610,7 +3610,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: init_balance_a + temp_amt - withdraw_a, }), nonce: 1 @@ -3622,7 +3622,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: init_balance_b + temp_amt + swap_b, }), nonce: 1 @@ -3634,7 +3634,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_a_definition_address, + definition_id: token_a_definition_id, balance: swap_user_a_amount + withdraw_a, }), nonce: 1 @@ -3646,7 +3646,7 @@ pub mod tests { data: TokenHolding::into_data( TokenHolding{ account_type: TOKEN_HOLDING_TYPE, - definition_id: token_b_definition_address, + definition_id: token_b_definition_id, balance: swap_user_b_amount - swap_b, }), nonce: 1 @@ -3659,4 +3659,5 @@ pub mod tests { assert!(pool_post == expected_pool); } + }