add passthrough account logic (#1602)

* add passthrough account logic

* cant read yet

* fix all zc alignment issues

* make oracle source a u8 on zc struct

Author: moosecat2

programs/drift/src/instructions/admin.rs

@@ -57,9 +57,10 @@ use crate::state::oracle::{
 use crate::state::oracle_map::OracleMap;
 use crate::state::paused_operations::{InsuranceFundOperation, PerpOperation, SpotOperation};
 use crate::state::perp_market::{
-    ContractTier, ContractType, InsuranceClaim, MarketStatus, PerpMarket, PoolBalance, AMM,
+    AmmCache, CacheInfo, ContractTier, ContractType, InsuranceClaim, MarketStatus, PerpMarket,
+    PoolBalance, AMM, AMM_POSITIONS_CACHE,
 };
-use crate::state::perp_market_map::get_writable_perp_market_set;
+use crate::state::perp_market_map::{get_writable_perp_market_set, MarketSet};
 use crate::state::protected_maker_mode_config::ProtectedMakerModeConfig;
 use crate::state::pyth_lazer_oracle::{PythLazerOracle, PYTH_LAZER_ORACLE_SEED};
 use crate::state::spot_market::{
@@ -1055,6 +1056,22 @@ pub fn handle_initialize_perp_market(
 
     safe_increment!(state.number_of_markets, 1);
 
+    let amm_cache = &mut ctx.accounts.amm_cache;
+    let current_len = amm_cache.cache.len();
+    amm_cache
+        .cache
+        .resize_with(current_len + 1, CacheInfo::default);
+    let current_market_info = amm_cache.cache.get_mut(current_len).unwrap();
+    current_market_info.slot = clock_slot;
+
+    current_market_info.oracle = perp_market.amm.oracle;
+    current_market_info.oracle_source = u8::from(perp_market.amm.oracle_source);
+    current_market_info.last_oracle_price_twap = perp_market
+        .amm
+        .historical_oracle_data
+        .last_oracle_price_twap;
+    amm_cache.validate(state)?;
+
     controller::amm::update_concentration_coef(perp_market, concentration_coef_scale)?;
     crate::dlog!(oracle_price);
 
@@ -1070,6 +1087,48 @@ pub fn handle_initialize_perp_market(
     Ok(())
 }
 
+pub fn handle_initialize_amm_cache(ctx: Context<InitializeAmmCache>) -> Result<()> {
+    let amm_cache = &mut ctx.accounts.amm_cache;
+    let state = &ctx.accounts.state;
+    amm_cache
+        .cache
+        .resize_with(state.number_of_markets as usize, CacheInfo::default);
+
+    Ok(())
+}
+
+pub fn handle_update_init_amm_cache_info<'c: 'info, 'info>(
+    ctx: Context<'_, '_, 'c, 'info, UpdateInitAmmCacheInfo<'info>>,
+) -> Result<()> {
+    let amm_cache = &mut ctx.accounts.amm_cache;
+
+    let AccountMaps {
+        perp_market_map,
+        spot_market_map: _,
+        oracle_map: _,
+    } = load_maps(
+        &mut ctx.remaining_accounts.iter().peekable(),
+        &MarketSet::new(),
+        &MarketSet::new(),
+        Clock::get()?.slot,
+        None,
+    )?;
+
+    for (_, perp_market_loader) in perp_market_map.0 {
+        let perp_market = perp_market_loader.load()?;
+        let market_index = perp_market.market_index as usize;
+        let cache = amm_cache.cache.get_mut(market_index).unwrap();
+        cache.oracle = perp_market.amm.oracle;
+        cache.oracle_source = u8::from(perp_market.amm.oracle_source);
+        cache.last_oracle_price_twap = perp_market
+            .amm
+            .historical_oracle_data
+            .last_oracle_price_twap;
+    }
+
+    Ok(())
+}
+
 #[access_control(
     perp_market_valid(&ctx.accounts.perp_market)
 )]
@@ -3128,10 +3187,11 @@ pub fn handle_update_perp_market_paused_operations(
     perp_market_valid(&ctx.accounts.perp_market)
 )]
 pub fn handle_update_perp_market_contract_tier(
-    ctx: Context<AdminUpdatePerpMarket>,
+    ctx: Context<AdminUpdatePerpMarketContractTier>,
     contract_tier: ContractTier,
 ) -> Result<()> {
     let perp_market = &mut load_mut!(ctx.accounts.perp_market)?;
+    let amm_cache = &mut ctx.accounts.amm_cache;
     msg!("perp market {}", perp_market.market_index);
 
     msg!(
@@ -3141,6 +3201,14 @@ pub fn handle_update_perp_market_contract_tier(
     );
 
     perp_market.contract_tier = contract_tier;
+    let max_confidence_interval_multiplier =
+        perp_market.get_max_confidence_interval_multiplier()?;
+    amm_cache
+        .cache
+        .get_mut(perp_market.market_index as usize)
+        .expect("value should exist for market index")
+        .max_confidence_interval_multiplier = max_confidence_interval_multiplier;
+
     Ok(())
 }
 
@@ -3488,6 +3556,7 @@ pub fn handle_update_perp_market_oracle(
     skip_invariant_check: bool,
 ) -> Result<()> {
     let perp_market = &mut load_mut!(ctx.accounts.perp_market)?;
+    let amm_cache = &mut ctx.accounts.amm_cache;
     msg!("perp market {}", perp_market.market_index);
 
     let clock = Clock::get()?;
@@ -3566,6 +3635,14 @@ pub fn handle_update_perp_market_oracle(
     perp_market.amm.oracle = oracle;
     perp_market.amm.oracle_source = oracle_source;
 
+    let amm_position_cache_info = amm_cache
+        .cache
+        .get_mut(perp_market.market_index as usize)
+        .expect("value should exist for market index");
+
+    amm_position_cache_info.oracle = oracle;
+    amm_position_cache_info.oracle_source = u8::from(oracle_source);
+
     Ok(())
 }
 
@@ -4890,12 +4967,57 @@ pub struct InitializePerpMarket<'info> {
         payer = admin
     )]
     pub perp_market: AccountLoader<'info, PerpMarket>,
