Convert fees to collateral custody token (#15)

Author: askibin

Cargo.toml

@@ -2,3 +2,12 @@
 members = [
     "programs/*"
 ]
+
+[profile.release]
+overflow-checks = true
+lto = "fat"
+codegen-units = 1
+[profile.release.build-override]
+opt-level = 3
+incremental = false
+codegen-units = 1

programs/perpetuals/Cargo.toml

@@ -22,11 +22,6 @@ cpi = ["no-entrypoint"]
 test = []
 default = []
 
-[profile.release]
-lto = true
-codegen-units = 1
-overflow-checks = true
-
 [dependencies]
 anchor-lang = {version = "0.26.0", features = ["init-if-needed"]}
 anchor-spl = "0.26.0"

programs/perpetuals/src/instructions/close_position.rs

@@ -167,7 +167,7 @@ pub fn close_position(ctx: Context<ClosePosition>, params: &ClosePositionParams)
     }
 
     msg!("Settle position");
-    let (transfer_amount, fee_amount, profit_usd, loss_usd) = pool.get_close_amount(
+    let (transfer_amount, mut fee_amount, profit_usd, loss_usd) = pool.get_close_amount(
         position,
         &token_price,
         &token_ema_price,
@@ -179,7 +179,11 @@ pub fn close_position(ctx: Context<ClosePosition>, params: &ClosePositionParams)
         false,
     )?;
 
-    let protocol_fee = Pool::get_fee_amount(custody.fees.protocol_share, fee_amount)?;
+    let fee_amount_usd = token_ema_price.get_asset_amount_usd(fee_amount, custody.decimals)?;
+    if position.side == Side::Short || custody.is_virtual {
+        fee_amount = collateral_token_ema_price
+            .get_token_amount(fee_amount_usd, collateral_custody.decimals)?;
+    }
 
     msg!("Net profit: {}, loss: {}", profit_usd, loss_usd);
     msg!("Collected fee: {}", fee_amount);
@@ -212,10 +216,7 @@ pub fn close_position(ctx: Context<ClosePosition>, params: &ClosePositionParams)
     collateral_custody.collected_fees.close_position_usd = collateral_custody
         .collected_fees
         .close_position_usd
-        .wrapping_add(
-            collateral_token_ema_price
-                .get_asset_amount_usd(fee_amount, collateral_custody.decimals)?,
-        );
+        .wrapping_add(fee_amount_usd);
 
     if transfer_amount > position.collateral_amount {
         let amount_lost = transfer_amount.saturating_sub(position.collateral_amount);
@@ -230,6 +231,8 @@ pub fn close_position(ctx: Context<ClosePosition>, params: &ClosePositionParams)
         collateral_custody.assets.collateral,
         position.collateral_amount,
     )?;
+
+    let protocol_fee = Pool::get_fee_amount(custody.fees.protocol_share, fee_amount)?;
     collateral_custody.assets.protocol_fees =
         math::checked_add(collateral_custody.assets.protocol_fees, protocol_fee)?;
 

programs/perpetuals/src/instructions/get_entry_price_and_fee.rs

@@ -149,13 +149,19 @@ pub fn get_entry_price_and_fee(
         curtime,
     )?;
 
-    let fee = pool.get_entry_fee(
+    let mut fee = pool.get_entry_fee(
         custody.fees.open_position,
         params.size,
         locked_amount,
         collateral_custody,
     )?;
 
+    if params.side == Side::Short || custody.is_virtual {
+        let fee_amount_usd = token_ema_price.get_asset_amount_usd(fee, custody.decimals)?;
+        fee = collateral_token_ema_price
+            .get_token_amount(fee_amount_usd, collateral_custody.decimals)?;
+    }
+
     Ok(NewPositionPricesAndFee {
         entry_price,
         liquidation_price,

programs/perpetuals/src/instructions/get_exit_price_and_fee.rs

@@ -6,7 +6,7 @@ use {
         oracle::OraclePrice,
         perpetuals::{Perpetuals, PriceAndFee},
         pool::Pool,
-        position::Position,
+        position::{Position, Side},
     },
     anchor_lang::prelude::*,
 };
@@ -49,6 +49,20 @@ pub struct GetExitPriceAndFee<'info> {
         constraint = custody_oracle_account.key() == custody.oracle.oracle_account
     )]
     pub custody_oracle_account: AccountInfo<'info>,
+
+    #[account(
+        seeds = [b"custody",
+                 pool.key().as_ref(),
+                 collateral_custody.mint.as_ref()],
+        bump = collateral_custody.bump
+    )]
+    pub collateral_custody: Box<Account<'info, Custody>>,
+
+    /// CHECK: oracle account for the collateral token
+    #[account(
+        constraint = collateral_custody_oracle_account.key() == collateral_custody.oracle.oracle_account
+    )]
+    pub collateral_custody_oracle_account: AccountInfo<'info>,
 }
 
 #[derive(AnchorSerialize, AnchorDeserialize)]
