Add a delay before TWAP starts getting recorded (#264)

* added twap_start_delay_slots field to dao, implemented into update_twap

* validate twap_start_delay_slots matches dao config on proposal create

* update sdk with new twapStartDelaySlots

* added slot calc utils

* update existing tests to account for new twapStartDelaySlots

* update devnet script to account for new twapStartDelaySlots

* add specific twap delay tests

* account for twapStartDelaySlots

* twap integration test

* test twap expected value

* bump sdk version

* v0.4.0-alpha.53

* Update package version

* Have TWAP delay update the latest observation, just not aggregator

---------

Co-authored-by: metaproph3t <metaproph3t@protonmail.com>

Author: suite

package.json

@@ -7,7 +7,7 @@
     },
     "dependencies": {
         "@coral-xyz/anchor": "0.29.0",
-        "@metadaoproject/futarchy": "0.4.0-alpha.51",
+        "@metadaoproject/futarchy": "0.4.0-alpha.53",
         "@metaplex-foundation/mpl-token-metadata": "^3.2.0",
         "@metaplex-foundation/umi": "^0.9.1",
         "@metaplex-foundation/umi-bundle-defaults": "^0.9.1",

programs/amm/src/instructions/create_amm.rs

@@ -11,6 +11,7 @@ use crate::events::{CommonFields, CreateAmmEvent};
 pub struct CreateAmmArgs {
     pub twap_initial_observation: u128,
     pub twap_max_observation_change_per_update: u128,
+    pub twap_start_delay_slots: u64,
 }
 
 #[event_cpi]
@@ -94,6 +95,7 @@ impl CreateAmm<'_> {
         let CreateAmmArgs {
             twap_initial_observation,
             twap_max_observation_change_per_update,
+            twap_start_delay_slots,
         } = args;
 
         amm.set_inner(Amm {
@@ -115,6 +117,7 @@ impl CreateAmm<'_> {
                 current_slot,
                 twap_initial_observation,
                 twap_max_observation_change_per_update,
+                twap_start_delay_slots,
             ),
 
             seq_num: 0,

programs/amm/src/state/amm.rs

@@ -44,13 +44,16 @@ pub struct TwapOracle {
     pub max_observation_change_per_update: u128,
     /// What the initial `latest_observation` is set to.
     pub initial_observation: u128,
+    /// Number of slots after amm.created_at_slot to start recording TWAP
+    pub start_delay_slots: u64,
 }
 
 impl TwapOracle {
     pub fn new(
         current_slot: Slot,
         initial_observation: u128,
         max_observation_change_per_update: u128,
+        start_delay_slots: u64,
     ) -> Self {
         Self {
             last_updated_slot: current_slot,
@@ -59,6 +62,7 @@ impl TwapOracle {
             aggregator: 0,
             max_observation_change_per_update,
             initial_observation,
+            start_delay_slots,
         }
     }
 }
@@ -163,9 +167,12 @@ impl Amm {
         ((lp_tokens as u128 * self.quote_amount as u128) / lp_total_supply as u128) as u64
     }
 
-    /// Returns the time-weighted average price since market creation in UQ64x32 form.
+    /// Returns the time-weighted average price since market creation
     pub fn get_twap(&self) -> Result<u128> {
-        let slots_passed = (self.oracle.last_updated_slot - self.created_at_slot) as u128;
+        let start_slot = self.created_at_slot + self.oracle.start_delay_slots;
+
+        require_gt!(self.oracle.last_updated_slot, start_slot, AmmError::NoSlotsPassed);
+        let slots_passed = (self.oracle.last_updated_slot - start_slot) as u128;
 
         require_neq!(slots_passed, 0, AmmError::NoSlotsPassed);
         require!(self.oracle.aggregator != 0, AmmError::AssertFailed);
@@ -179,6 +186,7 @@ impl Amm {
     /// Returns an observation if one was recorded.
     pub fn update_twap(&mut self, current_slot: Slot) -> Result<Option<u128>> {
         let oracle = &mut self.oracle;
+
         // a manipulator is likely to be "bursty" with their usage, such as a
         // validator who abuses their slots to manipulate the TWAP.
         // meanwhile, regular trading is less likely to happen in each slot.
@@ -228,22 +236,35 @@ impl Amm {
             max(price, min_observation)
         };
 
-        let slot_difference = (current_slot - oracle.last_updated_slot) as u128;
+        // if the start delay hasn't passed, we don't update the aggregator
+        // but we still update the observation
+        let twap_start_slot = self.created_at_slot + oracle.start_delay_slots;
+
+        let new_aggregator = if current_slot <= twap_start_slot {
+            oracle.aggregator
+        } else {
+            // so that we don't act as if the first update ocurred over the whole
+            // pre-start delay period
+            let effective_last_updated_slot = oracle.last_updated_slot.max(twap_start_slot);
+
+            let slot_difference = (current_slot - effective_last_updated_slot) as u128;
 
-        // if this saturates, the aggregator will wrap back to 0, so this value doesn't
-        // really matter. we just can't panic.
-        let weighted_observation = new_observation.saturating_mul(slot_difference);
+            // if this saturates, the aggregator will wrap back to 0, so this value doesn't
+            // really matter. we just can't panic.
+            let weighted_observation = new_observation.saturating_mul(slot_difference);
 
-        let new_aggregator = oracle.aggregator.wrapping_add(weighted_observation);
+            oracle.aggregator.wrapping_add(weighted_observation)
+        };
 
         let new_oracle = TwapOracle {
             last_updated_slot: current_slot,
             last_price: price,
             last_observation: new_observation,
             aggregator: new_aggregator,
-            // these two shouldn't change
+            // these three shouldn't change
             max_observation_change_per_update: oracle.max_observation_change_per_update,
             initial_observation: oracle.initial_observation,
+            start_delay_slots: oracle.start_delay_slots,
         };
 
         require!(

programs/autocrat/src/error.rs

@@ -10,6 +10,8 @@ pub enum AutocratError {
         "An amm has a `max_observation_change_per_update` that doesn't match the `dao`'s config"
     )]
     InvalidMaxObservationChange,
+    #[msg("An amm has a `start_delay_slots` that doesn't match the `dao`'s config")]
+    InvalidStartDelaySlots,
     #[msg("One of the vaults has an invalid `settlement_authority`")]
     InvalidSettlementAuthority,
     #[msg("Proposal is too young to be executed or rejected")]

programs/autocrat/src/instructions/initialize_dao.rs

@@ -4,6 +4,7 @@ use super::*;
 pub struct InitializeDaoParams {
     pub twap_initial_observation: u128,
     pub twap_max_observation_change_per_update: u128,
+    pub twap_start_delay_slots: u64,
     pub min_quote_futarchic_liquidity: u64,
     pub min_base_futarchic_liquidity: u64,
     pub pass_threshold_bps: Option<u16>,
@@ -33,6 +34,7 @@ impl InitializeDao<'_> {
         let InitializeDaoParams {
             twap_initial_observation,
             twap_max_observation_change_per_update,
+            twap_start_delay_slots,
             min_base_futarchic_liquidity,
             min_quote_futarchic_liquidity,
             pass_threshold_bps,
@@ -54,6 +56,7 @@ impl InitializeDao<'_> {
             slots_per_proposal: slots_per_proposal.unwrap_or(THREE_DAYS_IN_SLOTS),
             twap_initial_observation,
             twap_max_observation_change_per_update,
+            twap_start_delay_slots,
             min_base_futarchic_liquidity,
             min_quote_futarchic_liquidity,
             seq_num: 0,

programs/autocrat/src/instructions/initialize_proposal.rs

@@ -106,6 +106,12 @@ impl InitializeProposal<'_> {
                 self.dao.twap_max_observation_change_per_update,
                 AutocratError::InvalidMaxObservationChange
             );
+
+            require_eq!(
+                amm.oracle.start_delay_slots,
+                self.dao.twap_start_delay_slots,
+                AutocratError::InvalidStartDelaySlots
+            );
         }
 
         // Should never be the case because the oracle is the proposal account, and you can't re-initialize a proposal

programs/autocrat/src/lib.rs

@@ -64,7 +64,8 @@ security_txt! {
 declare_id!("autowMzCbM29YXMgVG3T62Hkgo7RcyrvgQQkd54fDQL");
 
 pub const SLOTS_PER_10_SECS: u64 = 25;
-pub const THREE_DAYS_IN_SLOTS: u64 = 3 * 24 * 60 * 6 * SLOTS_PER_10_SECS;
+pub const DAY_IN_SLOTS: u64 = 24 * 60 * 6 * SLOTS_PER_10_SECS;
+pub const THREE_DAYS_IN_SLOTS: u64 = 3 * DAY_IN_SLOTS;
 
 pub const TEN_DAYS_IN_SECONDS: i64 = 10 * 24 * 60 * 60;
 

programs/autocrat/src/state/dao.rs

@@ -27,6 +27,8 @@ pub struct Dao {
     /// in 50 minutes.
     pub twap_initial_observation: u128,
     pub twap_max_observation_change_per_update: u128,
+    /// Forces TWAP calculation to start after amm.created_at_slot + twap_start_delay_slots
+    pub twap_start_delay_slots: u64,
     /// As an anti-spam measure and to help liquidity, you need to lock up some liquidity
     /// in both futarchic markets in order to create a proposal.
     ///

programs/launchpad/src/instructions/complete_launch.rs

@@ -22,6 +22,7 @@ use raydium_cpmm_cpi::{
 
 use autocrat::program::Autocrat;
 use autocrat::InitializeDaoParams;
+use autocrat::{DAY_IN_SLOTS};
 
 pub const PRICE_SCALE: u128 = 1_000_000_000_000;
 
@@ -287,7 +288,8 @@ impl CompleteLaunch<'_> {
                     min_quote_futarchic_liquidity: total_committed_amount / 100,
                     min_base_futarchic_liquidity: AVAILABLE_TOKENS / 100,
                     pass_threshold_bps: None,
-                    slots_per_proposal: None,
+                    slots_per_proposal: Some(3 * DAY_IN_SLOTS),
+                    twap_start_delay_slots: DAY_IN_SLOTS,
                 },
             )?;
 

scripts/setupDevnet.ts

@@ -144,7 +144,7 @@ async function main() {
   let storedAmm: Amm | null = await ammProgram.fetchAmm(amm);
   console.log(storedAmm);
   if (!storedAmm) {
-    await ammProgram.initializeAmmIx(pUp, pDown, new BN(0), new BN(0)).rpc();
+    await ammProgram.initializeAmmIx(pUp, pDown, new BN(0), new BN(0), new BN(0)).rpc();
     storedAmm = await ammProgram.fetchAmm(amm);
   }