zero copy + permissionless crank ixs (#1581)

Author: moosecat2

programs/drift/src/instructions/admin.rs

@@ -4390,7 +4390,7 @@ pub fn handle_initialize_lp_pool(
         last_revenue_rebalance_ts: 0,
         total_fees_received: 0,
         total_fees_paid: 0,
-        padding: [0; 6],
+        _padding: [0; 6],
     };
 
     let signature_seeds = get_signer_seeds(&state.signer_nonce);

programs/drift/src/instructions/lp_pool.rs

@@ -0,0 +1,85 @@
+use anchor_lang::{
+    prelude::{Account, AccountInfo, AccountLoader, Context, Pubkey, Signer, SolanaSysvar},
+    Accounts, Result,
+};
+
+use crate::state::{
+    lp_pool::{
+        AmmConstituentDatum, AmmConstituentMappingFixed, ConstituentTargetWeightsFixed, LPPool,
+        WeightDatum,
+    },
+    perp_market_map::MarketSet,
+    state::State,
+    zero_copy::{AccountZeroCopy, AccountZeroCopyMut, ZeroCopyLoader},
+};
+use solana_program::sysvar::clock::Clock;
+
+use super::optional_accounts::{load_maps, AccountMaps};
+
+pub fn handle_update_dlp_target_weights<'info, 'c: 'info>(
+    ctx: Context<'_, 'info, 'c, 'info, UpdateDlpTargetWeights<'info>>,
+    constituent_indexes: Vec<u16>,
+) -> Result<()> {
+    let state = &ctx.accounts.state;
+    let lp_pool = &ctx.accounts.lp_pool.load()?;
+    let slot = Clock::get()?.slot;
+
+    let amm_constituent_mapping: AccountZeroCopy<
+        'info,
+        AmmConstituentDatum,
+        AmmConstituentMappingFixed,
+    > = ctx.accounts.amm_constituent_mapping.load_zc()?;
+
+    let mut target_weights: AccountZeroCopyMut<'info, WeightDatum, ConstituentTargetWeightsFixed> =
+        ctx.accounts.constituent_target_weights.load_zc_mut()?;
+
+    let AccountMaps {
+        perp_market_map,
+        spot_market_map,
+        mut oracle_map,
+    } = load_maps(
+        &mut ctx.remaining_accounts.iter().peekable(),
+        &MarketSet::new(),
+        &MarketSet::new(),
+        slot,
+        Some(state.oracle_guard_rails),
+    )?;
+
+    let mut amm_inventories: Vec<(u16, i64)> = vec![];
+    let mut oracle_prices: Vec<i64> = vec![];
+    for (i, datum) in amm_constituent_mapping.iter().enumerate() {
+        let perp_market = perp_market_map.get_ref(&datum.perp_market_index)?;
+        let amm_inventory = perp_market.amm.get_protocol_owned_position()?;
+        amm_inventories.push((datum.perp_market_index, amm_inventory));
+
+        let oracle_data = oracle_map.get_price_data_and_guard_rails(&(
+            perp_market.amm.oracle,
+            perp_market.amm.oracle_source,
+        ))?;
+
+        oracle_prices.push(oracle_data.0.price);
+    }
+
+    target_weights.update_target_weights(
+        &amm_constituent_mapping,
+        amm_inventories.as_slice(),
+        constituent_indexes.as_slice(),
+        &oracle_prices.as_slice(),
+        lp_pool.last_aum,
+        slot,
+    )?;
+
+    Ok(())
+}
+
+#[derive(Accounts)]
+pub struct UpdateDlpTargetWeights<'info> {
+    pub state: Box<Account<'info, State>>,
+    #[account(mut)]
+    pub keeper: Signer<'info>,
+    /// CHECK: checked in AmmConstituentMappingZeroCopy checks
+    pub amm_constituent_mapping: AccountInfo<'info>,
+    /// CHECK: checked in ConstituentTargetWeightsZeroCopy checks
+    pub constituent_target_weights: AccountInfo<'info>,
+    pub lp_pool: AccountLoader<'info, LPPool>,
+}

programs/drift/src/instructions/mod.rs

@@ -2,6 +2,7 @@ pub use admin::*;
 pub use constraints::*;
 pub use if_staker::*;
 pub use keeper::*;
+pub use lp_pool::*;
 pub use pyth_lazer_oracle::*;
 pub use pyth_pull_oracle::*;
 pub use user::*;
@@ -10,6 +11,7 @@ mod admin;
 mod constraints;
 mod if_staker;
 mod keeper;
+mod lp_pool;
 pub mod optional_accounts;
 mod pyth_lazer_oracle;
 mod pyth_pull_oracle;

programs/drift/src/state/lp_pool.rs

@@ -1,17 +1,20 @@
-use crate::error::{DriftResult, ErrorCode};
+use crate::error::DriftResult;
 use crate::math::casting::Cast;
 use crate::math::constants::{PERCENTAGE_PRECISION_I128, PERCENTAGE_PRECISION_I64};
 use crate::math::safe_math::SafeMath;
