Merge pull request #6 from AdrenaDEX/feat/get_lp_price

Implement get_lp_token_price view instruction

Author: askibin

programs/perpetuals/src/instructions.rs

@@ -26,6 +26,7 @@ pub mod get_entry_price_and_fee;
 pub mod get_exit_price_and_fee;
 pub mod get_liquidation_price;
 pub mod get_liquidation_state;
+pub mod get_lp_token_price;
 pub mod get_oracle_price;
 pub mod get_pnl;
 pub mod get_remove_liquidity_amount_and_fee;
@@ -41,7 +42,7 @@ pub use {
     add_collateral::*, add_custody::*, add_liquidity::*, add_pool::*, close_position::*,
     get_add_liquidity_amount_and_fee::*, get_assets_under_management::*,
     get_entry_price_and_fee::*, get_exit_price_and_fee::*, get_liquidation_price::*,
-    get_liquidation_state::*, get_oracle_price::*, get_pnl::*,
+    get_liquidation_state::*, get_lp_token_price::*, get_oracle_price::*, get_pnl::*,
     get_remove_liquidity_amount_and_fee::*, get_swap_amount_and_fees::*, init::*, liquidate::*,
     open_position::*, remove_collateral::*, remove_custody::*, remove_liquidity::*, remove_pool::*,
     set_admin_signers::*, set_custody_config::*, set_permissions::*, set_test_oracle_price::*,

programs/perpetuals/src/instructions/get_lp_token_price.rs

@@ -0,0 +1,76 @@
+//! GetLpTokenPrice instruction handler
+
+use {
+    crate::{
+        math,
+        state::{
+            perpetuals::Perpetuals,
+            pool::{AumCalcMode, Pool},
+        },
+    },
+    anchor_lang::prelude::*,
+    anchor_spl::token::Mint,
+    num_traits::Zero,
+};
+
+#[derive(Accounts)]
+pub struct GetLpTokenPrice<'info> {
+    #[account(
+        seeds = [b"perpetuals"],
+        bump = perpetuals.perpetuals_bump
+    )]
+    pub perpetuals: Box<Account<'info, Perpetuals>>,
+
+    #[account(
+        seeds = [b"pool",
+                 pool.name.as_bytes()],
+        bump = pool.bump
+    )]
+    pub pool: Box<Account<'info, Pool>>,
+
+    #[account(
+        seeds = [b"lp_token_mint",
+                 pool.key().as_ref()],
+        bump = pool.lp_token_bump
+    )]
+    pub lp_token_mint: Box<Account<'info, Mint>>,
+    // remaining accounts:
+    //   pool.tokens.len() custody accounts (read-only, unsigned)
+    //   pool.tokens.len() custody oracles (read-only, unsigned)
+}
+
+#[derive(AnchorSerialize, AnchorDeserialize)]
+pub struct GetLpTokenPriceParams {}
+
+pub fn get_lp_token_price(
+    ctx: Context<GetLpTokenPrice>,
+    _params: &GetLpTokenPriceParams,
+) -> Result<u64> {
+    let aum_usd = math::checked_as_u64(ctx.accounts.pool.get_assets_under_management_usd(
+        AumCalcMode::EMA,
+        ctx.remaining_accounts,
+        ctx.accounts.perpetuals.get_time()?,
+    )?)?;
+
+    msg!("aum_usd: {}", aum_usd);
+
+    let lp_supply = ctx.accounts.lp_token_mint.supply;
+
+    msg!("lp_supply: {}", lp_supply);
+
+    if lp_supply.is_zero() {
+        return Ok(0);
+    }
+
+    let price_usd = math::checked_decimal_div(
+        aum_usd,
+        -(Perpetuals::USD_DECIMALS as i32),
+        lp_supply,
+        -(Perpetuals::LP_DECIMALS as i32),
+        -(Perpetuals::USD_DECIMALS as i32),
+    )?;
+
+    msg!("price_usd: {}", price_usd);
+
+    Ok(price_usd)
+}

programs/perpetuals/src/lib.rs