@@ -63,6 +77,7 @@ pub fn get_exit_price_and_fee(
     let pool = &ctx.accounts.pool;
     let curtime = ctx.accounts.perpetuals.get_time()?;
     let custody = &ctx.accounts.custody;
+    let collateral_custody = &ctx.accounts.collateral_custody;
 
     let token_price = OraclePrice::new_from_oracle(
         &ctx.accounts.custody_oracle_account.to_account_info(),
@@ -78,11 +93,26 @@ pub fn get_exit_price_and_fee(
         custody.pricing.use_ema,
     )?;
 
+    let collateral_token_ema_price = OraclePrice::new_from_oracle(
+        &ctx.accounts
+            .collateral_custody_oracle_account
+            .to_account_info(),
+        &collateral_custody.oracle,
+        curtime,
+        collateral_custody.pricing.use_ema,
+    )?;
+
     let price = pool.get_exit_price(&token_price, &token_ema_price, position.side, custody)?;
 
     let size = token_ema_price.get_token_amount(position.size_usd, custody.decimals)?;
 
-    let fee = pool.get_exit_fee(size, custody)?;
+    let mut fee = pool.get_exit_fee(size, custody)?;
+
+    if position.side == Side::Short || custody.is_virtual {
+        let fee_amount_usd = token_ema_price.get_asset_amount_usd(fee, custody.decimals)?;
+        fee = collateral_token_ema_price
+            .get_token_amount(fee_amount_usd, collateral_custody.decimals)?;
+    }
 
     Ok(PriceAndFee { price, fee })
 }

programs/perpetuals/src/instructions/liquidate.rs

@@ -173,7 +173,7 @@ pub fn liquidate(ctx: Context<Liquidate>, _params: &LiquidateParams) -> Result<(
     );
 
     msg!("Settle position");
-    let (total_amount_out, fee_amount, profit_usd, loss_usd) = pool.get_close_amount(
+    let (total_amount_out, mut fee_amount, profit_usd, loss_usd) = pool.get_close_amount(
         position,
         &token_price,
         &token_ema_price,
@@ -185,7 +185,11 @@ pub fn liquidate(ctx: Context<Liquidate>, _params: &LiquidateParams) -> Result<(
         true,
     )?;
 
-    let protocol_fee = Pool::get_fee_amount(custody.fees.protocol_share, fee_amount)?;
+    let fee_amount_usd = token_ema_price.get_asset_amount_usd(fee_amount, custody.decimals)?;
+    if position.side == Side::Short || custody.is_virtual {
+        fee_amount = collateral_token_ema_price
+            .get_token_amount(fee_amount_usd, collateral_custody.decimals)?;
+    }
 
     msg!("Net profit: {}, loss: {}", profit_usd, loss_usd);
     msg!("Collected fee: {}", fee_amount);
@@ -233,10 +237,7 @@ pub fn liquidate(ctx: Context<Liquidate>, _params: &LiquidateParams) -> Result<(
     collateral_custody.collected_fees.liquidation_usd = collateral_custody
         .collected_fees
         .liquidation_usd
-        .wrapping_add(
-            collateral_token_ema_price
-                .get_asset_amount_usd(fee_amount, collateral_custody.decimals)?,
-        );
+        .wrapping_add(fee_amount_usd);
 
     if total_amount_out > position.collateral_amount {
         let amount_lost = total_amount_out.saturating_sub(position.collateral_amount);
@@ -251,6 +252,8 @@ pub fn liquidate(ctx: Context<Liquidate>, _params: &LiquidateParams) -> Result<(
         collateral_custody.assets.collateral,
         position.collateral_amount,
     )?;
+
+    let protocol_fee = Pool::get_fee_amount(custody.fees.protocol_share, fee_amount)?;
     collateral_custody.assets.protocol_fees =
         math::checked_add(collateral_custody.assets.protocol_fees, protocol_fee)?;
 

programs/perpetuals/src/instructions/open_position.rs

@@ -134,7 +134,8 @@ pub fn open_position(ctx: Context<OpenPosition>, params: &OpenPositionParams) ->
     {
         return Err(ProgramError::InvalidArgument.into());
     }
-    if params.side == Side::Short || custody.is_virtual {
+    let use_collateral_custody = params.side == Side::Short || custody.is_virtual;
+    if use_collateral_custody {
         require_keys_neq!(custody.key(), collateral_custody.key());
         require!(
             collateral_custody.is_stable && !collateral_custody.is_virtual,
@@ -211,7 +212,7 @@ pub fn open_position(ctx: Context<OpenPosition>, params: &OpenPositionParams) ->
     let collateral_usd = min_collateral_price
         .get_asset_amount_usd(params.collateral, collateral_custody.decimals)?;
 
-    let locked_amount = if params.side == Side::Short || custody.is_virtual {
+    let locked_amount = if use_collateral_custody {
         custody.get_locked_amount(
             min_collateral_price.get_token_amount(size_usd, collateral_custody.decimals)?,
             params.side,
@@ -221,12 +222,17 @@ pub fn open_position(ctx: Context<OpenPosition>, params: &OpenPositionParams) ->
     };
 
     // compute fee
-    let fee_amount = pool.get_entry_fee(
+    let mut fee_amount = pool.get_entry_fee(
         custody.fees.open_position,
         params.size,
         locked_amount,
         collateral_custody,
     )?;
+    let fee_amount_usd = token_ema_price.get_asset_amount_usd(fee_amount, custody.decimals)?;
+    if use_collateral_custody {
+        fee_amount = collateral_token_ema_price
+            .get_token_amount(fee_amount_usd, collateral_custody.decimals)?;
+    }
     msg!("Collected fee: {}", fee_amount);
 
     // compute amount to transfer
@@ -296,10 +302,7 @@ pub fn open_position(ctx: Context<OpenPosition>, params: &OpenPositionParams) ->
     collateral_custody.collected_fees.open_position_usd = collateral_custody
         .collected_fees
         .open_position_usd
-        .wrapping_add(
-            collateral_token_ema_price
-                .get_asset_amount_usd(fee_amount, collateral_custody.decimals)?,
-        );
+        .wrapping_add(fee_amount_usd);
 
     collateral_custody.assets.collateral =
         math::checked_add(collateral_custody.assets.collateral, params.collateral)?;