Formulaic k

programs/clearing_house/src/context.rs

@@ -851,6 +851,11 @@ pub struct UpdateFundingRate<'info> {
         constraint = &state.funding_rate_history.eq(&funding_rate_history.key())
     )]
     pub funding_rate_history: AccountLoader<'info, FundingRateHistory>,
+    #[account(
+        mut,
+        constraint = &state.extended_curve_history.eq(&extended_curve_history.key())
+    )]
+    pub extended_curve_history: AccountLoader<'info, ExtendedCurveHistory>,
 }
 
 #[derive(Accounts)]

programs/clearing_house/src/controller/amm.rs

@@ -1,12 +1,17 @@
 use solana_program::msg;
 
+use crate::controller::repeg::apply_cost_to_market;
 use crate::error::{ClearingHouseResult, ErrorCode};
 use crate::math::amm::calculate_quote_asset_amount_swapped;
 use crate::math::casting::{cast, cast_to_i128};
 use crate::math::constants::PRICE_TO_PEG_PRECISION_RATIO;
-use crate::math::{amm, bn, quote_asset::*};
+use crate::math::{amm, bn, quote_asset::*, repeg};
 use crate::math_error;
-use crate::state::market::AMM;
+use crate::state::history::curve::{ExtendedCurveHistory, ExtendedCurveRecord};
+use crate::state::market::{Market, OraclePriceData, AMM};
+use std::cell::RefMut;
+
+use std::cmp::{max, min};
 
 #[derive(Clone, Copy, PartialEq)]
 pub enum SwapDirection {
@@ -92,6 +97,100 @@ pub fn move_price(
     Ok(())
 }
 
+pub fn formulaic_k(
+    market: &mut Market,
+    mark_price: u128,
+    oracle_price_data: &OraclePriceData,
+    is_oracle_valid: bool,
+    funding_imbalance_cost: i128,
+    curve_history: Option<&mut RefMut<ExtendedCurveHistory>>,
+    now: i64,
+    market_index: u64,
+    trade_record: Option<u128>,
+) -> ClearingHouseResult {
+    let peg_multiplier_before = market.amm.peg_multiplier;
+    let base_asset_reserve_before = market.amm.base_asset_reserve;
+    let quote_asset_reserve_before = market.amm.quote_asset_reserve;
+    let sqrt_k_before = market.amm.sqrt_k;
+
+    // calculate budget
+    let budget = if funding_imbalance_cost < 0 {
+        // negative cost is period revenue, give back half in k increase
+        funding_imbalance_cost
+            .checked_div(2)
+            .ok_or_else(math_error!())?
+    } else if market.amm.net_revenue_since_last_funding < (funding_imbalance_cost as i64) {
+        // cost exceeded period revenue, take back half in k decrease
+        max(0, market.amm.net_revenue_since_last_funding)
+            .checked_sub(funding_imbalance_cost as i64)
+            .ok_or_else(math_error!())?
+            .checked_div(2)
+            .ok_or_else(math_error!())? as i128
+    } else {
+        0
+    };
+
+    if budget != 0 && curve_history.is_some() {
+        let curve_history = curve_history.unwrap();
+
+        // single k scale is capped by .1% increase and .09% decrease (regardless of budget)
+        let (p_numer, p_denom) = amm::calculate_budgeted_k_scale(market, budget)?;
+
+        if p_numer > p_denom {
+            msg!("increase sqrt_k (* {:?}/{:?})", p_numer, p_denom);
+        } else if p_numer < p_denom {
+            msg!("decrease sqrt_k (* {:?}/{:?})", p_numer, p_denom);
+        }
+
+        let new_sqrt_k = market
+            .amm
+            .sqrt_k
+            .checked_mul(p_numer)
+            .ok_or_else(math_error!())?
+            .checked_div(p_denom)
+            .ok_or_else(math_error!())?;
+
+        let (adjust_k_market, adjustment_cost) =
+            amm::adjust_k_cost(market, bn::U256::from(new_sqrt_k))?;
+        let cost_applied = apply_cost_to_market(market, adjustment_cost)?;
+        if cost_applied {
+            // todo: do actual k adj here
+            amm::update_k(market, bn::U256::from(new_sqrt_k))?;
+
+            let peg_multiplier_after = market.amm.peg_multiplier;
+            let base_asset_reserve_after = market.amm.base_asset_reserve;
+            let quote_asset_reserve_after = market.amm.quote_asset_reserve;
+            let sqrt_k_after = market.amm.sqrt_k;
+
+            let record_id = curve_history.next_record_id();
+            curve_history.append(ExtendedCurveRecord {
+                ts: now,
+                record_id,
+                market_index,
+                peg_multiplier_before,
+                base_asset_reserve_before,
+                quote_asset_reserve_before,
+                sqrt_k_before,
+                peg_multiplier_after,
+                base_asset_reserve_after,
+                quote_asset_reserve_after,
+                sqrt_k_after,
+                base_asset_amount_long: market.base_asset_amount_long.unsigned_abs(),
+                base_asset_amount_short: market.base_asset_amount_short.unsigned_abs(),
+                base_asset_amount: market.base_asset_amount,
+                open_interest: market.open_interest,
+                total_fee: market.amm.total_fee,
+                total_fee_minus_distributions: market.amm.total_fee_minus_distributions,
+                adjustment_cost,
+                oracle_price: oracle_price_data.price,
+                trade_record: trade_record.unwrap_or(0),
+                padding: [0; 5],
+            });
+        }
+    }
+    Ok(())
+}
+
 #[allow(dead_code)]
 pub fn move_to_price(amm: &mut AMM, target_price: u128) -> ClearingHouseResult {
     let sqrt_k = bn::U256::from(amm.sqrt_k);

programs/clearing_house/src/controller/funding.rs

@@ -4,6 +4,9 @@ use std::cmp::{max, min};
 use anchor_lang::prelude::*;
 
 use crate::error::*;
+
+use crate::controller::amm::formulaic_k;
+
 use crate::math::amm;
 use crate::math::amm::normalise_oracle_price;
 use crate::math::casting::{cast, cast_to_i128};
@@ -14,6 +17,7 @@ use crate::math::constants::{
 use crate::math::funding::{calculate_funding_payment, calculate_funding_rate_long_short};
 use crate::math::oracle;
 use crate::math_error;
+use crate::state::history::curve::ExtendedCurveHistory;
 use crate::state::history::funding_payment::{FundingPaymentHistory, FundingPaymentRecord};
 use crate::state::history::funding_rate::{FundingRateHistory, FundingRateRecord};
 use crate::state::market::AMM;
@@ -93,6 +97,7 @@ pub fn update_funding_rate(
     now: UnixTimestamp,
     clock_slot: u64,
     funding_rate_history: &mut RefMut<FundingRateHistory>,
+    curve_history: Option<&mut RefMut<ExtendedCurveHistory>>,
     guard_rails: &OracleGuardRails,
     funding_paused: bool,
     precomputed_mark_price: Option<u128>,
@@ -101,16 +106,21 @@ pub fn update_funding_rate(
         .checked_sub(market.amm.last_funding_rate_ts)
         .ok_or_else(math_error!())?;
 
+    let mark_price = match precomputed_mark_price {
+        Some(mark_price) => mark_price,
+        None => market.amm.mark_price()?,
+    };
+
     // Pause funding if oracle is invalid or if mark/oracle spread is too divergent
     let (block_funding_rate_update, oracle_price_data) = oracle::block_operation(
         &market.amm,
         price_oracle,
         clock_slot,
         guard_rails,
-        precomputed_mark_price,
+        Some(mark_price),
     )?;
     let normalised_oracle_price =
-        normalise_oracle_price(&market.amm, &oracle_price_data, precomputed_mark_price)?;
+        normalise_oracle_price(&market.amm, &oracle_price_data, Some(mark_price))?;
 
     // round next update time to be available on the hour
     let mut next_update_wait = market.amm.funding_period;
@@ -174,6 +184,27 @@ pub fn update_funding_rate(
         let (funding_rate_long, funding_rate_short) =
             calculate_funding_rate_long_short(market, funding_rate)?;
 
+        // dynamic k
+        let funding_imbalance_cost = funding_rate
+            .checked_mul(market.base_asset_amount)
+            .ok_or_else(math_error!())?
+            .checked_div(
+                AMM_TO_QUOTE_PRECISION_RATIO_I128 * cast_to_i128(FUNDING_PAYMENT_PRECISION)?,
+            )
+            .ok_or_else(math_error!())?;
+
+        formulaic_k(
+            market,
+            mark_price,
+            &oracle_price_data,
+            true, // only way to have gotten here
+            funding_imbalance_cost,
+            curve_history,
+            now,
+            market_index,
+            None,
+        )?;
+
         market.amm.cumulative_funding_rate_long = market
             .amm
             .cumulative_funding_rate_long

programs/clearing_house/src/controller/orders.rs

@@ -800,23 +800,24 @@ pub fn fill_order(
         let funding_rate_history = &mut funding_rate_history
             .load_mut()
             .or(Err(ErrorCode::UnableToLoadAccountLoader))?;
+        let extended_curve_history = &mut extended_curve_history
+            .load_mut()
+            .or(Err(ErrorCode::UnableToLoadAccountLoader))?;
         controller::funding::update_funding_rate(
             market_index,
             market,
             oracle,
             now,
             clock_slot,
             funding_rate_history,
+            Some(extended_curve_history),
             &state.oracle_guard_rails,
             state.funding_paused,
             Some(mark_price_before),
         )?;
 
         // if market_index >= 12 {
         // todo for soft launch
-        let extended_curve_history = &mut extended_curve_history
-            .load_mut()
-            .or(Err(ErrorCode::UnableToLoadAccountLoader))?;
 
         controller::repeg::formulaic_repeg(
             market,

programs/clearing_house/src/controller/repeg.rs

@@ -89,9 +89,9 @@ pub fn formulaic_repeg(
 ) -> ClearingHouseResult<i128> {
     // backrun market swaps to do automatic on-chain repeg
 
-    if !is_oracle_valid || oracle_price_data.delay > 5 {
+    if !is_oracle_valid {
         msg!(
-            "invalid oracle (oracle delay = {:?})",
+            "skipping formulaic_repeg: invalid oracle (oracle delay = {:?})",
             oracle_price_data.delay
         );
         return Ok(0);
@@ -115,7 +115,7 @@ pub fn formulaic_repeg(
         terminal_quote_reserves,
         repeg_budget,
         mark_price,
-        cast_to_u128(oracle_price_data.price)?,
+        oracle_price_data,
     )?;
 
     let (
@@ -172,7 +172,7 @@ pub fn formulaic_repeg(
     Ok(adjustment_cost)
 }
 
-fn apply_cost_to_market(market: &mut Market, cost: i128) -> ClearingHouseResult<bool> {
+pub fn apply_cost_to_market(market: &mut Market, cost: i128) -> ClearingHouseResult<bool> {
     // positive cost is expense, negative cost is revenue
     // Reduce pnl to quote asset precision and take the absolute value
     if cost > 0 {

programs/clearing_house/src/lib.rs

@@ -765,6 +765,7 @@ pub mod clearing_house {
                 now,
                 clock_slot,
                 funding_rate_history,
+                None,
                 &ctx.accounts.state.oracle_guard_rails,
                 ctx.accounts.state.funding_paused,
                 Some(mark_price_before),
@@ -959,6 +960,7 @@ pub mod clearing_house {
             now,
             clock_slot,
             funding_rate_history,
+            None,
             &ctx.accounts.state.oracle_guard_rails,
             ctx.accounts.state.funding_paused,
             Some(mark_price_before),
@@ -2079,13 +2081,20 @@ pub mod clearing_house {
         let clock_slot = clock.slot;
 
         let funding_rate_history = &mut ctx.accounts.funding_rate_history.load_mut()?;
+        let extended_curve_history = &mut ctx
+            .accounts
+            .extended_curve_history
+            .load_mut()
+            .or(Err(ErrorCode::UnableToLoadAccountLoader))?;
+
         controller::funding::update_funding_rate(
             market_index,
             market,
             price_oracle,
             now,
             clock_slot,
             funding_rate_history,
+            Some(extended_curve_history),
             &ctx.accounts.state.oracle_guard_rails,
             ctx.accounts.state.funding_paused,
             None,
@@ -2123,7 +2132,12 @@ pub mod clearing_house {
         let quote_asset_reserve_before = market.amm.quote_asset_reserve;
         let sqrt_k_before = market.amm.sqrt_k;
 
-        let adjustment_cost = math::amm::adjust_k_cost(market, bn::U256::from(sqrt_k))?;
+        let new_sqrt_k_U256 = bn::U256::from(sqrt_k);
+
+        let (mut adjust_k_market, adjustment_cost) =
+            math::amm::adjust_k_cost(market, new_sqrt_k_U256)?;
+
+        math::amm::update_k(market, new_sqrt_k_U256);
 
         if adjustment_cost > 0 {
             let max_cost = market