flash-sdk 1.0.0

package/src/PoolAccount.ts

@@ -0,0 +1,434 @@
+
+import { BN_ZERO, BPS_DECIMALS, BPS_POWER, PERCENTAGE_DECIMALS, PRICE_DECIMALS, USD_DECIMALS } from "./constants";
+import { BN } from "@coral-xyz/anchor";
+import { Mint } from "@solana/spl-token";
+import { Custody, FeesMode, Pool, Side, TokenRatios, isVariant } from "./types";
+import { PublicKey } from "@solana/web3.js";
+import {CustodyAccount} from "./CustodyAccount";
+import { OraclePrice } from "./OraclePrice";
+import { PositionAccount } from "./PositionAccount";
+import { checkedCeilDiv, checkedDecimalCeilMul, checkedDecimalMul, scaleToExponent } from "./utils";
+
+
+export class PoolAccount {
+
+    publicKey: PublicKey;
+
+    //  all Pool Type data IMP:: SHOULD MATCH NAMES 
+    name: string;
+    custodies: PublicKey[];
+    ratios: TokenRatios[];
+    aumUsd: BN;
+    bump: number;
+    lpTokenBump: number;
+    inceptionTime: BN;
+
+
+    constructor(publicKey: PublicKey, parseData: Pool) {
+        this.publicKey = publicKey;
+        Object.assign(this, parseData);
+    }
+
+    static from(publicKey: PublicKey, parseData: Pool): PoolAccount {
+        return new PoolAccount(publicKey, parseData);
+    }
+
+
+    updatePoolData(parseData: Pool) {
+        Object.assign(this, parseData);
+    }
+
+    getTokenId(custodyKey: PublicKey) : number {
+        return this.custodies.findIndex(i => i.toBase58()==custodyKey.toBase58())
+    }
+
+    //   loadlpData(lpTokenInfo : Mint){
+    //     this.lpTokenInfo = lpTokenInfo
+    //   }
+
+    getAddLiquidityFee(
+        tokenId: number,
+        amount: BN,
+        custody: CustodyAccount,
+        tokenPrice: OraclePrice,
+    ) : BN {
+        return this.getFee(
+                    tokenId,
+                    custody.fees.addLiquidity,
+                    amount,
+                    new BN(0),
+                    custody,
+                    tokenPrice,
+                )
+    }
+
+    // TODO 
+    getFee(
+        tokenId: number,
+        baseFee: BN,
+        amountAdd: BN,
+        amountRemove: BN,
+        custody: CustodyAccount,
+        tokenPrice: OraclePrice,
+    ) : BN {
+        if (custody.fees.mode === FeesMode.Fixed) {
+            // return Self::get_fee_amount(base_fee, std::cmp::max(amount_add, amount_remove));
+           return this.getFeeAmount(baseFee,BN.max(amountAdd, amountRemove))
+        }
+        // === NOW FEE MODE IS FeesMode.Linear
+        // if token ratio is improved:
+        //    fee = base_fee / ratio_fee
+        // otherwise:
+        //    fee = base_fee * ratio_fee
+        // where:
+        //   if new_ratio < ratios.target:
+        //     ratio_fee = 1 + custody.fees.ratio_mult * (ratios.target - new_ratio) / (ratios.target - ratios.min);
+        //   otherwise:
+        //     ratio_fee = 1 + custody.fees.ratio_mult * (new_ratio - ratios.target) / (ratios.max - ratios.target);
+
+         let ratios = this.ratios[tokenId];
+        let current_ratio = this.getCurrentRatio(custody, tokenPrice);
+        throw Error("TODODO");
+        // let new_ratio = self.get_new_ratio(amount_add, amount_remove, custody, token_price)?;
+
+        // let improved = match new_ratio.cmp(&ratios.target) {
+        //     Ordering::Less => {
+        //         new_ratio > current_ratio
+        //             || (current_ratio > ratios.target
+        //                 && current_ratio - ratios.target > ratios.target - new_ratio)
+        //     }
+        //     Ordering::Greater => {
+        //         new_ratio < current_ratio
+        //             || (current_ratio < ratios.target
+        //                 && ratios.target - current_ratio > new_ratio - ratios.target)
+        //     }
+        //     Ordering::Equal => current_ratio != ratios.target,
+        // };
+
+        // let ratio_fee = if new_ratio <= ratios.target {
+        //     if ratios.target == ratios.min {
+        //         Perpetuals::BPS_POWER
+        //     } else {
+        //         math::checked_add(
+        //             Perpetuals::BPS_POWER,
+        //             math::checked_div(
+        //                 math::checked_mul(
+        //                     custody.fees.ratio_mult as u128,
+        //                     math::checked_sub(ratios.target, new_ratio)? as u128,
+        //                 )?,
+        //                 math::checked_sub(ratios.target, ratios.min)? as u128,
+        //             )?,
+        //         )?
+        //     }
+        // } else if ratios.target == ratios.max {
+        //     Perpetuals::BPS_POWER
+        // } else {
+        //     math::checked_add(
+        //         Perpetuals::BPS_POWER,
+        //         math::checked_div(
+        //             math::checked_mul(
+        //                 custody.fees.ratio_mult as u128,
+        //                 math::checked_sub(new_ratio, ratios.target)? as u128,
+        //             )?,
+        //             math::checked_sub(ratios.max, ratios.target)? as u128,
+        //         )?,
+        //     )?
+        // };
+
+        // let fee = if improved {
+        //     math::checked_div(
+        //         math::checked_mul(base_fee as u128, Perpetuals::BPS_POWER)?,
+        //         ratio_fee,
+        //     )?
+        // } else {
+        //     math::checked_div(
+        //         math::checked_mul(base_fee as u128, ratio_fee)?,
+        //         Perpetuals::BPS_POWER,
+        //     )?
+        // };
+
+        // Self::get_fee_amount(
+        //     math::checked_as_u64(fee)?,
+        //     std::cmp::max(amount_add, amount_remove),
+        // )
+    
+
+        return new BN(0);    
+    }
+
+    getFeeAmount(fee: BN, amount: BN) : BN {
+        if (fee.isZero() || amount.isZero() ){
+            return new BN(0);
+        }
+
+        return checkedCeilDiv(
+            (amount.mul(fee)),
+            new BN(BPS_POWER)
+        )
+    }
+
+    getExitFee( size: BN, custody: CustodyAccount) : BN {
+       return this.getFeeAmount(custody.fees.closePosition, size)
+    }
+
+    getLiquidationFee( size: BN, custody: CustodyAccount) : BN {
+        return this.getFeeAmount(custody.fees.closePosition, size);
+    }
+
+    getCurrentRatio(
+        custody : CustodyAccount,
+         tokenPrice : OraclePrice
+    ) :BN {
+        if (this.aumUsd.isZero()) {
+            return new BN(0);
+        }
+        // let ratio = math::checked_as_u64(math::checked_div(
+        //     math::checked_mul(
+        //         token_price.get_asset_amount_usd(custody.assets.owned, custody.decimals)? as u128,
+        //         Perpetuals::BPS_POWER,
+        //     )?,
+        //     self.aum_usd,
+        // )?)?;
+
+        // Ok(std::cmp::min(ratio, Perpetuals::BPS_POWER as u64))
+    }
+
+    getExitPrice(
+        token_price: OraclePrice,
+        token_ema_price: OraclePrice,
+        side: Side,
+        custody: CustodyAccount,
+    ) : BN {
+        let price = this.getPrice(
+            token_price,
+            token_ema_price,
+            (isVariant(side, 'long')) ? Side.Short : Side.Long,
+            (isVariant(side, 'long')) ? custody.pricing.tradeSpreadShort : custody.pricing.tradeSpreadLong,
+        );
+        return price.scale_to_exponent(new BN(-1*PRICE_DECIMALS)).price
+    }
+    
+
+   getPrice(
+        token_price: OraclePrice,
+        token_ema_price: OraclePrice,
+        side: Side,
+        spread: BN,
+     ) : OraclePrice {
+        if (isVariant(side, 'long')) {
+            console.log("inside long")
+            let max_price : OraclePrice;
+             if (token_price.cmp(token_ema_price))  {
+                max_price = token_price;
+            } else {
+                max_price = token_ema_price;
+            };
+
+            // Ok(OraclePrice {
+            //     price: math::checked_add(
+            //         max_price.price,
+            //         math::checked_decimal_ceil_mul(
+            //             max_price.price,
+            //             max_price.exponent,
+            //             spread,
+            //             -(Perpetuals::BPS_DECIMALS as i32),
+            //             max_price.exponent,
+            //         )?,
+            //     )?,
+            //     exponent: max_price.exponent,
+            // })
+            let x = checkedDecimalCeilMul(
+                max_price.price,
+                max_price.exponent,
+                spread,
+                new BN(-1 * BPS_DECIMALS),
+                max_price.exponent,
+            );
+            console.log("x:",x);
+            return new OraclePrice({
+                price : max_price.price.add(
+                    checkedDecimalCeilMul(
+                        max_price.price,
+                        max_price.exponent,
+                        spread,
+                        new BN(-1 * BPS_DECIMALS),
+                        max_price.exponent,
+                    )
+                ),
+                exponent : max_price.exponent,
+            })
+        } else {
+            console.log("inside short ")
+
+            let min_price:OraclePrice;
+            if (token_price.cmp(token_ema_price) ) {
+                min_price = token_ema_price;
+            } else {
+                min_price = token_price;
+            };
+            console.log("min_price:",min_price.price.toString())
+
+            let spread_i = checkedDecimalMul(
+                min_price.price,
+                min_price.exponent,
+                spread,
+                new BN(-1 * BPS_DECIMALS),
+                min_price.exponent,
+            );
+            console.log("spread_i:",spread_i.toString())
+
+            let price : BN;
+            if (spread_i.lt(min_price.price) ){
+                price = min_price.price.sub(spread_i)
+            } else {
+                price = BN_ZERO;
+            };
+
+            return new OraclePrice({
+                price : price,
+                exponent : min_price.exponent
+            })
+
+        }
+    }
+
+    getPnlUsd(
+        position: PositionAccount,
+        token_price: OraclePrice,
+        token_ema_price: OraclePrice,
+        custody: CustodyAccount,
+        curtime: BN,
+        liquidation: boolean,
+    ) {
+
+        if (position.sizeUsd.isZero() || position.price.isZero()){
+            return { 
+                profit: BN_ZERO,
+                loss: BN_ZERO,
+                exitFee:  BN_ZERO
+            }
+        }   
+        let min_price: OraclePrice;
+        if (token_price.cmp(token_ema_price)) {
+            min_price = token_price
+        } else {
+            min_price = token_ema_price
+        };
+
+
+        let exit_price = this.getExitPrice(token_price, token_ema_price, position.side, custody);
+        console.log("exit_price:",exit_price, exit_price?.toString())
+
+
+        let size = token_ema_price.getTokenAmount(position.sizeUsd, custody.decimals);
+        console.log("size:",size, size?.toString())
+
+        let exit_fee :BN; 
+        if (liquidation) {
+            exit_fee = this.getLiquidationFee(size, custody)
+        } else {
+            exit_fee = this.getExitFee(size, custody)
+        };
+        console.log("exit_fee:",exit_fee.toString())
+
+        let exit_fee_usd = token_ema_price.getAssetAmountUsd(exit_fee, custody.decimals);
+        console.log("exit_fee_usd:",exit_fee_usd.toString())
+
+        let interest_usd = custody.getInterestAmountUsd(position, curtime);
+        console.log("interest_usd:",interest_usd.toString())
+
+        let unrealized_loss_usd =  (exit_fee_usd.add(interest_usd)).add(position.unrealizedLossUsd);
+        console.log("unrealized_loss_usd:",unrealized_loss_usd.toString())
+
+        let price_diff_profit, price_diff_loss ;
+        if (isVariant(position.side, 'long'))  {
+            if (exit_price.gt(position.price))  {
+                price_diff_profit =  exit_price.sub(position.price)
+                price_diff_loss = BN_ZERO
+            } else {
+                price_diff_profit = BN_ZERO;
+                price_diff_loss =  position.price.sub(exit_price);
+            }
+        } else if (exit_price.lt(position.price) ){
+            price_diff_profit =  position.price.sub(exit_price);
+            price_diff_loss = BN_ZERO
+        } else {
+            price_diff_profit = BN_ZERO;
+            price_diff_loss = exit_price.sub(position.price);
+        };
+        console.log("1 price_diff_profit:",price_diff_profit.toString())
+        console.log("2 price_diff_loss:",price_diff_loss.toString())
+
+
+        let position_price = scaleToExponent(
+            position.price,
+            new BN(-1 * PRICE_DECIMALS),
+            new BN(-1 * USD_DECIMALS ),
+        );
+        console.log("position_price:",position_price.toString())
+
+        if (price_diff_profit.gt(BN_ZERO)) {
+            
+            let potential_profit_usd = (position.sizeUsd.mul(price_diff_profit)).div(position_price);
+
+            potential_profit_usd = potential_profit_usd.add(position.unrealizedProfitUsd);
+            console.log("potential_profit_usd:",potential_profit_usd.toString())
+
+
+            if (potential_profit_usd.gte(unrealized_loss_usd))  {
+                let cur_profit_usd = potential_profit_usd.sub(unrealized_loss_usd);
+                let max_profit_usd =
+                    min_price.getAssetAmountUsd(position.lockedAmount, custody.decimals);
+
+                console.log("cur_profit_usd:",cur_profit_usd.toString())
+                console.log("max_profit_usd:",max_profit_usd.toString())
+
+                return { 
+                    profit: BN.min(max_profit_usd, cur_profit_usd),
+                    loss: BN_ZERO,
+                    exitFee:  exit_fee
+                }
+            } else {
+                console.log(" -- unrealized_loss_usd:",unrealized_loss_usd.toString())
+                console.log(" -- potential_profit_usd:",potential_profit_usd.toString())
+
+                return { 
+                    profit: BN_ZERO,
+                    loss: unrealized_loss_usd.sub(potential_profit_usd),
+                    exitFee:  exit_fee
+                }
+            }
+        } else {
+            let potential_loss_usd = checkedCeilDiv(
+                position.sizeUsd.mul(price_diff_loss),
+                position_price,
+            );
+
+             potential_loss_usd = potential_loss_usd.add(unrealized_loss_usd);
+             console.log("potential_loss_usd:",potential_loss_usd.toString())
+
+
+            if ( potential_loss_usd.gte(position.unrealizedProfitUsd) ) {
+             console.log("position.unrealizedProfitUsd:",position.unrealizedProfitUsd.toString())
+
+                return { 
+                    profit: BN_ZERO,
+                    loss: potential_loss_usd.sub(position.unrealizedProfitUsd),
+                    exitFee:  exit_fee
+                }
+            } else {
+                let cur_profit_usd = position.unrealizedProfitUsd.sub(potential_loss_usd);
+                let max_profit_usd = min_price.getAssetAmountUsd(position.lockedAmount, custody.decimals);
+             console.log("cur_profit_usd:",cur_profit_usd.toString())
+             console.log("max_profit_usd:",max_profit_usd.toString())
+                
+                return { 
+                    profit: BN.min(max_profit_usd, cur_profit_usd),
+                    loss: BN_ZERO,
+                    exitFee:  exit_fee
+                }
+            }
+        }
+    } //getPnlUsd
+
+} // Pool