+    #[account(
+        mut,
+        seeds = [AMM_POSITIONS_CACHE.as_ref()],
+        bump,
+        realloc = AmmCache::space(amm_cache.cache.len() + 1 as usize),
+        realloc::payer = admin,
+        realloc::zero = false,
+    )]
+    pub amm_cache: Box<Account<'info, AmmCache>>,
     /// CHECK: checked in `initialize_perp_market`
     pub oracle: AccountInfo<'info>,
     pub rent: Sysvar<'info, Rent>,
     pub system_program: Program<'info, System>,
 }
 
+#[derive(Accounts)]
+pub struct InitializeAmmCache<'info> {
+    #[account(
+        mut,
+        constraint = admin.key() == admin_hot_wallet::id() || admin.key() == state.admin
+    )]
+    pub admin: Signer<'info>,
+    pub state: Box<Account<'info, State>>,
+    #[account(
+        init,
+        seeds = [AMM_POSITIONS_CACHE.as_ref()],
+        space = AmmCache::space(state.number_of_markets as usize),
+        bump,
+        payer = admin
+    )]
+    pub amm_cache: Box<Account<'info, AmmCache>>,
+    pub rent: Sysvar<'info, Rent>,
+    pub system_program: Program<'info, System>,
+}
+
+#[derive(Accounts)]
+pub struct UpdateInitAmmCacheInfo<'info> {
+    #[account(
+        mut,
+        constraint = admin.key() == admin_hot_wallet::id() || admin.key() == state.admin
+    )]
+    pub state: Box<Account<'info, State>>,
+    pub admin: Signer<'info>,
+    #[account(
+        mut,
+        seeds = [AMM_POSITIONS_CACHE.as_ref()],
+        bump,
+    )]
+    pub amm_cache: Box<Account<'info, AmmCache>>,
+}
+
 #[derive(Accounts)]
 pub struct DeleteInitializedPerpMarket<'info> {
     #[account(mut)]
@@ -4920,6 +5042,23 @@ pub struct AdminUpdatePerpMarket<'info> {
     pub perp_market: AccountLoader<'info, PerpMarket>,
 }
 
+#[derive(Accounts)]
+pub struct AdminUpdatePerpMarketContractTier<'info> {
+    pub admin: Signer<'info>,
+    #[account(
+        has_one = admin
+    )]
+    pub state: Box<Account<'info, State>>,
+    #[account(mut)]
+    pub perp_market: AccountLoader<'info, PerpMarket>,
+    #[account(
+        mut,
+        seeds = [AMM_POSITIONS_CACHE.as_ref()],
+        bump,
+    )]
+    pub amm_cache: Box<Account<'info, AmmCache>>,
+}
+
 #[derive(Accounts)]
 pub struct AdminUpdatePerpMarketAmmSummaryStats<'info> {
     #[account(