@@ -231,4 +231,11 @@ pub mod perpetuals {
     ) -> Result<u128> {
         instructions::get_assets_under_management(ctx, &params)
     }
+
+    pub fn get_lp_token_price(
+        ctx: Context<GetLpTokenPrice>,
+        params: GetLpTokenPriceParams,
+    ) -> Result<u64> {
+        instructions::get_lp_token_price(ctx, &params)
+    }
 }

programs/perpetuals/src/math.rs

@@ -353,6 +353,19 @@ where
     }
 }
 
+pub fn checked_as_f64<T>(arg: T) -> Result<f64>
+where
+    T: Display + num_traits::ToPrimitive + Clone,
+{
+    let option: Option<f64> = num_traits::NumCast::from(arg.clone());
+    if let Some(res) = option {
+        Ok(res)
+    } else {
+        msg!("Error: Overflow in {} as f64", arg);
+        err!(PerpetualsError::MathOverflow)
+    }
+}
+
 pub fn scale_to_exponent(arg: u64, exponent: i32, target_exponent: i32) -> Result<u64> {
     if target_exponent == exponent {
         return Ok(arg);
@@ -366,7 +379,10 @@ pub fn scale_to_exponent(arg: u64, exponent: i32, target_exponent: i32) -> Resul
 }
 
 pub fn to_ui_amount(amount: u64, decimals: u8) -> Result<f64> {
-    checked_float_div(amount as f64, checked_powi(10.0, decimals as i32)?)
+    checked_float_div(
+        checked_as_f64(amount)?,
+        checked_powi(10.0, decimals as i32)?,
+    )
 }
 
 pub fn to_token_amount(ui_amount: f64, decimals: u8) -> Result<u64> {
@@ -375,3 +391,69 @@ pub fn to_token_amount(ui_amount: f64, decimals: u8) -> Result<u64> {
         checked_powi(10.0, decimals as i32)?,
     )?)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_checked_decimal_div_ok() {
+        // Nominal test
+        assert_eq!(
+            2_000_000,
+            checked_decimal_div(1_000, -6, 500, -6, -6).unwrap()
+        );
+
+        // Different exponents
+        assert_eq!(
+            2_000_000_000,
+            checked_decimal_div(1_000, -6, 500, -9, -6).unwrap()
+        );
+
+        // Different exponents
+        assert_eq!(2_000, checked_decimal_div(1_000, -9, 500, -6, -6).unwrap());
+
+        // MAX coefficient values
+        assert_eq!(
+            1_000_000,
+            checked_decimal_div(u64::MAX, -6, u64::MAX, -6, -6).unwrap()
+        );
+
+        assert_eq!(0, checked_decimal_div(0, -6, u64::MAX, -6, -6).unwrap());
+
+        // Maximum coefficients delta depends on target exponent
+        assert_eq!(
+            18_446_744_073_709_000_000,
+            checked_decimal_div(
+                checked_div(u64::MAX, checked_pow(10u64, 6).unwrap()).unwrap(),
+                -6,
+                1,
+                -6,
+                -6,
+            )
+            .unwrap()
+        );
+
+        // Maximum coefficients delta depends on target exponent
+        assert_eq!(
+            18_446_744_073_000_000_000,
+            checked_decimal_div(
+                checked_div(u64::MAX, checked_pow(10u64, 9).unwrap()).unwrap(),
+                -6,
+                1,
+                -6,
+                -9,
+            )
+            .unwrap()
+        );
+    }
+
+    #[test]
+    fn test_checked_decimal_div_ko() {
+        // Division by zero
+        assert!(checked_decimal_div(1_000_000, -6, 0, -6, -6).is_err());
+
+        // Overflowing result
+        assert!(checked_decimal_div(u64::MAX, -6, 1, -6, -6).is_err());
+    }
+}

programs/perpetuals/src/state/oracle.rs

