From cbc3cc7bbdd5fbad8098f187392ede150d5c928f Mon Sep 17 00:00:00 2001 From: Christian Kamm Date: Sat, 2 Apr 2022 11:21:41 +0200 Subject: [PATCH] MangoAccount: Rename how tokens/serum3/perps data is stored token_account_map -> tokens serum3_account_map -> serum3 perp -> perps --- .../src/instructions/create_account.rs | 6 +-- programs/mango-v4/src/instructions/deposit.rs | 4 +- .../src/instructions/liq_token_with_token.rs | 27 +++--------- .../mango-v4/src/instructions/margin_trade.rs | 7 +-- .../src/instructions/perp_consume_events.rs | 20 ++++++--- .../src/instructions/serum3_cancel_order.rs | 2 +- .../instructions/serum3_create_open_orders.rs | 8 ++-- .../serum3_liq_force_cancel_orders.rs | 6 +-- .../src/instructions/serum3_place_order.rs | 6 +-- .../src/instructions/serum3_settle_funds.rs | 6 +-- .../mango-v4/src/instructions/withdraw.rs | 4 +- programs/mango-v4/src/state/health.rs | 8 ++-- programs/mango-v4/src/state/mango_account.rs | 44 ++++++++++++------- programs/mango-v4/src/state/orderbook/book.rs | 4 +- .../tests/program_test/mango_client.rs | 29 ++++++------ programs/mango-v4/tests/test_margin_trade.rs | 2 +- .../mango-v4/tests/test_position_lifetime.rs | 4 +- programs/mango-v4/tests/test_serum.rs | 2 +- 18 files changed, 91 insertions(+), 98 deletions(-) diff --git a/programs/mango-v4/src/instructions/create_account.rs b/programs/mango-v4/src/instructions/create_account.rs index 4454c7e95..ef80262db 100644 --- a/programs/mango-v4/src/instructions/create_account.rs +++ b/programs/mango-v4/src/instructions/create_account.rs @@ -32,9 +32,9 @@ pub fn create_account(ctx: Context, account_num: u8) -> Result<() group: ctx.accounts.group.key(), owner: ctx.accounts.owner.key(), delegate: Pubkey::default(), - token_account_map: TokenAccountMap::new(), - serum3_account_map: Serum3AccountMap::new(), - perp: PerpData::new(), + tokens: MangoAccountTokens::new(), + serum3: MangoAccountSerum3::new(), + perps: MangoAccountPerps::new(), being_liquidated: 0, is_bankrupt: 0, account_num, diff --git a/programs/mango-v4/src/instructions/deposit.rs b/programs/mango-v4/src/instructions/deposit.rs index 6e334086f..251dcef87 100644 --- a/programs/mango-v4/src/instructions/deposit.rs +++ b/programs/mango-v4/src/instructions/deposit.rs @@ -60,7 +60,7 @@ pub fn deposit(ctx: Context, amount: u64) -> Result<()> { let mut account = ctx.accounts.account.load_mut()?; require!(account.is_bankrupt == 0, MangoError::IsBankrupt); - let (position, position_index) = account.token_account_map.get_mut_or_create(token_index)?; + let (position, position_index) = account.tokens.get_mut_or_create(token_index)?; // Update the bank and position let position_is_active = { @@ -87,7 +87,7 @@ pub fn deposit(ctx: Context, amount: u64) -> Result<()> { // Deposits can deactivate a position if they cancel out a previous borrow. // if !position_is_active { - account.token_account_map.deactivate(position_index); + account.tokens.deactivate(position_index); } Ok(()) diff --git a/programs/mango-v4/src/instructions/liq_token_with_token.rs b/programs/mango-v4/src/instructions/liq_token_with_token.rs index 25c58a41f..2b172df6a 100644 --- a/programs/mango-v4/src/instructions/liq_token_with_token.rs +++ b/programs/mango-v4/src/instructions/liq_token_with_token.rs @@ -75,15 +75,12 @@ pub fn liq_token_with_token( let liab_price = oracle_price(liab_oracle)?; let liqee_assets_native = liqee - .token_account_map + .tokens .get(asset_bank.token_index)? .native(&asset_bank); require!(liqee_assets_native.is_positive(), MangoError::SomeError); - let liqee_liab_native = liqee - .token_account_map - .get(liab_bank.token_index)? - .native(&liab_bank); + let liqee_liab_native = liqee.tokens.get(liab_bank.token_index)?.native(&liab_bank); require!(liqee_liab_native.is_negative(), MangoError::SomeError); // TODO why sum of both tokens liquidation fees? Add comment @@ -121,29 +118,17 @@ pub fn liq_token_with_token( let asset_transfer = cm!(liab_transfer * liab_price_adjusted / asset_price); // Apply the balance changes to the liqor and liqee accounts - liab_bank.deposit( - liqee.token_account_map.get_mut(liab_token_index)?, - liab_transfer, - )?; + liab_bank.deposit(liqee.tokens.get_mut(liab_token_index)?, liab_transfer)?; liab_bank.withdraw( - liqor - .token_account_map - .get_mut_or_create(liab_token_index)? - .0, + liqor.tokens.get_mut_or_create(liab_token_index)?.0, liab_transfer, )?; asset_bank.deposit( - liqor - .token_account_map - .get_mut_or_create(asset_token_index)? - .0, - asset_transfer, - )?; - asset_bank.withdraw( - liqee.token_account_map.get_mut(asset_token_index)?, + liqor.tokens.get_mut_or_create(asset_token_index)?.0, asset_transfer, )?; + asset_bank.withdraw(liqee.tokens.get_mut(asset_token_index)?, asset_transfer)?; // Update the health cache liqee_health_cache.adjust_token_balance(liab_token_index, liab_transfer)?; diff --git a/programs/mango-v4/src/instructions/margin_trade.rs b/programs/mango-v4/src/instructions/margin_trade.rs index acebb2747..86a53e3c9 100644 --- a/programs/mango-v4/src/instructions/margin_trade.rs +++ b/programs/mango-v4/src/instructions/margin_trade.rs @@ -39,7 +39,7 @@ pub fn margin_trade<'key, 'accounts, 'remaining, 'info>( // total number of indexed positions, since // user might end up withdrawing or depositing and activating a new indexed position require!( - banks_len >= account.token_account_map.iter_active().count(), + banks_len >= account.tokens.iter_active().count(), MangoError::SomeError // todo: SomeError ); @@ -173,10 +173,7 @@ fn adjust_for_post_cpi_amounts( let bank_loader = AccountLoader::<'_, Bank>::try_from(bank_ai)?; let mut bank = bank_loader.load_mut()?; - let position = account - .token_account_map - .get_mut_or_create(bank.token_index)? - .0; + let position = account.tokens.get_mut_or_create(bank.token_index)?.0; // user has either withdrawn or deposited bank.change( diff --git a/programs/mango-v4/src/instructions/perp_consume_events.rs b/programs/mango-v4/src/instructions/perp_consume_events.rs index 2319d8ac0..1a2fd182b 100644 --- a/programs/mango-v4/src/instructions/perp_consume_events.rs +++ b/programs/mango-v4/src/instructions/perp_consume_events.rs @@ -50,10 +50,16 @@ pub fn perp_consume_events(ctx: Context, limit: usize) -> Res Some(account_info) => account_info.load_mut::()?, }; - ma.perp - .execute_maker(perp_market.perp_market_index, &mut perp_market, fill)?; - ma.perp - .execute_taker(perp_market.perp_market_index, &mut perp_market, fill)?; + ma.perps.execute_maker( + perp_market.perp_market_index, + &mut perp_market, + fill, + )?; + ma.perps.execute_taker( + perp_market.perp_market_index, + &mut perp_market, + fill, + )?; } else { let mut maker = match mango_account_ais.iter().find(|ai| ai.key == &fill.maker) { @@ -72,12 +78,12 @@ pub fn perp_consume_events(ctx: Context, limit: usize) -> Res Some(account_info) => account_info.load_mut::()?, }; - maker.perp.execute_maker( + maker.perps.execute_maker( perp_market.perp_market_index, &mut perp_market, fill, )?; - taker.perp.execute_taker( + taker.perps.execute_taker( perp_market.perp_market_index, &mut perp_market, fill, @@ -95,7 +101,7 @@ pub fn perp_consume_events(ctx: Context, limit: usize) -> Res Some(account_info) => account_info.load_mut::()?, }; - ma.perp + ma.perps .remove_order(out.owner_slot as usize, out.quantity)?; } EventType::Liquidate => { diff --git a/programs/mango-v4/src/instructions/serum3_cancel_order.rs b/programs/mango-v4/src/instructions/serum3_cancel_order.rs index 65e971af0..581e7c570 100644 --- a/programs/mango-v4/src/instructions/serum3_cancel_order.rs +++ b/programs/mango-v4/src/instructions/serum3_cancel_order.rs @@ -59,7 +59,7 @@ pub fn serum3_cancel_order( // Validate open_orders require!( account - .serum3_account_map + .serum3 .find(serum_market.market_index) .ok_or_else(|| error!(MangoError::SomeError))? .open_orders diff --git a/programs/mango-v4/src/instructions/serum3_create_open_orders.rs b/programs/mango-v4/src/instructions/serum3_create_open_orders.rs index 89f23c6ec..26629e873 100644 --- a/programs/mango-v4/src/instructions/serum3_create_open_orders.rs +++ b/programs/mango-v4/src/instructions/serum3_create_open_orders.rs @@ -50,9 +50,7 @@ pub fn serum3_create_open_orders(ctx: Context) -> Result let serum_market = ctx.accounts.serum_market.load()?; let mut account = ctx.accounts.account.load_mut()?; require!(account.is_bankrupt == 0, MangoError::IsBankrupt); - let serum_account = account - .serum3_account_map - .create(serum_market.market_index)?; + let serum_account = account.serum3.create(serum_market.market_index)?; serum_account.open_orders = ctx.accounts.open_orders.key(); serum_account.base_token_index = serum_market.base_token_index; serum_account.quote_token_index = serum_market.quote_token_index; @@ -61,11 +59,11 @@ pub fn serum3_create_open_orders(ctx: Context) -> Result // stay permanently blocked. Otherwise users may end up in situations where // they can't settle a market because they don't have free token_account_map! let (quote_position, _) = account - .token_account_map + .tokens .get_mut_or_create(serum_market.quote_token_index)?; quote_position.in_use_count += 1; let (base_position, _) = account - .token_account_map + .tokens .get_mut_or_create(serum_market.base_token_index)?; base_position.in_use_count += 1; diff --git a/programs/mango-v4/src/instructions/serum3_liq_force_cancel_orders.rs b/programs/mango-v4/src/instructions/serum3_liq_force_cancel_orders.rs index 2cea9969b..3b41d7fec 100644 --- a/programs/mango-v4/src/instructions/serum3_liq_force_cancel_orders.rs +++ b/programs/mango-v4/src/instructions/serum3_liq_force_cancel_orders.rs @@ -71,7 +71,7 @@ pub fn serum3_liq_force_cancel_orders( // Validate open_orders require!( account - .serum3_account_map + .serum3 .find(serum_market.market_index) .ok_or_else(|| error!(MangoError::SomeError))? .open_orders @@ -137,14 +137,14 @@ pub fn serum3_liq_force_cancel_orders( let mut account = ctx.accounts.account.load_mut()?; let mut base_bank = ctx.accounts.base_bank.load_mut()?; - let base_position = account.token_account_map.get_mut(base_bank.token_index)?; + let base_position = account.tokens.get_mut(base_bank.token_index)?; base_bank.change( base_position, I80F48::from(after_base_vault) - I80F48::from(before_base_vault), )?; let mut quote_bank = ctx.accounts.quote_bank.load_mut()?; - let quote_position = account.token_account_map.get_mut(quote_bank.token_index)?; + let quote_position = account.tokens.get_mut(quote_bank.token_index)?; quote_bank.change( quote_position, I80F48::from(after_quote_vault) - I80F48::from(before_quote_vault), diff --git a/programs/mango-v4/src/instructions/serum3_place_order.rs b/programs/mango-v4/src/instructions/serum3_place_order.rs index 350e6aa89..6e441c04a 100644 --- a/programs/mango-v4/src/instructions/serum3_place_order.rs +++ b/programs/mango-v4/src/instructions/serum3_place_order.rs @@ -118,7 +118,7 @@ pub fn serum3_place_order( // Validate open_orders require!( account - .serum3_account_map + .serum3 .find(serum_market.market_index) .ok_or_else(|| error!(MangoError::SomeError))? .open_orders @@ -189,14 +189,14 @@ pub fn serum3_place_order( let mut account = ctx.accounts.account.load_mut()?; let mut base_bank = ctx.accounts.base_bank.load_mut()?; - let base_position = account.token_account_map.get_mut(base_bank.token_index)?; + let base_position = account.tokens.get_mut(base_bank.token_index)?; base_bank.change( base_position, I80F48::from(after_base_vault) - I80F48::from(before_base_vault), )?; let mut quote_bank = ctx.accounts.quote_bank.load_mut()?; - let quote_position = account.token_account_map.get_mut(quote_bank.token_index)?; + let quote_position = account.tokens.get_mut(quote_bank.token_index)?; quote_bank.change( quote_position, I80F48::from(after_quote_vault) - I80F48::from(before_quote_vault), diff --git a/programs/mango-v4/src/instructions/serum3_settle_funds.rs b/programs/mango-v4/src/instructions/serum3_settle_funds.rs index 32a554429..e8e3efafa 100644 --- a/programs/mango-v4/src/instructions/serum3_settle_funds.rs +++ b/programs/mango-v4/src/instructions/serum3_settle_funds.rs @@ -70,7 +70,7 @@ pub fn serum3_settle_funds(ctx: Context) -> Result<()> { // Validate open_orders require!( account - .serum3_account_map + .serum3 .find(serum_market.market_index) .ok_or_else(|| error!(MangoError::SomeError))? .open_orders @@ -124,14 +124,14 @@ pub fn serum3_settle_funds(ctx: Context) -> Result<()> { let mut account = ctx.accounts.account.load_mut()?; let mut base_bank = ctx.accounts.base_bank.load_mut()?; - let base_position = account.token_account_map.get_mut(base_bank.token_index)?; + let base_position = account.tokens.get_mut(base_bank.token_index)?; base_bank.change( base_position, I80F48::from(after_base_vault) - I80F48::from(before_base_vault), )?; let mut quote_bank = ctx.accounts.quote_bank.load_mut()?; - let quote_position = account.token_account_map.get_mut(quote_bank.token_index)?; + let quote_position = account.tokens.get_mut(quote_bank.token_index)?; quote_bank.change( quote_position, I80F48::from(after_quote_vault) - I80F48::from(before_quote_vault), diff --git a/programs/mango-v4/src/instructions/withdraw.rs b/programs/mango-v4/src/instructions/withdraw.rs index 5086630cc..8565613c2 100644 --- a/programs/mango-v4/src/instructions/withdraw.rs +++ b/programs/mango-v4/src/instructions/withdraw.rs @@ -62,7 +62,7 @@ pub fn withdraw(ctx: Context, amount: u64, allow_borrow: bool) -> Resu let mut account = ctx.accounts.account.load_mut()?; require!(account.is_bankrupt == 0, MangoError::IsBankrupt); - let (position, position_index) = account.token_account_map.get_mut_or_create(token_index)?; + let (position, position_index) = account.tokens.get_mut_or_create(token_index)?; // The bank will also be passed in remainingAccounts. Use an explicit scope // to drop the &mut before we borrow it immutably again later. @@ -115,7 +115,7 @@ pub fn withdraw(ctx: Context, amount: u64, allow_borrow: bool) -> Resu // deactivated. // if !position_is_active { - account.token_account_map.deactivate(position_index); + account.tokens.deactivate(position_index); } Ok(()) diff --git a/programs/mango-v4/src/state/health.rs b/programs/mango-v4/src/state/health.rs index f8dd5fe61..531a5d81f 100644 --- a/programs/mango-v4/src/state/health.rs +++ b/programs/mango-v4/src/state/health.rs @@ -165,8 +165,8 @@ pub fn compute_health_from_fixed_accounts( health_type: HealthType, ais: &[AccountInfo], ) -> Result { - let active_token_len = account.token_account_map.iter_active().count(); - let active_serum_len = account.serum3_account_map.iter_active().count(); + let active_token_len = account.tokens.iter_active().count(); + let active_serum_len = account.serum3.iter_active().count(); let expected_ais = active_token_len * 2 // banks + oracles + active_serum_len; // open_orders require!(ais.len() == expected_ais, MangoError::SomeError); @@ -298,7 +298,7 @@ fn compute_health_detail<'a, 'b: 'a>( ) -> Result { // token contribution from token accounts let mut token_infos = vec![]; - for (i, position) in account.token_account_map.iter_active().enumerate() { + for (i, position) in account.tokens.iter_active().enumerate() { let (bank, oracle_ai) = retriever.bank_and_oracle(&account.group, i, position.token_index)?; let oracle_price = oracle_price(oracle_ai)?; @@ -319,7 +319,7 @@ fn compute_health_detail<'a, 'b: 'a>( } // token contribution from serum accounts - for (i, serum_account) in account.serum3_account_map.iter_active().enumerate() { + for (i, serum_account) in account.serum3.iter_active().enumerate() { let oo = retriever.serum_oo(i, &serum_account.open_orders)?; if !allow_serum3 { require!( diff --git a/programs/mango-v4/src/state/mango_account.rs b/programs/mango-v4/src/state/mango_account.rs index ebe42625e..3130ec563 100644 --- a/programs/mango-v4/src/state/mango_account.rs +++ b/programs/mango-v4/src/state/mango_account.rs @@ -65,17 +65,22 @@ impl TokenAccount { } #[zero_copy] -pub struct TokenAccountMap { +pub struct MangoAccountTokens { pub values: [TokenAccount; MAX_TOKEN_ACCOUNTS], } +const_assert_eq!( + size_of::(), + MAX_TOKEN_ACCOUNTS * size_of::() +); +const_assert_eq!(size_of::() % 8, 0); -impl Default for TokenAccountMap { +impl Default for MangoAccountTokens { fn default() -> Self { Self::new() } } -impl TokenAccountMap { +impl MangoAccountTokens { pub fn new() -> Self { Self { values: [TokenAccount { @@ -186,17 +191,22 @@ impl Default for Serum3Account { } #[zero_copy] -pub struct Serum3AccountMap { +pub struct MangoAccountSerum3 { pub values: [Serum3Account; MAX_SERUM3_ACCOUNTS], } +const_assert_eq!( + size_of::(), + MAX_SERUM3_ACCOUNTS * size_of::() +); +const_assert_eq!(size_of::() % 8, 0); -impl Default for Serum3AccountMap { +impl Default for MangoAccountSerum3 { fn default() -> Self { Self::new() } } -impl Serum3AccountMap { +impl MangoAccountSerum3 { pub fn new() -> Self { Self { values: [Serum3Account::default(); MAX_SERUM3_ACCOUNTS], @@ -308,7 +318,7 @@ impl PerpAccount { } #[zero_copy] -pub struct PerpData { +pub struct MangoAccountPerps { pub accounts: [PerpAccount; MAX_PERP_ACCOUNTS], // TODO: possibly it's more convenient to store a single list of PerpOpenOrder structs? @@ -318,12 +328,12 @@ pub struct PerpData { pub order_client_id: [u64; MAX_PERP_OPEN_ORDERS], } const_assert_eq!( - size_of::(), + size_of::(), MAX_PERP_ACCOUNTS * size_of::() + MAX_PERP_OPEN_ORDERS * (2 + 1 + 16 + 8) ); -const_assert_eq!(size_of::() % 8, 0); +const_assert_eq!(size_of::() % 8, 0); -impl PerpData { +impl MangoAccountPerps { pub fn new() -> Self { Self { accounts: [PerpAccount::default(); MAX_PERP_ACCOUNTS], @@ -491,7 +501,7 @@ impl PerpData { } } -impl Default for PerpData { +impl Default for MangoAccountPerps { fn default() -> Self { Self::new() } @@ -507,13 +517,13 @@ pub struct MangoAccount { // Maps token_index -> deposit/borrow account for each token // that is active on this MangoAccount. - pub token_account_map: TokenAccountMap, + pub tokens: MangoAccountTokens, // Maps serum_market_index -> open orders for each serum market // that is active on this MangoAccount. - pub serum3_account_map: Serum3AccountMap, + pub serum3: MangoAccountSerum3, - pub perp: PerpData, + pub perps: MangoAccountPerps, /// This account cannot open new positions or borrow until `init_health >= 0` pub being_liquidated: u8, @@ -530,9 +540,9 @@ pub struct MangoAccount { const_assert_eq!( size_of::(), 3 * 32 - + MAX_TOKEN_ACCOUNTS * size_of::() - + MAX_SERUM3_ACCOUNTS * size_of::() - + size_of::() + + size_of::() + + size_of::() + + size_of::() + 4 + 4 ); diff --git a/programs/mango-v4/src/state/orderbook/book.rs b/programs/mango-v4/src/state/orderbook/book.rs index b678e23f9..694546329 100644 --- a/programs/mango-v4/src/state/orderbook/book.rs +++ b/programs/mango-v4/src/state/orderbook/book.rs @@ -336,7 +336,7 @@ impl<'a> Book<'a> { } let owner_slot = mango_account - .perp + .perps .next_order_slot() .ok_or_else(|| error!(MangoError::SomeError))?; let new_order = LeafNode::new( @@ -397,7 +397,7 @@ fn apply_fees( let taker_fees = taker_quote_native * market.taker_fee; let perp_account = mango_account - .perp + .perps .get_account_mut_or_create(market.perp_market_index)? .0; perp_account.quote_position_native -= taker_fees; diff --git a/programs/mango-v4/tests/program_test/mango_client.rs b/programs/mango-v4/tests/program_test/mango_client.rs index 6dfa33b2f..395a78b1e 100644 --- a/programs/mango-v4/tests/program_test/mango_client.rs +++ b/programs/mango-v4/tests/program_test/mango_client.rs @@ -110,7 +110,7 @@ async fn derive_health_check_remaining_account_metas( // figure out all the banks/oracles that need to be passed for the health check let mut banks = vec![]; let mut oracles = vec![]; - for position in account.token_account_map.iter_active() { + for position in account.tokens.iter_active() { let mint_info = get_mint_info_by_token_index(account_loader, account, position.token_index).await; // TODO: ALTs are unavailable @@ -129,7 +129,7 @@ async fn derive_health_check_remaining_account_metas( // If there is not yet an active position for the token, we need to pass // the bank/oracle for health check anyway. let new_position = account - .token_account_map + .tokens .values .iter() .position(|p| !p.is_active()) @@ -140,10 +140,7 @@ async fn derive_health_check_remaining_account_metas( } } - let serum_oos = account - .serum3_account_map - .iter_active() - .map(|&s| s.open_orders); + let serum_oos = account.serum3.iter_active().map(|&s| s.open_orders); banks .iter() @@ -175,9 +172,9 @@ async fn derive_liquidation_remaining_account_metas( let mut banks = vec![]; let mut oracles = vec![]; let token_indexes = liqee - .token_account_map + .tokens .iter_active() - .chain(liqor.token_account_map.iter_active()) + .chain(liqor.tokens.iter_active()) .map(|ta| ta.token_index) .unique(); for token_index in token_indexes { @@ -199,9 +196,9 @@ async fn derive_liquidation_remaining_account_metas( } let serum_oos = liqee - .serum3_account_map + .serum3 .iter_active() - .chain(liqor.serum3_account_map.iter_active()) + .chain(liqor.serum3.iter_active()) .map(|&s| s.open_orders); banks @@ -232,7 +229,7 @@ pub async fn account_position(solana: &SolanaCookie, account: Pubkey, bank: Pubk let account_data: MangoAccount = solana.get_account(account).await; let bank_data: Bank = solana.get_account(bank).await; let native = account_data - .token_account_map + .tokens .find(bank_data.token_index) .unwrap() .native(&bank_data); @@ -266,7 +263,7 @@ impl<'keypair> ClientInstruction for MarginTradeInstruction<'keypair> { let account: MangoAccount = account_loader.load(&self.account).await.unwrap(); let instruction = Self::Instruction { - banks_len: account.token_account_map.iter_active().count(), + banks_len: account.tokens.iter_active().count(), cpi_data: self.margin_trade_program_ix_cpi_data.clone(), }; @@ -876,7 +873,7 @@ impl<'keypair> ClientInstruction for Serum3PlaceOrderInstruction<'keypair> { let account: MangoAccount = account_loader.load(&self.account).await.unwrap(); let serum_market: Serum3Market = account_loader.load(&self.serum_market).await.unwrap(); let open_orders = account - .serum3_account_map + .serum3 .find(serum_market.market_index) .unwrap() .open_orders; @@ -971,7 +968,7 @@ impl<'keypair> ClientInstruction for Serum3CancelOrderInstruction<'keypair> { let account: MangoAccount = account_loader.load(&self.account).await.unwrap(); let serum_market: Serum3Market = account_loader.load(&self.serum_market).await.unwrap(); let open_orders = account - .serum3_account_map + .serum3 .find(serum_market.market_index) .unwrap() .open_orders; @@ -1030,7 +1027,7 @@ impl<'keypair> ClientInstruction for Serum3SettleFundsInstruction<'keypair> { let account: MangoAccount = account_loader.load(&self.account).await.unwrap(); let serum_market: Serum3Market = account_loader.load(&self.serum_market).await.unwrap(); let open_orders = account - .serum3_account_map + .serum3 .find(serum_market.market_index) .unwrap() .open_orders; @@ -1104,7 +1101,7 @@ impl ClientInstruction for Serum3LiqForceCancelOrdersInstruction { let account: MangoAccount = account_loader.load(&self.account).await.unwrap(); let serum_market: Serum3Market = account_loader.load(&self.serum_market).await.unwrap(); let open_orders = account - .serum3_account_map + .serum3 .find(serum_market.market_index) .unwrap() .open_orders; diff --git a/programs/mango-v4/tests/test_margin_trade.rs b/programs/mango-v4/tests/test_margin_trade.rs index 430e14d76..902d534b8 100644 --- a/programs/mango-v4/tests/test_margin_trade.rs +++ b/programs/mango-v4/tests/test_margin_trade.rs @@ -84,7 +84,7 @@ async fn test_margin_trade() -> Result<(), TransportError> { let account_data: MangoAccount = solana.get_account(account).await; let bank_data: Bank = solana.get_account(bank).await; assert!( - account_data.token_account_map.values[0].native(&bank_data) + account_data.tokens.values[0].native(&bank_data) - I80F48::from_num(deposit_amount_initial) < dust_threshold ); diff --git a/programs/mango-v4/tests/test_position_lifetime.rs b/programs/mango-v4/tests/test_position_lifetime.rs index d0e7c4aa2..3f3363255 100644 --- a/programs/mango-v4/tests/test_position_lifetime.rs +++ b/programs/mango-v4/tests/test_position_lifetime.rs @@ -120,7 +120,7 @@ async fn test_position_lifetime() -> Result<()> { // Check that positions are fully deactivated let account: MangoAccount = solana.get_account(account).await; - assert_eq!(account.token_account_map.iter_active().count(), 0); + assert_eq!(account.tokens.iter_active().count(), 0); // No user tokens got lost for &payer_token in payer_mint_accounts { @@ -199,7 +199,7 @@ async fn test_position_lifetime() -> Result<()> { // Check that positions are fully deactivated let account: MangoAccount = solana.get_account(account).await; - assert_eq!(account.token_account_map.iter_active().count(), 0); + assert_eq!(account.tokens.iter_active().count(), 0); // No user tokens got lost for &payer_token in payer_mint_accounts { diff --git a/programs/mango-v4/tests/test_serum.rs b/programs/mango-v4/tests/test_serum.rs index 53b9acbd0..5e0d36bed 100644 --- a/programs/mango-v4/tests/test_serum.rs +++ b/programs/mango-v4/tests/test_serum.rs @@ -127,7 +127,7 @@ async fn test_serum() -> Result<(), TransportError> { let account_data: MangoAccount = solana.get_account(account).await; assert_eq!( account_data - .serum3_account_map + .serum3 .iter_active() .map(|v| (v.open_orders, v.market_index)) .collect::>(),