package/src/PositionAccount.ts

@@ -0,0 +1,57 @@
+import { BN } from "@coral-xyz/anchor";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { isVariant, Position, Side } from "./types";
+
+
+export class PositionAccount {
+
+    public publicKey: PublicKey;
+
+    //  all Position Type data IMP:: SHOULD MATCH NAMES 
+    public owner: PublicKey;
+    public pool: PublicKey;
+    public custody: PublicKey;
+    //public  lockCustody: PublicKey,
+    public openTime: BN;
+    public updateTime: BN;
+
+    public side: Side;
+    public price: BN;
+    public sizeUsd: BN;
+    public collateralUsd: BN;
+    public unrealizedProfitUsd: BN;
+    public unrealizedLossUsd: BN;
+    public cumulativeInterestSnapshot: BN;
+    public lockedAmount: BN;
+    public collateralAmount: BN;
+    // extra 
+
+    constructor( publicKey : PublicKey, parseData : Position) {
+        this.publicKey = publicKey;
+        Object.assign(this, parseData);
+    }
+
+    static from(publicKey: PublicKey,parseData : Position): PositionAccount {
+        return new PositionAccount( publicKey,parseData);
+    }
+
+    updatePositionData(position: Position) {
+        Object.assign(this, { ...position })
+    }
+
+    static async getLiquidationPrice(  poolKey: PublicKey, custodyKey: PublicKey, position: PublicKey) {
+        try {
+        } catch (error) {
+        return new BN(0);
+        }
+    }
+
+    static async getPnl( poolKey: PublicKey, custodyKey: PublicKey, position: PublicKey) {
+        try {
+        } catch (error) {
+        return new BN(0);
+        
+        }
+    }
+
+}

package/src/constants/index.ts

@@ -0,0 +1,17 @@
+import { BN } from "bn.js";
+
+export const PERCENTAGE_DECIMALS = 4; // stableCoinPercentage
+export const PRICE_DECIMALS = 6; // 
+export const USD_DECIMALS = 6; // 
+
+
+export const BPS_DECIMALS = 4; // 
+export const BPS_POWER = 10**(BPS_DECIMALS);
+
+export const LP_DECIMALS = USD_DECIMALS;
+
+export const RATE_DECIMALS = 9; // borow rate 
+export const RATE_POWER = 10**(RATE_DECIMALS);
+
+export const BN_ZERO = new BN(0);
+export const BN_ONE = new BN(1);

package/src/index.ts

@@ -0,0 +1,14 @@
+export * from './PoolAccount';
+export * from './CustodyAccount';
+export * from './PositionAccount';
+export * from './OraclePrice';
+export * from './constants';
+export * from './types';
+export * from './utils';
+export * from './PerpetualsClient';
+
+
+
+
+
+

package/src/readme.md

@@ -0,0 +1,4 @@
+# strict JS types <=> Rust types 
+
+1) u65 : unisigned intergar - so no decimals => BN 
+2) u8 : number