flash-sdk 1.0.0

package/src/PerpetualsClient.ts

@@ -0,0 +1,983 @@
+import {
+  setProvider,
+  Program,
+  AnchorProvider,
+  workspace,
+  utils,
+  BN,
+} from "@coral-xyz/anchor";
+import {
+  PublicKey,
+  TransactionInstruction,
+  Transaction,
+  SystemProgram,
+  AccountMeta,
+  Keypair,
+  SYSVAR_RENT_PUBKEY,
+} from "@solana/web3.js";
+import {
+  getAccount,
+  getAssociatedTokenAddress,
+  createAssociatedTokenAccountInstruction,
+  createCloseAccountInstruction,
+  createSyncNativeInstruction,
+  TOKEN_PROGRAM_ID,
+} from "@solana/spl-token";
+
+import fetch from "node-fetch";
+import { sha256 } from "js-sha256";
+import { encode } from "bs58";
+import { readFileSync } from "fs";
+
+import { PoolAccount } from "./PoolAccount";
+import { PositionAccount } from "./PositionAccount";
+import { BorrowRateParams, Custody, Fees, OracleParams, Permissions, Position, PositionSide, PricingParams, TokenRatios, isVariant } from "./types";
+import { OraclePrice } from "./OraclePrice";
+import { CustodyAccount } from "./CustodyAccount";
+import { Perpetuals } from "./target/types/perpetuals"
+// import { Perpetuals } from "../../target/types/perpetuals"
+
+
+export class PerpetualsClient {
+  provider: AnchorProvider;
+  program: Program<Perpetuals>;
+  admin: Keypair;
+
+  // pdas
+  multisig: { publicKey: PublicKey; bump: number };
+  authority: { publicKey: PublicKey; bump: number };
+  perpetuals: { publicKey: PublicKey; bump: number };
+
+  constructor(clusterUrl: string, adminKey: string) {
+    this.provider = AnchorProvider.local(clusterUrl, {
+      commitment: "confirmed",
+      preflightCommitment: "confirmed",
+      skipPreflight: true
+    });
+    setProvider(this.provider);
+    this.program = workspace.Perpetuals as Program<Perpetuals>;
+
+    this.admin = Keypair.fromSecretKey(
+      new Uint8Array(JSON.parse(readFileSync(adminKey).toString()))
+    );
+
+    this.multisig = this.findProgramAddress("multisig");
+    this.authority = this.findProgramAddress("transfer_authority");
+    this.perpetuals = this.findProgramAddress("perpetuals");
+
+    BN.prototype.toJSON = function () {
+      return this.toString(10);
+    };
+  }
+
+  findProgramAddress = (label: string, extraSeeds :any = null) => {
+    let seeds = [Buffer.from(utils.bytes.utf8.encode(label))];
+    if (extraSeeds) {
+      for (let extraSeed of extraSeeds) {
+        if (typeof extraSeed === "string") {
+          seeds.push(Buffer.from(utils.bytes.utf8.encode(extraSeed)));
+        } else if (Array.isArray(extraSeed)) {
+          seeds.push(Buffer.from(extraSeed));
+        } else {
+          seeds.push(extraSeed.toBuffer());
+        }
+      }
+    }
+    let res = PublicKey.findProgramAddressSync(seeds, this.program.programId);
+    return { publicKey: res[0], bump: res[1] };
+  };
+
+  adjustTokenRatios = (ratios : TokenRatios[]) => {
+    if (ratios.length == 0) {
+      return ratios;
+    }
+    let target = Math.floor(10000 / ratios.length);
+
+    for (let ratio of ratios) {
+      ratio.target = new BN(target);
+    }
+
+    if (10000 % ratios.length !== 0) {
+      ratios[ratios.length - 1].target = new BN(
+        target + (10000 % ratios.length)
+      );
+    }
+
+    return ratios;
+  };
+
+  getPerpetuals = async () => {
+    return this.program.account.perpetuals.fetch(this.perpetuals.publicKey);
+  };
+
+  getPoolKey = (name: string) => {
+    return this.findProgramAddress("pool", name).publicKey;
+  };
+
+  getPool = async (name: string) => {
+    console.log("pool:",this.getPoolKey(name).toBase58())
+    return this.program.account.pool.fetch(this.getPoolKey(name));
+  };
+
+  getPools = async () => {
+    //return this.program.account.pool.all();
+    let perpetuals = await this.getPerpetuals();
+    return this.program.account.pool.fetchMultiple(perpetuals.pools);
+  };
+
+  getPoolLpTokenKey = (name: string) => {
+    return this.findProgramAddress("lp_token_mint", [this.getPoolKey(name)])
+      .publicKey;
+  };
+
+  getCustodyKey = (poolName: string, tokenMint: PublicKey) => {
+    return this.findProgramAddress("custody", [
+      this.getPoolKey(poolName),
+      tokenMint,
+    ]).publicKey;
+  };
+
+  getCustodyTokenAccountKey = (poolName: string, tokenMint: PublicKey) => {
+    return this.findProgramAddress("custody_token_account", [
+      this.getPoolKey(poolName),
+      tokenMint,
+    ]).publicKey;
+  };
+
+  getCustodyOracleAccountKey = async (
+    poolName: string,
+    tokenMint: PublicKey
+  ) => {
+    return (await this.getCustody(poolName, tokenMint)).oracle.oracleAccount;
+  };
+
+  getCustodyTestOracleAccountKey = (poolName: string, tokenMint: PublicKey) => {
+    return this.findProgramAddress("oracle_account", [
+      this.getPoolKey(poolName),
+      tokenMint,
+    ]).publicKey;
+  };
+
+  getCustody = async (poolName: string, tokenMint: PublicKey) => {
+    console.log("custody key :",this.getCustodyKey(poolName, tokenMint).toBase58());
+    return this.program.account.custody.fetch(
+      this.getCustodyKey(poolName, tokenMint)
+    );
+  };
+
+  getCustodies = async (poolName: string) => {
+    //return this.program.account.custody.all();
+    let pool  = await this.getPool(poolName);
+    return this.program.account.custody.fetchMultiple(
+      pool.custodies
+    );
+  };
+
+  getCustodyMetas = async (poolName: string) => {
+    let pool = await this.getPool(poolName);
+    let custodies :any = await this.program.account.custody.fetchMultiple(
+      pool.custodies
+    );
+    let custodyMetas = [];
+    for (const custody of pool.custodies) {
+      custodyMetas.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: custody,
+      });
+    }
+    for (const custody of custodies) {
+      custodyMetas.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: custody?.oracle.oracleAccount,
+      });
+    }
+    return custodyMetas;
+  };
+
+  getMultisig = async () => {
+    return this.program.account.multisig.fetch(this.multisig.publicKey);
+  };
+
+  getPositionKey = (
+    wallet: PublicKey,
+    poolName: string,
+    tokenMint: PublicKey,
+    side: PositionSide
+  ) => {
+    let pool = this.getPoolKey(poolName);
+    let custody = this.getCustodyKey(poolName, tokenMint);
+    return this.findProgramAddress("position", [
+      wallet,
+      pool,
+      custody,
+      side === "long" ? [1] : [0],
+    ]).publicKey;
+  };
+
+  getPosition = async (postionKey : PublicKey) => {
+    return this.program.account.position.fetch(postionKey);
+  };
+
+  getUserPosition = async (
+    wallet: PublicKey,
+    poolName: string,
+    tokenMint: PublicKey,
+    side: PositionSide
+  ) => {
+    return this.program.account.position.fetch(
+      this.getPositionKey(wallet, poolName, tokenMint, side)
+    );
+  };
+
+  getUserPositions = async (wallet: PublicKey) => {
+    let data = encode(
+      Buffer.concat([
+        this.getAccountDiscriminator("Position"),
+        wallet.toBuffer(),
+      ])
+    );
+    let positions = await this.provider.connection.getProgramAccounts(
+      this.program.programId,
+      {
+        filters: [{ dataSize: 200 }, { memcmp: { bytes: data, offset: 0 } }],
+      }
+    );
+    return Promise.all(
+      positions.map((position) => {
+        return this.program.account.position.fetch(position.pubkey);
+      })
+    );
+  };
+
+  getPoolTokenPositions = async (poolName: string, tokenMint: PublicKey) => {
+    let poolKey = this.getPoolKey(poolName);
+    let custodyKey = this.getCustodyKey(poolName, tokenMint);
+    let data = encode(
+      Buffer.concat([poolKey.toBuffer(), custodyKey.toBuffer()])
+    );
+    let positions = await this.provider.connection.getProgramAccounts(
+      this.program.programId,
+      {
+        filters: [{ dataSize: 200 }, { memcmp: { bytes: data, offset: 40 } }],
+      }
+    );
+    return Promise.all(
+      positions.map((position) => {
+        return this.program.account.position.fetch(position.pubkey);
+      })
+    );
+  };
+
+  getAllPositions = async () => {
+    return this.program.account.position.all();
+  };
+
+  getAccountDiscriminator = (name: string) => {
+    return Buffer.from(sha256.digest(`account:${name}`)).slice(0, 8);
+  };
+
+
+  log = (...message: string[]) => {
+    let date = new Date();
+    let date_str = date.toDateString();
+    let time = date.toLocaleTimeString();
+    console.log(`[${date_str} ${time}] ${message}`);
+  };
+
+  prettyPrint = (object: object) => {
+    console.log(JSON.stringify(object, null, 2));
+  };
+
+  ///////
+  // instructions
+
+  init = async (admins: PublicKey[], config: any) => {
+    let perpetualsProgramData = PublicKey.findProgramAddressSync(
+      [this.program.programId.toBuffer()],
+      new PublicKey("BPFLoaderUpgradeab1e11111111111111111111111")
+    )[0];
+
+    let adminMetas = [];
+    for (const admin of admins) {
+      adminMetas.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: admin,
+      });
+    }
+
+    await this.program.methods
+      .init(config)
+      .accounts({
+        upgradeAuthority: this.provider.wallet.publicKey,
+        multisig: this.multisig.publicKey,
+        transferAuthority: this.authority.publicKey,
+        perpetuals: this.perpetuals.publicKey,
+        perpetualsProgram: this.program.programId,
+        perpetualsProgramData,
+        systemProgram: SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID,
+      })
+      .remainingAccounts(adminMetas)
+      .rpc()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  setAdminSigners = async (admins: PublicKey[], minSignatures: number) => {
+    let adminMetas = [];
+    for (const admin of admins) {
+      adminMetas.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: admin,
+      });
+    }
+    try {
+      await this.program.methods
+        .setAdminSigners({
+          minSignatures,
+        })
+        .accounts({
+          admin: this.admin.publicKey,
+          multisig: this.multisig.publicKey,
+        })
+        .remainingAccounts(adminMetas)
+        .signers([this.admin])
+        .rpc();
+    } catch (err) {
+      // @ts-ignore
+      if (this.printErrors) {
+        console.log(err);
+      }
+      throw err;
+    }
+  };
+
+  addPool = async (name: string) => {
+    await this.program.methods
+      .addPool({ name })
+      .accounts({
+        admin: this.admin.publicKey,
+        multisig: this.multisig.publicKey,
+        transferAuthority: this.authority.publicKey,
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(name),
+        lpTokenMint: this.getPoolLpTokenKey(name),
+        systemProgram: SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        rent: SYSVAR_RENT_PUBKEY,
+      })
+      .signers([this.admin])
+      .rpc()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  removePool = async (name: string) => {
+    await this.program.methods
+      .removePool({})
+      .accounts({
+        admin: this.admin.publicKey,
+        multisig: this.multisig.publicKey,
+        transferAuthority: this.authority.publicKey,
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(name),
+        systemProgram: SystemProgram.programId,
+      })
+      .signers([this.admin])
+      .rpc()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  addCustody = async (
+    poolName: string,
+    tokenMint: PublicKey,
+    isStable: boolean,
+    oracle : OracleParams,
+    pricing: PricingParams,
+    permissions : Permissions,
+    fees : Fees,
+    borrowRate : BorrowRateParams,
+    ratios : TokenRatios[]
+  ) => {
+    console.log("CustodyKey",  this.getCustodyKey(poolName, tokenMint).toBase58())
+    console.log("getCustodyTokenAccountKey",  this.getCustodyTokenAccountKey(poolName, tokenMint).toBase58())
+    try {
+      const trx_id =  await this.program.methods
+      // @ts-ignore
+      .addCustody({ 
+        isStable,
+        oracle,
+        pricing,
+        permissions,
+        fees,
+        borrowRate,
+        ratios,
+      })
+      .accounts({
+        admin: this.admin.publicKey,
+        multisig: this.multisig.publicKey,
+        transferAuthority: this.authority.publicKey,
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyTokenAccount: this.getCustodyTokenAccountKey(
+          poolName,
+          tokenMint
+        ),
+        custodyTokenMint: tokenMint,
+        systemProgram: SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        rent: SYSVAR_RENT_PUBKEY,
+      })
+      .signers([this.admin])
+      .rpc()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+
+      console.log("trx_id:", `https://explorer.solana.com/tx/${trx_id}?cluster=devnet`)
+    } catch (error) {
+      console.log("cli error :",error);
+    }
+    
+
+  };
+
+  editCustody = async (
+    poolName: string,
+    tokenMint: PublicKey,
+    isStable: boolean,
+    oracle : OracleParams,
+    pricing: PricingParams,
+    permissions : Permissions,
+    fees : Fees,
+    borrowRate : BorrowRateParams,
+    ratios : TokenRatios[]
+  ) => {
+    console.log("CustodyKey",  this.getCustodyKey(poolName, tokenMint).toBase58())
+    console.log("getCustodyTokenAccountKey",  this.getCustodyTokenAccountKey(poolName, tokenMint).toBase58())
+
+   const trx_id =  await this.program.methods
+   //@ts-ignore
+      .testingEditCustody({
+        isStable,
+        oracle,
+        pricing,
+        permissions,
+        fees,
+        borrowRate,
+        ratios,
+      })
+      .accounts({
+        admin: this.admin.publicKey,
+        multisig: this.multisig.publicKey,
+        transferAuthority: this.authority.publicKey,
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyTokenAccount: this.getCustodyTokenAccountKey(
+          poolName,
+          tokenMint
+        ),
+        custodyTokenMint: tokenMint,
+        systemProgram: SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        rent: SYSVAR_RENT_PUBKEY,
+      })
+      .signers([this.admin])
+      .rpc()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+      console.log("trx_id:", `https://explorer.solana.com/tx/${trx_id}?cluster=devnet`)
+  };
+
+  removeCustody = async (poolName: string, tokenMint: PublicKey, ratios:TokenRatios[]) => {
+    await this.program.methods
+      .removeCustody({ ratios })
+      .accounts({
+        admin: this.admin.publicKey,
+        multisig: this.multisig.publicKey,
+        transferAuthority: this.authority.publicKey,
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyTokenAccount: this.getCustodyTokenAccountKey(
+          poolName,
+          tokenMint
+        ),
+        systemProgram: SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID,
+      })
+      .signers([this.admin])
+      .rpc()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  upgradeCustody = async (poolName: string, tokenMint: PublicKey) => {
+    await this.program.methods
+      .upgradeCustody({})
+      .accounts({
+        admin: this.admin.publicKey,
+        multisig: this.multisig.publicKey,
+        pool: this.getPoolKey(poolName),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        systemProgram: SystemProgram.programId,
+      })
+      .signers([this.admin])
+      .rpc()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  liquidate = async (
+    wallet: PublicKey,
+    poolName: string,
+    tokenMint: PublicKey,
+    side: PositionSide,
+    receivingAccount: PublicKey,
+    rewardsReceivingAccount: PublicKey
+  ) => {
+    return await this.program.methods
+      .liquidate({})
+      .accounts({
+        signer: this.provider.wallet.publicKey,
+        receivingAccount,
+        rewardsReceivingAccount,
+        transferAuthority: this.authority.publicKey,
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        position: this.getPositionKey(wallet, poolName, tokenMint, side),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+        custodyTokenAccount: this.getCustodyTokenAccountKey(
+          poolName,
+          tokenMint
+        ),
+        tokenProgram: TOKEN_PROGRAM_ID,
+      })
+      .rpc()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  getOraclePrice = async (
+    poolName: string,
+    tokenMint: PublicKey,
+    ema: boolean
+  ) => {
+    return await this.program.methods
+      .getOraclePrice({
+        ema,
+      })
+      .accounts({
+        // signer: this.provider.wallet.publicKey,
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+      })
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  getAddLiquidityAmountAndFee = async (
+    poolName: string,
+    tokenMint: PublicKey,
+    amount: BN
+  ) => {
+    return await this.program.methods
+      .getAddLiquidityAmountAndFee({ 
+        amountIn: amount,
+      })
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+        lpTokenMint: this.getPoolLpTokenKey(poolName),
+      })
+      .remainingAccounts(await this.getCustodyMetas(poolName))
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+
+
+  getRemoveLiquidityAmountAndFee = async (
+    poolName: string,
+    tokenMint: PublicKey,
+    lpAmount: BN
+  ) => {
+    return await this.program.methods
+      .getRemoveLiquidityAmountAndFee({
+        lpAmountIn: lpAmount,
+      })
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+        lpTokenMint: this.getPoolLpTokenKey(poolName),
+      })
+      .remainingAccounts(await this.getCustodyMetas(poolName))
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  getEntryPriceAndFee = async (
+    poolName: string,
+    tokenMint: PublicKey,
+    collateral:  BN,
+    size:  BN,
+    side: PositionSide
+  ) => {
+    console.log("perps: ", this.perpetuals.publicKey.toBase58())
+
+    console.log("poolKey: ", this.getPoolKey(poolName).toBase58())
+    console.log("custody key : ",this.getCustodyKey(poolName, tokenMint).toBase58());
+    console.log("orcalve: ",  (await this.getCustodyOracleAccountKey(poolName,tokenMint)).toBase58())
+
+    //@ts-ignore
+    return await this.program.methods
+    //@ts-ignore
+      .getEntryPriceAndFee({ 
+        collateral,
+        size,
+        side: side == "long" ? { long: {} } : { short: {} }, 
+      })
+      .accounts({
+        // signer: this.provider.wallet.publicKey,
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+        // lockCustody: this.getCustodyKey(poolName, tokenMint),
+        // lockCustodyOracleAccount: await this.getCustodyOracleAccountKey(
+        //   poolName,
+        //   tokenMint
+        // ),
+      })
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  getExitPriceAndFee = async (
+    wallet: PublicKey,
+    poolName: string,
+    tokenMint: PublicKey,
+    side: PositionSide
+  ) => {
+    return await this.program.methods
+      .getExitPriceAndFee({})
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        position: this.getPositionKey(wallet, poolName, tokenMint, side),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+      })
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  getLiquidationPrice = async (
+    wallet: PublicKey,
+    poolName: string,
+    tokenMint: PublicKey,
+    side: PositionSide,
+    addCollateral: BN,
+    removeCollateral: BN
+  ) => {
+    return await this.program.methods
+      .getLiquidationPrice({
+        addCollateral,
+        removeCollateral,
+      })
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        position: this.getPositionKey(wallet, poolName, tokenMint, side),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+      })
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  getLiquidationPriceTrx = async (
+    wallet: PublicKey,
+    poolName: string,
+    tokenMint: PublicKey,
+    side: PositionSide,
+    addCollateral: BN,
+    removeCollateral: BN
+  ) => {
+    return await this.program.methods
+      .getLiquidationPrice({
+        addCollateral,
+        removeCollateral,
+      })
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        position: this.getPositionKey(wallet, poolName, tokenMint, side),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+      })
+      .rpc()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  getLiquidationPrice2 = async (
+    wallet: PublicKey,
+    poolName: string,
+    tokenMint: PublicKey,
+    side: PositionSide,
+    addCollateral: BN,
+    removeCollateral: BN
+  ) => {
+    return await this.program.methods
+      .getLiquidationPrice({
+        addCollateral,
+        removeCollateral,
+      })
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        position: this.getPositionKey(wallet, poolName, tokenMint, side),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+      })
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  getLiquidationState = async (
+    wallet: PublicKey,
+    poolName: string,
+    tokenMint: PublicKey,
+    side: PositionSide
+  ) => {
+    return await this.program.methods
+      .getLiquidationState({})
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        position: this.getPositionKey(wallet, poolName, tokenMint, side),
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+      })
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  getPnl = async (
+    wallet: PublicKey,
+    poolName: string,
+    tokenMint: PublicKey,
+    side: PositionSide
+  ) => {
+    const pos = this.getPositionKey(wallet, poolName, tokenMint, side);
+    console.log("pos:",pos.toBase58())
+    return await this.program.methods
+      .getPnl({})
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        position: pos,
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+      })
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+
+  getPnlTrx = async (
+    wallet: PublicKey,
+    poolName: string,
+    tokenMint: PublicKey,
+    side: PositionSide
+  ) => {
+    const pos = this.getPositionKey(wallet, poolName, tokenMint, side);
+    console.log("pos:",pos.toBase58())
+    return await this.program.methods
+      .getPnl({})
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        position: pos,
+        custody: this.getCustodyKey(poolName, tokenMint),
+        custodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMint
+        ),
+      })
+      .rpc()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+
+  getPnl2 =  (
+    postionKey : PublicKey,
+    postionData: Position,
+    tokenPrice : OraclePrice,
+    tokenEmaPrice : OraclePrice,
+    custodyAccount : CustodyAccount,
+    poolAccount : PoolAccount,
+    currentTime : BN
+  ) => {
+    
+    const positionAccount = PositionAccount.from(postionKey, postionData);
+    // console.log("positionAccount:",positionAccount);
+    // console.log("side :", postionData.side, (isVariant(postionData.side, 'long')))
+
+    let {profit, loss, exitFee} = poolAccount.getPnlUsd(
+      positionAccount,
+      tokenPrice,
+      tokenEmaPrice,
+      custodyAccount,
+      currentTime,
+      false,
+      );
+
+      return {
+        profit,
+        loss
+      }
+
+  }
+
+  getSwapAmountAndFees = async (
+    poolName: string,
+    tokenMintIn: PublicKey,
+    tokenMintOut: PublicKey,
+    amountIn: BN
+  ) => {
+    return await this.program.methods
+      .getSwapAmountAndFees({
+        amountIn,
+      })
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+        receivingCustody: this.getCustodyKey(poolName, tokenMintIn),
+        receivingCustodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMintIn
+        ),
+        dispensingCustody: this.getCustodyKey(poolName, tokenMintOut),
+        dispensingCustodyOracleAccount: await this.getCustodyOracleAccountKey(
+          poolName,
+          tokenMintOut
+        ),
+      })
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+
+  getAum = async (poolName: string) => {
+    return await this.program.methods
+      .getAssetsUnderManagement({})
+      .accounts({
+        perpetuals: this.perpetuals.publicKey,
+        pool: this.getPoolKey(poolName),
+      })
+      .remainingAccounts(await this.getCustodyMetas(poolName))
+      .view()
+      .catch((err) => {
+        console.error(err);
+        throw err;
+      });
+  };
+}