-use crate::state::oracle::OracleSource;
-use crate::state::spot_market::{SpotBalance, SpotBalanceType, SpotMarket};
+use crate::state::spot_market::{SpotBalance, SpotBalanceType};
 use crate::state::traits::Size;
 use anchor_lang::prelude::*;
+use anchor_lang::Discriminator;
 use borsh::{BorshDeserialize, BorshSerialize};
 
+use super::zero_copy::{AccountZeroCopy, AccountZeroCopyMut, HasLen};
+use crate::impl_zero_copy_loader;
+
 #[cfg(test)]
 mod tests;
 
-#[account(zero_copy)]
+#[account(zero_copy(unsafe))]
 #[derive(Default, Debug)]
 #[repr(C)]
 pub struct LPPool {
@@ -40,7 +43,7 @@ pub struct LPPool {
     /// timestamp of last AUM slot
     pub last_aum_slot: u64, // 8, 152
     /// timestamp of last AUM update
-    pub last_aum_ts: u64, // 8, 160
+    pub last_aum_ts: u64, // 8, 160``
 
     /// timestamp of last vAMM revenue rebalance
     pub last_revenue_rebalance_ts: u64, // 8, 168
@@ -51,7 +54,7 @@ pub struct LPPool {
     pub total_fees_paid: u128, // 16, 192
 
     pub constituents: u16, // 2, 194
-    pub padding: [u8; 6],
+    pub _padding: [u8; 6],
 }
 
 impl Size for LPPool {
@@ -131,9 +134,6 @@ pub struct Constituent {
     pub padding: [u8; 16],
 }
 
-//   pub struct PerpConstituent {
-//   }
-
 #[zero_copy]
 #[derive(Debug, BorshDeserialize, BorshSerialize)]
 #[repr(C)]
@@ -146,6 +146,34 @@ pub struct AmmConstituentDatum {
     pub last_slot: u64,
 }
 
+#[zero_copy]
+pub struct AmmConstituentMappingFixed {
+    pub len: u32,
+}
+
+impl HasLen for AmmConstituentMappingFixed {
+    fn len(&self) -> u32 {
+        self.len
+    }
+}
+
+#[account]
+#[derive(Debug)]
+#[repr(C)]
+pub struct AmmConstituentMapping {
+    // PERCENTAGE_PRECISION. Each datum represents the target weight for a single (AMM, Constituent) pair.
+    // An AMM may be partially backed by multiple Constituents
+    pub data: Vec<AmmConstituentDatum>,
+}
+
+impl_zero_copy_loader!(
+    AmmConstituentMapping,
+    crate::id,
+    AmmConstituentMappingFixed,
+    AmmConstituentDatum,
+    AmmConstituentMapping::discriminator()
+);
+
 #[zero_copy]
 #[derive(Debug, BorshDeserialize, BorshSerialize)]
 #[repr(C)]
@@ -157,13 +185,18 @@ pub struct WeightDatum {
     pub last_slot: u64,
 }
 
-#[account]
+#[zero_copy]
 #[derive(Debug)]
 #[repr(C)]
-pub struct AmmConstituentMapping {
-    // PERCENTAGE_PRECISION. Each datum represents the target weight for a single (AMM, Constituent) pair.
-    // An AMM may be partially backed by multiple Constituents
-    pub data: Vec<AmmConstituentDatum>,
+pub struct ConstituentTargetWeightsFixed {
+    /// total elements in the flattened `data` vec
+    pub len: u32,
+}
+
+impl HasLen for ConstituentTargetWeightsFixed {
+    fn len(&self) -> u32 {
+        self.len
+    }
 }
 
 #[account]
@@ -174,6 +207,14 @@ pub struct ConstituentTargetWeights {
     pub data: Vec<WeightDatum>,
 }
 
+impl_zero_copy_loader!(
+    ConstituentTargetWeights,
+    crate::id,
+    ConstituentTargetWeightsFixed,
+    WeightDatum,
+    ConstituentTargetWeights::discriminator()
+);
+
 impl Default for ConstituentTargetWeights {
     fn default() -> Self {
         ConstituentTargetWeights {
@@ -182,61 +223,46 @@ impl Default for ConstituentTargetWeights {
     }
 }
 
-impl ConstituentTargetWeights {
+impl<'a> AccountZeroCopyMut<'a, WeightDatum, ConstituentTargetWeightsFixed> {
     /// Update target weights based on amm_inventory and mapping
     pub fn update_target_weights(
         &mut self,
-        mapping: &AmmConstituentMapping,
-        amm_inventory: &[(u16, i64)],
-        constituents: &[Constituent],
-        prices: &[u64], // same order as constituents
+        mapping: &AccountZeroCopy<'a, AmmConstituentDatum, AmmConstituentMappingFixed>,
+        // (perp market index, inventory, price)
+        amm_inventory: &[(u16, i64)], // length = mapping.num_rows
+        constituents_indexes: &[u16],
+        prices: &[i64], // length = mapping.num_rows
         aum: u64,
         slot: u64,
     ) -> DriftResult<()> {
-        // assert_ne!(aum, 0);
-        assert_eq!(prices.len(), constituents.len());
-
-        self.data.clear();
-
-        for (constituent_index, constituent) in constituents.iter().enumerate() {
+        for (i, constituent_index) in constituents_indexes.iter().enumerate() {
             let mut target_amount = 0i128;
 
             for (perp_market_index, inventory) in amm_inventory.iter() {
                 let idx = mapping
-                    .data
                     .iter()
                     .position(|d| &d.perp_market_index == perp_market_index)
                     .expect("missing mapping for this market index");
-                let weight = mapping.data[idx].data; // PERCENTAGE_PRECISION
+                let weight = mapping.get(idx).data; // PERCENTAGE_PRECISION
                 target_amount +=
                     (*inventory as i128) * weight as i128 / PERCENTAGE_PRECISION_I64 as i128;
             }
 
-            let price = prices[constituent_index] as i128;
+            let price = prices[i] as i128;
             let target_weight = target_amount
                 .saturating_mul(price)
                 .saturating_div(aum.max(1) as i128);
 
             // PERCENTAGE_PRECISION capped
             let weight_datum = (target_weight).min(PERCENTAGE_PRECISION_I128);
 
-            self.data.push(WeightDatum {
-                constituent_index: constituent_index as u16,
-                padding: [0; 6],
-                data: weight_datum as i64,
-                last_slot: slot,
-            });
+            let cell = self.get_mut(*constituent_index as u32);
+            cell.constituent_index = *constituent_index;
+            cell.padding = [0; 6];
+            cell.data = weight_datum as i64;
+            cell.last_slot = slot;
         }
 
         Ok(())
     }
-
-    pub fn get_target_weight(&self, constituent_index: u16) -> DriftResult<i64> {
-        let weight_datum = self
-            .data
-            .iter()
-            .find(|d| d.constituent_index == constituent_index)
-            .expect("missing target weight for this constituent");
-        Ok(weight_datum.data)
-    }
 }

programs/drift/src/state/lp_pool/tests.rs

@@ -4,10 +4,41 @@ mod tests {
     use crate::state::lp_pool::*;
     use crate::state::oracle::OracleSource;
     use crate::state::spot_market::SpotBalanceType;
+    use crate::state::zero_copy::ZeroCopyLoader;
     use anchor_lang::prelude::Pubkey;
 
     const PERCENTAGE_PRECISION_I64: i64 = 1_000_000;
 
+    fn constituent_target_weights_zc(
+    ) -> AccountZeroCopyMut<WeightDatum, ConstituentTargetWeightsFixed> {
+        let disc = ConstituentTargetWeights::discriminator();
+        let fixed = ConstituentTargetWeightsFixed { len: 1 };
+        let mut buf = Vec::new();
+        buf.extend_from_slice(&disc);
+        buf.extend_from_slice(bytemuck::bytes_of(&fixed));
+        buf.resize(buf.len() + std::mem::size_of::<WeightDatum>() * 1, 0);
+
+        // 2) wrap in AccountInfo
+        let mut lamports = 0u64;
+        let pubkey = Pubkey::default();
+        let owner = crate::ID;
+        let mut ai = AccountInfo::new(
+            &pubkey,
+            false,
+            true,
+            &mut lamports,
+            &mut buf,
+            &owner,
+            false,
+            0,
+        );
+
+        // 3) call your loader
+        let mut zc: AccountZeroCopyMut<WeightDatum, ConstituentTargetWeightsFixed> =
+            ai.load_zc_mut().unwrap();
+        zc
+    }
+
     fn weight_datum(constituent_index: u16, data: i64, last_slot: u64) -> WeightDatum {
         WeightDatum {
             constituent_index,
@@ -62,7 +93,7 @@ mod tests {
         let aum = 1_000_000;
         let now_ts = 1000;
 
-        let mut target = ConstituentTargetWeights::default();
+        let mut target = constituent_target_weights_zc();
         target
             .update_target_weights(
                 &mapping,
@@ -91,7 +122,7 @@ mod tests {
         let aum = 1_000_000;
         let now_ts = 1234;
 
-        let mut target = ConstituentTargetWeights::default();
+        let mut target = constituent_target_weights_zc();
         target
             .update_target_weights(
                 &mapping,
@@ -123,7 +154,7 @@ mod tests {
         let aum = 1_000_000;
         let now_ts = 999;
 
-        let mut target = ConstituentTargetWeights::default();
+        let mut target = constituent_target_weights_zc();
         target
             .update_target_weights(
                 &mapping,
@@ -180,7 +211,7 @@ mod tests {
 
         let amm_inventory = vec![(0, i64::MAX)];
         let prices = vec![u64::MAX];
-        let constituents = vec![dummy_constituent(0)];
+        let constituents = vec![0];
         let aum = 1;
         let now_ts = 222;
 

programs/drift/src/state/mod.rs

@@ -25,3 +25,4 @@ pub mod state;
 pub mod traits;
 pub mod user;
 pub mod user_map;
+pub mod zero_copy;