@@ -186,7 +186,10 @@ impl OraclePrice {
     }
 
     pub fn checked_as_f64(&self) -> Result<f64> {
-        math::checked_float_mul(self.price as f64, math::checked_powi(10.0, self.exponent)?)
+        math::checked_float_mul(
+            math::checked_as_f64(self.price)?,
+            math::checked_powi(10.0, self.exponent)?,
+        )
     }
 
     // private helpers

programs/perpetuals/tests/native/instructions/mod.rs

@@ -2,6 +2,7 @@ pub mod test_add_custody;
 pub mod test_add_liquidity;
 pub mod test_add_pool;
 pub mod test_close_position;
+pub mod test_get_lp_token_price;
 pub mod test_init;
 pub mod test_liquidate;
 pub mod test_open_position;
@@ -12,6 +13,7 @@ pub mod test_swap;
 
 pub use {
     test_add_custody::*, test_add_liquidity::*, test_add_pool::*, test_close_position::*,
-    test_init::*, test_liquidate::*, test_open_position::*, test_remove_liquidity::*,
-    test_set_custody_config::*, test_set_test_oracle_price::*, test_swap::*,
+    test_get_lp_token_price::*, test_init::*, test_liquidate::*, test_open_position::*,
+    test_remove_liquidity::*, test_set_custody_config::*, test_set_test_oracle_price::*,
+    test_swap::*,
 };

programs/perpetuals/tests/native/instructions/test_get_lp_token_price.rs

@@ -0,0 +1,69 @@
+use {
+    crate::utils::{self, pda},
+    anchor_lang::{prelude::Pubkey, ToAccountMetas},
+    perpetuals::{
+        instructions::GetLpTokenPriceParams,
+        state::{custody::Custody, pool::Pool},
+    },
+    solana_program::instruction::AccountMeta,
+    solana_program_test::{BanksClientError, ProgramTestContext},
+    solana_sdk::signer::keypair::Keypair,
+};
+
+#[allow(clippy::too_many_arguments)]
+pub async fn test_get_lp_token_price(
+    program_test_ctx: &mut ProgramTestContext,
+    payer: &Keypair,
+    pool_pda: &Pubkey,
+    lp_token_mint_pda: &Pubkey,
+) -> std::result::Result<u64, BanksClientError> {
+    // ==== WHEN ==============================================================
+    let perpetuals_pda = pda::get_perpetuals_pda().0;
+
+    let accounts_meta = {
+        let accounts = perpetuals::accounts::GetLpTokenPrice {
+            perpetuals: perpetuals_pda,
+            pool: *pool_pda,
+            lp_token_mint: *lp_token_mint_pda,
+        };
+
+        let mut accounts_meta = accounts.to_account_metas(None);
+
+        let pool_account = utils::get_account::<Pool>(program_test_ctx, *pool_pda).await;
+
+        // For each token, add custody account as remaining_account
+        for custody in &pool_account.custodies {
+            accounts_meta.push(AccountMeta {
+                pubkey: *custody,
+                is_signer: false,
+                is_writable: false,
+            });
+        }
+
+        // For each token, add custody oracle account as remaining_account
+        for custody in &pool_account.custodies {
+            let custody_account = utils::get_account::<Custody>(program_test_ctx, *custody).await;
+
+            accounts_meta.push(AccountMeta {
+                pubkey: custody_account.oracle.oracle_account,
+                is_signer: false,
+                is_writable: false,
+            });
+        }
+
+        accounts_meta
+    };
+
+    let result: u64 = utils::create_and_simulate_perpetuals_view_ix(
+        program_test_ctx,
+        accounts_meta,
+        perpetuals::instruction::GetLpTokenPrice {
+            params: GetLpTokenPriceParams {},
+        },
+        payer,
+    )
+    .await?;
+
+    // ==== THEN ==============================================================
+    Ok(result)
+}

programs/perpetuals/tests/native/main.rs

@@ -15,4 +15,6 @@ pub async fn test_integration() {
     tests_suite::position::min_max_leverage().await;
     tests_suite::position::liquidate_position().await;
     tests_suite::position::max_user_profit().await;
+
+    tests_suite::lp_token::lp_token_price().await;
 }