@@ -5087,6 +5226,12 @@ pub struct AdminUpdatePerpMarketOracle<'info> {
     pub oracle: AccountInfo<'info>,
     /// CHECK: checked in `admin_update_perp_market_oracle` ix constraint
     pub old_oracle: AccountInfo<'info>,
+    #[account(
+        mut,
+        seeds = [AMM_POSITIONS_CACHE.as_ref()],
+        bump,
+    )]
+    pub amm_cache: Box<Account<'info, AmmCache>>,
 }
 
 #[derive(Accounts)]

programs/drift/src/instructions/keeper.rs

@@ -40,8 +40,10 @@ use crate::state::fulfillment_params::serum::SerumFulfillmentParams;
 use crate::state::high_leverage_mode_config::HighLeverageModeConfig;
 use crate::state::insurance_fund_stake::InsuranceFundStake;
 use crate::state::oracle_map::OracleMap;
-use crate::state::order_params::{OrderParams, PlaceOrderOptions, SignedMsgOrderParamsMessage};
+use crate::state::order_params::{OrderParams, PlaceOrderOptions};
 use crate::state::paused_operations::{PerpOperation, SpotOperation};
+use crate::state::perp_market::CacheInfo;
+use crate::state::perp_market::AMM_POSITIONS_CACHE;
 use crate::state::perp_market::{ContractType, MarketStatus, PerpMarket};
 use crate::state::perp_market_map::{
     get_market_set_for_spot_positions, get_market_set_for_user_positions, get_market_set_from_list,
@@ -62,6 +64,8 @@ use crate::state::user::{
     MarginMode, MarketType, OrderStatus, OrderTriggerCondition, OrderType, User, UserStats,
 };
 use crate::state::user_map::{load_user_map, load_user_maps, UserMap, UserStatsMap};
+use crate::state::zero_copy::AccountZeroCopyMut;
+use crate::state::zero_copy::ZeroCopyLoader;
 use crate::validation::sig_verification::verify_and_decode_ed25519_msg;
 use crate::validation::user::{validate_user_deletion, validate_user_is_idle};
 use crate::{
@@ -2911,6 +2915,63 @@ pub fn handle_pause_spot_market_deposit_withdraw(
     Ok(())
 }
 
+pub fn handle_update_amm_cache<'c: 'info, 'info>(
+    ctx: Context<'_, '_, 'c, 'info, UpdateAmmCache<'info>>,
+) -> Result<()> {
+    let remaining_accounts_iter = &mut ctx.remaining_accounts.iter().peekable();
+    let mut amm_cache: AccountZeroCopyMut<'_, CacheInfo, _> =
+        ctx.accounts.amm_cache.load_zc_mut()?;
+    let AccountMaps {
+        perp_market_map,
+        spot_market_map: _,
+        mut oracle_map,
+    } = load_maps(
+        remaining_accounts_iter,
+        &MarketSet::new(),
+        &MarketSet::new(),
+        Clock::get()?.slot,
+        None,
+    )?;
+    let slot = Clock::get()?.slot;
+
+    for (_, perp_market_loader) in perp_market_map.0.iter() {
+        let perp_market = perp_market_loader.load()?;
+        let cached_info = amm_cache.get_mut(perp_market.market_index as u32);
+        cached_info.position = perp_market.amm.get_protocol_owned_position()?;
+        cached_info.slot = slot;
+        cached_info.last_oracle_price_twap = perp_market
+            .amm
+            .historical_oracle_data
+            .last_oracle_price_twap;
+
+        validate!(
+            perp_market.oracle_id() == cached_info.oracle_id()?,
+            ErrorCode::DefaultError,
+            "oracle id mismatch between amm cache and perp market"
+        )?;
+
+        let oracle_data = oracle_map.get_price_data(&perp_market.oracle_id())?;
+        cached_info.oracle_price = oracle_data.price;
+        cached_info.oracle_delay = oracle_data.delay;
+        cached_info.oracle_confidence = oracle_data.confidence;
+    }
+
+    Ok(())
+}
+
+#[derive(Accounts)]
+pub struct UpdateAmmCache<'info> {
+    #[account(mut)]
+    pub keeper: Signer<'info>,
+    #[account(
+        mut,
+        seeds = [AMM_POSITIONS_CACHE.as_ref()],
+        bump,
+    )]
+    /// CHECK: checked in AmmCacheZeroCopy checks
+    pub amm_cache: AccountInfo<'info>,
+}
+
 #[derive(Accounts)]
 pub struct FillOrder<'info> {
     pub state: Box<Account<'info, State>>,