flash-sdk 1.0.22 → 1.0.23

package/src/PerpetualsClient.ts

@@ -1,2112 +0,0 @@
-import {
-  setProvider,
-  Program,
-  AnchorProvider,
-  workspace,
-  utils,
-  BN,
-} from "@coral-xyz/anchor";
-import {
-  PublicKey,
-  TransactionInstruction,
-  Transaction,
-  SystemProgram,
-  AccountMeta,
-  Keypair,
-  SYSVAR_RENT_PUBKEY,
-  Commitment,
-  LAMPORTS_PER_SOL,
-  Signer,
-} from "@solana/web3.js";
-import {
-  getAccount,
-  getAssociatedTokenAddress,
-  createAssociatedTokenAccountInstruction,
-  createCloseAccountInstruction,
-  createSyncNativeInstruction,
-  TOKEN_PROGRAM_ID,
-  NATIVE_MINT,
-  createInitializeAccount3Instruction,
-  getMinimumBalanceForRentExemptAccount,
-  getAssociatedTokenAddressSync,
-} from "@solana/spl-token";
-
-import { sha256 } from "js-sha256";
-import { encode } from "bs58";
-import { PoolAccount } from "./PoolAccount";
-import { PositionAccount } from "./PositionAccount";
-import { AumCalcMode, BorrowRateParams, Custody, Fees, OracleParams, Permissions, Position, PositionSide, PricingParams, Side, TokenRatios, isVariant } from "./types";
-import { OraclePrice } from "./OraclePrice";
-import { CustodyAccount } from "./CustodyAccount";
-import { Perpetuals } from "./idl/perpetuals";
-import { IDL } from './idl/perpetuals';
-import { sendTransaction } from "./utils/rpc";
-import { PoolConfig } from "./PoolConfig";
-import { checkIfAccountExists } from "./utils";
-
-
-/* USEAGE 
-
-UI -----  
-provider = from phatom 
-
-client = new PerpetualsClient(provider, user.pubkey , programId);
-
-BOT cli -------- 
-
-provider = await getProvider(new DefaultWallet(DEFAULT_PERPS_USER));
-
-AnchorProvider.local(clusterUrl, {
-       commitment: "confirmed",
-      preflightCommitment: "confirmed",
-       skipPreflight: true
-   });
-process.env["ANCHOR_WALLET"] = adminKeyPath;
-
-client = new PerpetualsClient(provider, DEFAULT_PERPS_USER.pubkey , programId);
-
-*/
-
-export type PerpClientOptions = {
-  postSendTxCallback?: ({ txid }: { txid: string }) => void;
-  prioritizationFee?: number;
-  txConfirmationCommitment?: Commitment;
-};
-
-export class PerpetualsClient {
-  provider: AnchorProvider;
-  program: Program<Perpetuals>;
-  admin: PublicKey;
-  programId: PublicKey;
-
-  // pdas
-  multisig: { publicKey: PublicKey; bump: number };
-  authority: { publicKey: PublicKey; bump: number };
-  perpetuals: { publicKey: PublicKey; bump: number };
-
-  private postSendTxCallback?: ({ txid }) => void;
-  private prioritizationFee: number;
-  private txConfirmationCommitment: Commitment;
-
-  constructor(provider: AnchorProvider, programId: PublicKey, opts: PerpClientOptions) {
-    // this.provider = AnchorProvider.local(clusterUrl, {
-    //   commitment: "confirmed",
-    //   preflightCommitment: "confirmed",
-    //   skipPreflight: true
-    // });
-    // setProvider(this.provider);
-    this.provider = provider;
-    setProvider(provider);
-
-    // const idl = JSON.parse(  fs.readFileSync("./target/idl/perpetuals.json", "utf8"));
-    // const idl = JSON.parse(IDL);
-    // const program = new anchor.Program(idl, programId, provider);
-    this.program = new Program(IDL, programId);
-    this.programId = programId;
-    //this.program =  workspace.Perpetuals as Program<Perpetuals>;
-    // console.log("client constructor programID : ", this.program.programId.toBase58());
-
-    // this.admin = Keypair.fromSecretKey(
-    //   new Uint8Array(JSON.parse(readFileSync(adminKey).toString()))
-    // );
-
-    this.admin = this.provider.wallet.publicKey;
-    // console.log("admin:", this.admin.toBase58())
-
-    this.multisig = this.findProgramAddress("multisig");
-    this.authority = this.findProgramAddress("transfer_authority");
-    this.perpetuals = this.findProgramAddress("perpetuals");
-
-    this.prioritizationFee = opts?.prioritizationFee || 0;
-    this.postSendTxCallback = opts?.postSendTxCallback;
-    this.txConfirmationCommitment = opts?.txConfirmationCommitment ?? 'processed'
-
-    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] : [2],
-    ]).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,
-    poolConfig: PoolConfig
-  ) => {
-
-    const positionKeys = [
-      ...poolConfig.getNonStableTokens().map(mint => this.getPositionKey(wallet, poolConfig.poolName, mint, 'long')),
-      ...poolConfig.getNonStableTokens().map(mint => this.getPositionKey(wallet, poolConfig.poolName, mint, 'short')),
-    ]
-
-    let positionsDatas = (await this.provider.connection.getMultipleAccountsInfo(positionKeys)) ?? [];
-
-    type Position = Awaited<ReturnType<typeof this.program.account.position.fetch>>
-
-    return positionsDatas
-      .map((p, i) => ({ pubkey: positionKeys[i], data: p }))
-      .filter(f => f.data !== null)
-      .map(k => ({ pubkey: k.pubkey, ...this.program.account.position.coder.accounts.decode<Position>('position', k.data!.data) }))
-  };
-
-  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,
-          multisig: this.multisig.publicKey,
-        })
-        .remainingAccounts(adminMetas)
-        // .signers([this.admin])
-        .rpc();
-    } catch (err) {
-      // @ts-ignore
-      if (this.printErrors) {
-        console.error("setAdminSigners err:",err);
-      }
-      throw err;
-    }
-  };
-
-  addPool = async (name: string) => {
-    await this.program.methods
-      .addPool({ name })
-      .accounts({
-        admin: this.provider.wallet.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,
-        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,
-          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.error("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("editCustody CustodyKey", this.getCustodyKey(poolName, tokenMint).toBase58())
-    // console.log("editCustody 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,
-        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,
-        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,
-        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("oracle: ", (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;
-      });
-  };
-
-  getLiquidationPriceView = async (
-    wallet: PublicKey,
-    poolName: string,
-    tokenMint: PublicKey,
-    side: PositionSide,
-    addCollateral = new BN(0),
-    removeCollateral = new BN(0)
-  ) => {
-    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 = new BN(0),
-    removeCollateral = new BN(0)
-  ) => {
-    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;
-      });
-  };
-
-  // TODO: currently just static, need to write 
-  getLiquidationPrice =  (
-    postionKey: PublicKey,
-    postionData: Position,
-    tokenPrice: OraclePrice,
-    tokenEmaPrice: OraclePrice,
-    custodyAccount: CustodyAccount,
-    poolAccount: PoolAccount,
-    currentTime: BN,
-    addCollateral = new BN(0),
-    removeCollateral = new BN(0)
-  ) => {
-    // const positionAccount = PositionAccount.from(postionKey, postionData);
-    let x : BN; 
-    if (isVariant(postionData.side, 'long'))  {
-      x = tokenPrice.price.mul(new BN(90)).div(new BN(90))
-    } else {
-      x = tokenPrice.price.mul(new BN(100)).div(new BN(90))
-    }
-    return new OraclePrice({price: x ,exponent : tokenPrice.exponent})
-  };
-
-  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;
-      });
-  };
-
-  getPnlView = 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;
-      });
-  };
-
-
-  getPnl = (
-    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;
-      });
-  };
-
-  getAumView = 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;
-      });
-  };
-
-  getAumTrx = async (poolName: string) => {
-    return await this.program.methods
-      .getAssetsUnderManagement({})
-      .accounts({
-        perpetuals: this.perpetuals.publicKey,
-        pool: this.getPoolKey(poolName),
-      })
-      .remainingAccounts(await this.getCustodyMetas(poolName))
-      .rpc()
-      .catch((err) => {
-        console.error(err);
-        throw err;
-      });
-  };
-
-  getAumSdk = (
-    poolAccount: PoolAccount,
-    token_prices: OraclePrice[],
-    token_ema_prices: OraclePrice[],
-    custodies: CustodyAccount[],
-    aum_calc_mode: AumCalcMode,
-    currentTime: BN
-  ) => {
-    // console.log("poolAccount:",poolAccount);
-
-    return poolAccount.getAssetsUnderManagementUsd(
-      token_prices,
-      token_ema_prices,
-      custodies,
-      aum_calc_mode,
-      currentTime
-    );
-  };
-
-  // TODO:  handle SOL wrapping to WSOL and create a ATA - DONE
-  // TODO:  Balance checks - DONE
-  // TODO:  ATA check - else create  - DONE 
-  // Create WSOL Token account and not ATA and close it in end 
-  // TODO:  close other Accounts - NOT NEEDED
-  openPosition = async (
-    payTokenSymbol: string,
-    priceAfterSlippage: BN,
-    collateralWithfee: BN,
-    fee : BN,
-    size: BN,
-    side: Side,
-    poolConfig: PoolConfig,
-    createUserWSOLATA = true,  
-    skipBalanceChecks = false
-  ): Promise< { instructions : TransactionInstruction[] , additionalSigners: Signer[]} > => {
-
-    console.log("open position :::", payTokenSymbol, poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey.toBase58());
-
-    // const slippageMultiplier = isVariant(side, 'long') ? -1 : 1;
-    // const priceAfterSlippage = price.mul(new BN((100 - (slippagePercentage * slippageMultiplier)) * 100)).div(new BN(100 * 100))
-
-    let publicKey = this.provider.wallet.publicKey;
-    const payTokenCustody = poolConfig.custodies.find(i => i.mintKey.equals(poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey))!;
-
-    let userCustodyTokenAccount = await getAssociatedTokenAddress(
-      poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey,
-      publicKey
-    );
-
-    let wrappedSolAccount: Keypair | undefined;
-    let preInstructions: TransactionInstruction[] = [];
-    let instructions: TransactionInstruction[] = [];
-    let postInstructions: TransactionInstruction[] = [];
-    const additionalSigners: Signer[] = [];
-
-    try {
-
-      // https://github.com/blockworks-foundation/mango-v4/blob/1ba6513b5ea2b0e557808e712fcf0a811968b45b/ts/client/src/client.ts#L1252 
-      // Create WSOL Token account and not ATA and close it in end 
-      if (payTokenSymbol == 'SOL' && createUserWSOLATA) {
-        console.log("payTokenSymbol === sol", payTokenSymbol);
-        wrappedSolAccount = new Keypair();
-        const accCreationLamports = (await getMinimumBalanceForRentExemptAccount(this.provider.connection)); // for account creation
-        console.log("accCreationLamports:",accCreationLamports)
-        const lamports = collateralWithfee.add(new BN(accCreationLamports)); // for account creation
-
-        preInstructions = [
-          SystemProgram.createAccount({
-            fromPubkey: publicKey,
-            newAccountPubkey: wrappedSolAccount.publicKey,
-            lamports: lamports.toNumber(), //will this break for large amounts ??
-            space: 165,
-            programId: TOKEN_PROGRAM_ID,
-          }),
-          createInitializeAccount3Instruction(
-            wrappedSolAccount.publicKey,
-            NATIVE_MINT,
-            publicKey,
-          ),
-        ];
-        postInstructions = [
-          createCloseAccountInstruction(
-            wrappedSolAccount.publicKey,
-            publicKey,
-            publicKey,
-          ),
-        ];
-        additionalSigners.push(wrappedSolAccount);
-
-      } else if(createUserWSOLATA == false){
-        console.log("skip WSOL checks and creation ,since createUserWSOLATA == false")
-      } else {
-        // for other tokens check if ATA and balance 
-        if (!(await checkIfAccountExists(userCustodyTokenAccount, this.provider.connection))) {
-          throw "Insufficient Funds , token Account doesn't exist"
-        }
-
-        if(!skipBalanceChecks){
-          const tokenAccountBalance = new BN((await this.provider.connection.getTokenAccountBalance(userCustodyTokenAccount)).value.amount);
-          if (tokenAccountBalance.lt(collateralWithfee)) {
-            throw `Insufficient Funds need more ${collateralWithfee.sub(tokenAccountBalance)} tokens`
-          }
-        }
-       
-      }
-
-      // replace with getPositionKey()
-      let positionAccount = PublicKey.findProgramAddressSync(
-        [
-          Buffer.from("position"),
-          publicKey.toBuffer(),
-          poolConfig.poolAddress.toBuffer(),
-          payTokenCustody.custodyAccount.toBuffer(),
-          isVariant(side, 'long') ? Buffer.from([1]) : Buffer.from([2]),
-        ],
-        this.programId
-      )[0];
-
-      const params: any = {
-        price: priceAfterSlippage,
-        collateral : collateralWithfee,
-        size,
-        side,
-      };
-
-      let instruction = await this.program.methods
-        .openPosition(params)
-        .accounts({
-          owner: publicKey,
-          fundingAccount: payTokenSymbol == 'SOL' ? wrappedSolAccount.publicKey : userCustodyTokenAccount,
-          transferAuthority: poolConfig.transferAuthority,
-          perpetuals: poolConfig.perpetuals,
-          pool: poolConfig.poolAddress,
-          position: positionAccount,
-          custody: payTokenCustody.custodyAccount,
-          custodyOracleAccount:
-          payTokenCustody.oracleAddress,
-          custodyTokenAccount:
-          payTokenCustody.tokenAccount,
-          systemProgram: SystemProgram.programId,
-          tokenProgram: TOKEN_PROGRAM_ID,
-        }).instruction()
-
-        
-        instructions.push(instruction);
-
-    } catch (error) {
-      console.log("perpClient openPosition error:", error)
-    }
-    return {
-      instructions : [...preInstructions, ...instructions ,...postInstructions],
-      additionalSigners
-    };
-  }
-
-  // TODO: handle SOL wrapping to WSOL and create a ATA - NOT NEEDED
-  // TODO : Balance checks - NOT NEEDED
-  // TODO: ATA check - else create  - DONE 
-  // TODO: for close Accounts - DONE BY ANCHOR
-  // TODO : if out token WSOL -> unwrap to SOL - DONE
-  closePosition = async (
-    receivingTokenSymbol: string,
-    priceAfterSlippage: BN,
-    side: Side,
-    poolConfig: PoolConfig,
-    createUserATA = true,
-    closeUsersWSOLATA = false // to get back WSOL=>SOL
-  ): Promise< { instructions : TransactionInstruction[] , additionalSigners: Signer[]}> => {
-
-    console.log("close position :::", receivingTokenSymbol, poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey.toBase58());
-
-    // opp during close 
-    // const slippageMultiplier = isVariant(side, 'short') ? -1 : 1;
-    // const priceAfterSlippage = price.mul(new BN((100 - (slippagePercentage * slippageMultiplier)) * 100)).div(new BN(100 * 100))
-
-    let publicKey = this.provider.wallet.publicKey;
-
-    let userReceivingTokenAccount : PublicKey;
-    let wrappedSolAccount: Keypair | undefined;
-    let preInstructions: TransactionInstruction[] = [];
-    let instructions: TransactionInstruction[] = [];
-    let postInstructions: TransactionInstruction[] = [];
-    const additionalSigners: Signer[] = [];
-    try {
-
-      if (receivingTokenSymbol == 'SOL') {
-        wrappedSolAccount = new Keypair();
-        userReceivingTokenAccount = wrappedSolAccount.publicKey;
-        const lamports = (await getMinimumBalanceForRentExemptAccount(this.provider.connection)); // for account creation
-
-        preInstructions = [
-          SystemProgram.createAccount({
-            fromPubkey: publicKey,
-            newAccountPubkey: wrappedSolAccount.publicKey,
-            lamports: lamports, //will this break for large amounts ??
-            space: 165,
-            programId: TOKEN_PROGRAM_ID,
-          }),
-          createInitializeAccount3Instruction(
-            wrappedSolAccount.publicKey,
-            NATIVE_MINT,
-            publicKey,
-          ),
-        ];
-        postInstructions = [
-          createCloseAccountInstruction(
-            wrappedSolAccount.publicKey,
-            publicKey,
-            publicKey,
-          ),
-        ];
-        additionalSigners.push(wrappedSolAccount);
-      } else {
-
-        userReceivingTokenAccount = await getAssociatedTokenAddress(
-          poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey,
-          publicKey
-        );
-
-        if (createUserATA && !(await checkIfAccountExists(userReceivingTokenAccount, this.provider.connection))) {
-          preInstructions.push(
-            createAssociatedTokenAccountInstruction(
-              publicKey,
-              userReceivingTokenAccount,
-              publicKey,
-              poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey
-            )
-          );
-        }
-
-      }
-      
-
-      const receivingTokenCustody = poolConfig.custodies.find(i => i.mintKey.equals(poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey))!;
-
-      // replace with getPositionKey
-      let positionAccount = PublicKey.findProgramAddressSync(
-        [
-          Buffer.from("position"),
-          publicKey.toBuffer(),
-          poolConfig.poolAddress.toBuffer(),
-          receivingTokenCustody.custodyAccount.toBuffer(),
-          isVariant(side, 'long') ? Buffer.from([1]) : Buffer.from([2]),
-        ],
-        this.programId
-      )[0];
-
-      // console.log("positionAccount:", positionAccount.toBase58())
-      const params: any = {
-        price: priceAfterSlippage,
-      };
-
-      let instruction = await this.program.methods
-        .closePosition(params)
-        .accounts({
-          owner: publicKey,
-          receivingAccount: userReceivingTokenAccount,
-          transferAuthority: poolConfig.transferAuthority,
-          perpetuals: poolConfig.perpetuals,
-          pool: poolConfig.poolAddress,
-          position: positionAccount,
-          custody: receivingTokenCustody.custodyAccount,
-          custodyOracleAccount:
-            receivingTokenCustody.oracleAddress,
-          custodyTokenAccount:
-            receivingTokenCustody.tokenAccount,
-          tokenProgram: TOKEN_PROGRAM_ID,
-        }).instruction();
-      instructions.push(instruction)
-
-      if (receivingTokenSymbol == 'WSOL' && closeUsersWSOLATA) {
-        const closeWsolATAIns = createCloseAccountInstruction(userReceivingTokenAccount, publicKey, publicKey);
-        postInstructions.push(closeWsolATAIns);
-      }
-    } catch (error) {
-      console.error("perpclient closePosition error:", error);
-    }
-
-    return {
-      instructions : [...preInstructions, ...instructions ,...postInstructions],
-      additionalSigners
-    };
-  }
-
-
-  // ==== OLD 
-  // TODO:  handle SOL wrapping to WSOL and create a ATA - DONE
-  // TODO:  Balance checks - DONE
-  // TODO:  ATA check - else create  - DONE 
-  // TODO:  for close Accounts - NOT NEEDED
-  openPositionOld = async (
-    payTokenSymbol: string,
-    priceAfterSlippage: BN,
-    collateral: BN,
-    fee : BN,
-    size: BN,
-    side: Side,
-    poolConfig: PoolConfig,
-    createUserWSOLATA = true  // if false will also skip balance checks 
-  ): Promise<TransactionInstruction[]> => {
-
-    console.log("open position :::", payTokenSymbol, poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey.toBase58());
-
-    // const slippageMultiplier = isVariant(side, 'long') ? -1 : 1;
-    // const priceAfterSlippage = price.mul(new BN((100 - (slippagePercentage * slippageMultiplier)) * 100)).div(new BN(100 * 100))
-
-    let publicKey = this.provider.wallet.publicKey;
-    const payTokenCustody = poolConfig.custodies.find(i => i.mintKey.equals(poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey))!;
-
-    let userCustodyTokenAccount = await getAssociatedTokenAddress(
-      poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey,
-      publicKey
-    );
-
-    const instructions = [];
-    try {
-
-      if (payTokenSymbol == 'SOL' && createUserWSOLATA) {
-        console.log("payTokenSymbol === sol", payTokenSymbol);
-        const wsolAssociatedTokenAccount = userCustodyTokenAccount;
-        // await getAssociatedTokenAddress(
-        //   NATIVE_MINT,
-        //   publicKey
-        // );
-        const wsolATAExist = await checkIfAccountExists(wsolAssociatedTokenAccount, this.provider.connection)
-        if (!wsolATAExist) {
-          console.log("wsol ata does not exist");
-          instructions.push(
-            createAssociatedTokenAccountInstruction(
-              publicKey,
-              wsolAssociatedTokenAccount,
-              publicKey,
-              NATIVE_MINT
-            )
-          );
-        }
-
-        const collateralWithfee = collateral.add(fee);
-
-        // get balance of WSOL associated token account
-        const wsolBalance = new BN(wsolATAExist ? (await this.provider.connection.getTokenAccountBalance(wsolAssociatedTokenAccount)).value.amount : 0);
-        if (wsolBalance.lt(collateralWithfee)) {
-          console.log("WSOL balance insufficient \n so Convert SOL to WSOL"); 
-          let unWrappedSolBalance = new BN(await this.provider.connection.getBalance(publicKey));
-          const totalSolBal = unWrappedSolBalance.add(wsolBalance);
-          // const rentExemptSolNeedforATA = new BN(0.02 * LAMPORTS_PER_SOL);
-          // console.log("rentExemptSolNeedforATA:",rentExemptSolNeedforATA.toString())
-          //TODOD ::  add(rentExemptSolNeedforATA)
-          if (totalSolBal.lt(collateralWithfee)) {
-            throw "Insufficient SOL Funds"
-          } else {
-            console.log("SOL balance sufficient so transfer from SOL to WSOL ATA")
-          }
-
-          let conversionAmt = collateralWithfee.sub(wsolBalance);
-          console.log("conversionAmt:",conversionAmt.toString())
-          instructions.push(
-            SystemProgram.transfer({
-              fromPubkey: publicKey,
-              toPubkey: wsolAssociatedTokenAccount,
-              lamports: conversionAmt.toNumber(), // IS IT SAFE TO PUT AS NUMBER
-            }),
-            createSyncNativeInstruction(wsolAssociatedTokenAccount)
-          );
-        }
-      } else if(createUserWSOLATA == false){
-        console.log("skip WSOL checks and creation ,since createUserWSOLATA == false")
-      } else {
-        // for other tokens check if ATA and balance 
-        if (!(await checkIfAccountExists(userCustodyTokenAccount, this.provider.connection))) {
-          throw "Insufficient Funds , token Account doesn't exist"
-        }
-        const tokenAccountBalance = new BN((await this.provider.connection.getTokenAccountBalance(userCustodyTokenAccount)).value.amount);
-        if (tokenAccountBalance.lt(collateral.add(fee))) {
-          throw "Insufficient Funds"
-        }
-      }
-
-      // replace with getPositionKey()
-      let positionAccount = PublicKey.findProgramAddressSync(
-        [
-          Buffer.from("position"),
-          publicKey.toBuffer(),
-          poolConfig.poolAddress.toBuffer(),
-          payTokenCustody.custodyAccount.toBuffer(),
-          isVariant(side, 'long') ? Buffer.from([1]) : Buffer.from([2]),
-        ],
-        this.programId
-      )[0];
-
-      const params: any = {
-        price: priceAfterSlippage,
-        collateral,
-        size,
-        side,
-      };
-
-      let instruction = await this.program.methods
-        .openPosition(params)
-        .accounts({
-          owner: publicKey,
-          fundingAccount: userCustodyTokenAccount,
-          transferAuthority: poolConfig.transferAuthority,
-          perpetuals: poolConfig.perpetuals,
-          pool: poolConfig.poolAddress,
-          position: positionAccount,
-          custody: payTokenCustody.custodyAccount,
-          custodyOracleAccount:
-            payTokenCustody.oracleAddress,
-          custodyTokenAccount:
-            payTokenCustody.tokenAccount,
-          systemProgram: SystemProgram.programId,
-          tokenProgram: TOKEN_PROGRAM_ID,
-        }).instruction()
-      instructions.push(instruction);
-
-    } catch (error) {
-      console.log("perpClient openPosition error:", error)
-    }
-    return instructions;
-  }
-
-  // ==== OLD 
-  // TODO: handle SOL wrapping to WSOL and create a ATA - NOT NEEDED
-  // TODO : Balance checks - NOT NEEDED
-  // TODO: ATA check - else create  - DONE 
-  // TODO: for close Accounts - DONE BY ANCHOR
-  // TODO : if out token WSOL -> unwrap to SOL - DONE
-  closePositionOld = async (
-    receivingTokenSymbol: string,
-    priceAfterSlippage: BN,
-    side: Side,
-    poolConfig: PoolConfig
-  ): Promise<TransactionInstruction[]> => {
-
-    console.log("close position :::", receivingTokenSymbol, poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey.toBase58());
-
-    // opp during close 
-    // const slippageMultiplier = isVariant(side, 'short') ? -1 : 1;
-    // const priceAfterSlippage = price.mul(new BN((100 - (slippagePercentage * slippageMultiplier)) * 100)).div(new BN(100 * 100))
-
-    let publicKey = this.provider.wallet.publicKey;
-
-    let userReceivingTokenAccount = await getAssociatedTokenAddress(
-      poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey,
-      publicKey
-    );
-    const instructions = [];
-    try {
-
-      if (!(await checkIfAccountExists(userReceivingTokenAccount, this.provider.connection))) {
-        instructions.push(
-          createAssociatedTokenAccountInstruction(
-            publicKey,
-            userReceivingTokenAccount,
-            publicKey,
-            poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey
-          )
-        );
-      }
-
-      const receivingTokenCustody = poolConfig.custodies.find(i => i.mintKey.equals(poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey))!;
-
-      // replace with getPositionKey
-      let positionAccount = PublicKey.findProgramAddressSync(
-        [
-          Buffer.from("position"),
-          publicKey.toBuffer(),
-          poolConfig.poolAddress.toBuffer(),
-          receivingTokenCustody.custodyAccount.toBuffer(),
-          isVariant(side, 'long') ? Buffer.from([1]) : Buffer.from([2]),
-        ],
-        this.programId
-      )[0];
-
-      console.log("positionAccount:", positionAccount.toBase58())
-      const params: any = {
-        price: priceAfterSlippage,
-      };
-
-      let instruction = await this.program.methods
-        .closePosition(params)
-        .accounts({
-          owner: publicKey,
-          receivingAccount: userReceivingTokenAccount,
-          transferAuthority: poolConfig.transferAuthority,
-          perpetuals: poolConfig.perpetuals,
-          pool: poolConfig.poolAddress,
-          position: positionAccount,
-          custody: receivingTokenCustody.custodyAccount,
-          custodyOracleAccount:
-            receivingTokenCustody.oracleAddress,
-          custodyTokenAccount:
-            receivingTokenCustody.tokenAccount,
-          tokenProgram: TOKEN_PROGRAM_ID,
-        }).instruction();
-      instructions.push(instruction)
-
-      // SOL is only retrievable by closing the token account and choosing the desired address to send the token account's lamports.
-      if (receivingTokenSymbol == 'SOL') {
-        // await closeAccount()
-        const closeWsolATAIns = createCloseAccountInstruction(userReceivingTokenAccount, publicKey, publicKey);
-        instructions.push(closeWsolATAIns);
-      }
-    } catch (error) {
-      console.error("perpclient closePosition error:", error);
-    }
-
-    return instructions;
-  }
-
-
-
-  // TODO: ATA check - else create  - DONE 
-  // TODO: handle SOL wrapping to WSOL and create a ATA - DONE
-  // TODO : Balance checks - NOT NEEDED
-  // TODO: for close Accounts - DONE BY ANCHOR
-  // TODO : if out token WSOL -> unwrap to SOL - DONE
-  swap = async (
-    poolReceivingTokenSymbol: string,
-    poolDispensingTokenSymbol: string,
-    amountIn: BN,
-    minAmountOut: BN,
-    poolConfig: PoolConfig,
-    unWrapSol = false
-  ): Promise<TransactionInstruction[]> => {
-
-    const userReceivingTokenSymbol = poolDispensingTokenSymbol;
-    const userDispensingTokenSymbol= poolReceivingTokenSymbol;
-
-    const poolReceivingCustodyConfig = poolConfig.custodies.find(
-      (i) => i.mintKey.toBase58() === poolConfig.getTokenFromSymbol(poolReceivingTokenSymbol).mintKey.toBase58()
-    );
-    if (!poolReceivingCustodyConfig) {
-      throw "receivingTokenCustody  not found";
-    }
-    const poolDispensingCustodyConfig = poolConfig.custodies.find(
-      (i) => i.mintKey.toBase58() === poolConfig.getTokenFromSymbol(poolDispensingTokenSymbol).mintKey.toBase58()
-    );
-    if (!poolDispensingCustodyConfig) {
-      throw "dispensingTokenCustody  not found";
-    }
-    let publicKey = this.provider.wallet.publicKey;
-
-
-    const instructions = [];
-    try {
-      let userReceivingTokenAccount = await getAssociatedTokenAddress(
-        poolDispensingCustodyConfig.mintKey,
-        publicKey
-      );
-      if (!(await checkIfAccountExists(userReceivingTokenAccount, this.provider.connection))) {
-        instructions.push(
-          createAssociatedTokenAccountInstruction(
-            publicKey,
-            userReceivingTokenAccount,
-            publicKey,
-            poolDispensingCustodyConfig.mintKey
-          )
-        );
-      }
-
-      let userDispensingCustodyTokenAccount = await getAssociatedTokenAddress(
-        poolReceivingCustodyConfig.mintKey,
-        publicKey
-      );
-      // handle Wrapping of SOL if user input token is SOL
-      if (userDispensingTokenSymbol == 'SOL') {
-        console.log("userDispensingTokenSymbol === sol", userDispensingTokenSymbol);
-        const wsolAssociatedTokenAccount = await getAssociatedTokenAddress(
-          NATIVE_MINT,
-          publicKey
-        );
-        const wsolATAExist = await checkIfAccountExists(wsolAssociatedTokenAccount, this.provider.connection)
-        if (!wsolATAExist) {
-          console.log("wsol ata does not exist");
-          instructions.push(
-            createAssociatedTokenAccountInstruction(
-              publicKey,
-              wsolAssociatedTokenAccount,
-              publicKey,
-              NATIVE_MINT
-            )
-          );
-        }
-
-        // get balance of WSOL associated token account
-        const wsolBalance = new BN(wsolATAExist ? (await this.provider.connection.getTokenAccountBalance(wsolAssociatedTokenAccount)).value.amount : 0);
-        if (wsolBalance.lt(amountIn)) {
-          // console.log("WSOL balance insufficient");
-          // so Convert SOL to WSOL 
-          let unWrappedSolBalance = new BN(await this.provider.connection.getBalance(publicKey));
-          const totalSolBal = unWrappedSolBalance.add(wsolBalance);
-          if (totalSolBal.lt(amountIn)) {
-            throw "Insufficient SOL Funds"
-          }
-
-          let conversionAmt = amountIn.sub(wsolBalance);
-          instructions.push(
-            SystemProgram.transfer({
-              fromPubkey: publicKey,
-              toPubkey: wsolAssociatedTokenAccount,
-              lamports: conversionAmt.toNumber(), // IS IT SAFE TO PUT AS NUMBER ?
-            }),
-            createSyncNativeInstruction(wsolAssociatedTokenAccount)
-          );
-        }
-      } else {
-        if (!(await checkIfAccountExists(userDispensingCustodyTokenAccount, this.provider.connection))) {
-          throw "Insufficient Funds , Token Account doesn't exist"
-        }
-        const tokenAccountBalance = new BN((await this.provider.connection.getTokenAccountBalance(userDispensingCustodyTokenAccount)).value.amount);
-        if (tokenAccountBalance.lt(amountIn)) {
-          throw "Insufficient Funds"
-        }
-      }
-
-      const params = {
-        amountIn,
-        minAmountOut,
-      };
-      let inx = await this.program.methods
-        .swap(params)
-        .accounts({
-          owner: publicKey,
-          fundingAccount: userDispensingCustodyTokenAccount,
-          receivingAccount: userReceivingTokenAccount,
-          transferAuthority: poolConfig.transferAuthority,
-          perpetuals: poolConfig.perpetuals,
-          pool: poolConfig.poolAddress,
-
-          receivingCustody: poolReceivingCustodyConfig.custodyAccount,
-          receivingCustodyOracleAccount: poolReceivingCustodyConfig.oracleAddress,
-          receivingCustodyTokenAccount: poolReceivingCustodyConfig.tokenAccount,
-
-          dispensingCustody: poolDispensingCustodyConfig.custodyAccount,
-          dispensingCustodyOracleAccount: poolDispensingCustodyConfig.oracleAddress,
-          dispensingCustodyTokenAccount: poolDispensingCustodyConfig.tokenAccount,
-          tokenProgram: TOKEN_PROGRAM_ID,
-        })
-        .instruction();
-
-      instructions.push(inx)
-
-       // SOL is only retrievable by closing the token account and choosing the desired address to send the token account's lamports.
-       if (userReceivingTokenSymbol == 'SOL' && unWrapSol) {
-        // await closeAccount()
-        const closeWsolATAIns = createCloseAccountInstruction(userReceivingTokenAccount, publicKey, publicKey);
-        instructions.push(closeWsolATAIns);
-       }
-
-    } catch (err) {
-      console.error("perpClient Swap error:: ", err);
-      throw err;
-    }
-
-    return instructions;
-  }
-
-  addCollateral = async (
-    collateralWithoutFee: BN,
-    fee: BN,
-    collateralSymbol: string,
-    positionPubKey: PublicKey,
-    poolConfig: PoolConfig
-  ): Promise<TransactionInstruction[]> => {
-    let publicKey = this.provider.wallet.publicKey;
-
-    const custody = poolConfig.custodies.find(i => i.mintKey.equals(poolConfig.getTokenFromSymbol(collateralSymbol).mintKey))!;
-
-    if (!custody) {
-      throw "payTokenCustody  not found";
-    }
-
-    const instructions = [];
-
-    let userPayingTokenAccount = getAssociatedTokenAddressSync(
-      custody.mintKey,
-      publicKey
-    );
-
-    const collateralWithfee = collateralWithoutFee.add(fee);
-
-    if (collateralSymbol == 'SOL') {
-      console.log("collateralSymbol === sol", collateralSymbol);
-      const wsolAssociatedTokenAccount = await getAssociatedTokenAddress(
-        NATIVE_MINT,
-        publicKey
-      );
-
-      const wsolATAExist = await checkIfAccountExists(wsolAssociatedTokenAccount, this.provider.connection)
-      if (!wsolATAExist) {
-        console.log("wsol ata does not exist");
-        instructions.push(
-          createAssociatedTokenAccountInstruction(
-            publicKey,
-            wsolAssociatedTokenAccount,
-            publicKey,
-            NATIVE_MINT
-          )
-        );
-      }
-
-      // get balance of WSOL associated token account
-      const wsolBalance = new BN(wsolATAExist ? (await this.provider.connection.getTokenAccountBalance(wsolAssociatedTokenAccount)).value.amount : 0);
-      if (wsolBalance.lt(collateralWithfee)) {
-        // console.log("WSOL balance insufficient");
-        // so Convert SOL to WSOL 
-        let unWrappedSolBalance = new BN(await this.provider.connection.getBalance(publicKey));
-        const totalSolBal = unWrappedSolBalance.add(wsolBalance);
-        if (totalSolBal.lt(collateralWithfee)) {
-          throw "Insufficient SOL Funds"
-        }
-
-        let conversionAmt = collateralWithfee.sub(wsolBalance);
-        instructions.push(
-          SystemProgram.transfer({
-            fromPubkey: publicKey,
-            toPubkey: wsolAssociatedTokenAccount,
-            lamports: conversionAmt.toNumber(), // IS IT SAFE TO PUT AS NUMBER
-          }),
-          createSyncNativeInstruction(wsolAssociatedTokenAccount)
-        );
-      }
-    }
-
-    let inx = await this.program.methods.addCollateral({
-      collateral: collateralWithoutFee
-    }).accounts({
-      owner: publicKey,
-      position: positionPubKey,
-      fundingAccount: userPayingTokenAccount, // user token account for custody token account
-      transferAuthority: poolConfig.transferAuthority,
-      perpetuals: poolConfig.perpetuals,
-      pool: poolConfig.poolAddress,
-      custody: custody.custodyAccount,
-      custodyOracleAccount: custody.oracleAddress,
-      custodyTokenAccount: custody.tokenAccount,
-      tokenProgram: TOKEN_PROGRAM_ID,
-    })
-    .instruction();
-
-    instructions.push(inx)
-
-    return instructions
-  }
-
-  removeCollateral = async (
-    collateralWithoutFee: BN,
-    collateralSymbol: string,
-    positionPubKey: PublicKey,
-    poolConfig: PoolConfig
-  ): Promise<TransactionInstruction[]> => {
-    let publicKey = this.provider.wallet.publicKey;
-
-    const custody = poolConfig.custodies.find((i) =>
-      i.mintKey.equals(poolConfig.getTokenFromSymbol(collateralSymbol).mintKey)
-    )!
-
-    if (!custody) {
-      throw "payTokenCustody  not found";
-    }
-
-    const instructions = [];
-
-    let userReceivingTokenAccount = getAssociatedTokenAddressSync(
-      poolConfig.getTokenFromSymbol(collateralSymbol).mintKey,
-      publicKey!
-    )
-
-    if (!(await checkIfAccountExists(userReceivingTokenAccount, this.provider.connection))) {
-      instructions.push(
-        createAssociatedTokenAccountInstruction(
-          publicKey!,
-          userReceivingTokenAccount,
-          publicKey!,
-          poolConfig.getTokenFromSymbol(collateralSymbol).mintKey
-        )
-      )
-    }
-
-    const ix = await this.program.methods
-    .removeCollateral({
-        collateralUsd: collateralWithoutFee,
-    })
-    .accounts({
-        owner: publicKey!,
-        receivingAccount: userReceivingTokenAccount, // user token account for custody token account
-        transferAuthority: poolConfig.transferAuthority,
-        perpetuals: poolConfig.perpetuals,
-        pool: poolConfig.poolAddress,
-        position: positionPubKey,
-        custody: custody.custodyAccount,
-        custodyOracleAccount: custody.oracleAddress,
-        custodyTokenAccount: custody.tokenAccount,
-        tokenProgram: TOKEN_PROGRAM_ID,
-    })
-    .instruction()
-
-    instructions.push(ix)
-
-    if (collateralSymbol === 'SOL') {
-      const closeWsolATAIns = createCloseAccountInstruction(userReceivingTokenAccount, publicKey!, publicKey!)
-      instructions.push(closeWsolATAIns)
-    }
-
-    return instructions
-  }
-
-  // TODO: handle SOL wrapping to WSOL and create a ATA - DONE
-  // TODO :Balance checks - DONE
-  // TODO: ATA check - else create  - DONE 
-  // TODO: for close Accounts - NOT NEEDED
-  addLiquidity = async (
-    payTokenSymbol: string,
-    tokenAmountIn: BN,
-    minLpAmountOut: BN, // give this value based on slippage 
-    poolConfig: PoolConfig
-  ): Promise<TransactionInstruction[]> => {
-
-    const payTokenCustody = poolConfig.custodies.find(i => i.mintKey.equals(poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey))!;
-    if (!payTokenCustody) {
-      throw "payTokenCustody  not found";
-    }
-    let publicKey = this.provider.wallet.publicKey;
-
-    const instructions = [];
-    try {
-
-      let userPayingTokenAccount = await getAssociatedTokenAddress(
-        payTokenCustody.mintKey,
-        publicKey
-      );
-
-      let lpTokenAccount = await getAssociatedTokenAddress(
-        poolConfig.lpTokenMint,
-        publicKey
-      );
-
-      let custodyAccountMetas = [];
-      let custodyOracleAccountMetas = [];
-      for (const custody of poolConfig.custodies) {
-        custodyAccountMetas.push({
-          pubkey: custody.custodyAccount,
-          isSigner: false,
-          isWritable: false,
-        });
-
-        custodyOracleAccountMetas.push({
-          pubkey: custody.oracleAddress,
-          isSigner: false,
-          isWritable: false,
-        });
-      }
-
-      if (!(await checkIfAccountExists(lpTokenAccount, this.provider.connection))) {
-        instructions.push(
-          createAssociatedTokenAccountInstruction(
-            publicKey,
-            lpTokenAccount,
-            publicKey,
-            poolConfig.lpTokenMint
-          )
-        );
-      }
-
-      if (payTokenSymbol == 'SOL') {
-        console.log("payTokenSymbol === sol", payTokenSymbol);
-        const wsolAssociatedTokenAccount = await getAssociatedTokenAddress(
-          NATIVE_MINT,
-          publicKey
-        );
-
-        const wsolATAExist = await checkIfAccountExists(wsolAssociatedTokenAccount, this.provider.connection)
-        if (!wsolATAExist) {
-          console.log("wsol ata does not exist");
-          instructions.push(
-            createAssociatedTokenAccountInstruction(
-              publicKey,
-              wsolAssociatedTokenAccount,
-              publicKey,
-              NATIVE_MINT
-            )
-          );
-        }
-
-        // get balance of WSOL associated token account
-        const wsolBalance = new BN(wsolATAExist ? (await this.provider.connection.getTokenAccountBalance(wsolAssociatedTokenAccount)).value.amount : 0);
-        if (wsolBalance.lt(tokenAmountIn)) {
-          // console.log("WSOL balance insufficient");
-          // so Convert SOL to WSOL 
-          let unWrappedSolBalance = new BN(await this.provider.connection.getBalance(publicKey));
-          const totalSolBal = unWrappedSolBalance.add(wsolBalance);
-          if (totalSolBal.lt(tokenAmountIn)) {
-            throw "Insufficient SOL Funds"
-          }
-
-          let conversionAmt = tokenAmountIn.sub(wsolBalance);
-          instructions.push(
-            SystemProgram.transfer({
-              fromPubkey: publicKey,
-              toPubkey: wsolAssociatedTokenAccount,
-              lamports: conversionAmt.toNumber(), // IS IT SAFE TO PUT AS NUMBER
-            }),
-            createSyncNativeInstruction(wsolAssociatedTokenAccount)
-          );
-        }
-      } else {
-        if (!(await checkIfAccountExists(userPayingTokenAccount, this.provider.connection))) {
-          throw "Insufficient Funds , token Account doesn't exist"
-        }
-        const tokenAccountBalance = new BN((await this.provider.connection.getTokenAccountBalance(userPayingTokenAccount)).value.amount);
-        if (tokenAccountBalance.lt(tokenAmountIn)) {
-          throw "Insufficient Funds"
-        }
-      }
-
-      // console.log("in add liq", tokenAmountIn);
-
-      let inx = await this.program.methods
-        .addLiquidity({
-          amountIn: tokenAmountIn,
-          minLpAmountOut
-        })
-        .accounts({
-          owner: publicKey,
-          fundingAccount: userPayingTokenAccount, // user token account for custody token account
-          lpTokenAccount,
-          transferAuthority: poolConfig.transferAuthority,
-          perpetuals: poolConfig.perpetuals,
-          pool: poolConfig.poolAddress,
-          custody: payTokenCustody.custodyAccount,
-          custodyOracleAccount: payTokenCustody.oracleAddress,
-          custodyTokenAccount: payTokenCustody.tokenAccount,
-          lpTokenMint: poolConfig.lpTokenMint,
-          tokenProgram: TOKEN_PROGRAM_ID,
-        })
-        .remainingAccounts([...custodyAccountMetas, ...custodyOracleAccountMetas])
-        .instruction();
-
-      instructions.push(inx)
-    } catch (err) {
-      console.error("perpClient addLiquidity error:: ", err);
-      throw err;
-    }
-
-    return instructions;
-  }
-  // TODO: handle SOL wrapping to WSOL and create a ATA - NOT NEEDED
-  // TODO :Balance checks - DONE
-  // TODO: ATA check - else create  - DONE 
-  // TODO: for LP close Accounts - DONE
-  // TODO : if out token WSOL -> unwrap to SOL - DONE
-  removeLiquidity = async (
-    recieveTokenSymbol: string,
-    liquidityAmountIn: BN,
-    minTokenAmountOut: BN, // give this value based on slippage 
-    poolConfig: PoolConfig,
-    closeLpATA = false
-  ): Promise<TransactionInstruction[]> => {
-
-    const recieveTokenCustody = poolConfig.custodies.find(i => i.mintKey.equals(poolConfig.getTokenFromSymbol(recieveTokenSymbol).mintKey))!;
-    if (!recieveTokenCustody) {
-      throw "recieveTokenCustody not found";
-    }
-    let publicKey = this.provider.wallet.publicKey;
-
-    const instructions = [];
-    try {
-      let userRecievingTokenAccount = await getAssociatedTokenAddress(
-        recieveTokenCustody.mintKey,
-        publicKey
-      );
-
-      if (!(await checkIfAccountExists(userRecievingTokenAccount, this.provider.connection))) {
-        instructions.push(
-          createAssociatedTokenAccountInstruction(
-            publicKey,
-            userRecievingTokenAccount,
-            publicKey,
-            recieveTokenCustody.mintKey
-          )
-        );
-      }
-      let lpTokenAccount = await getAssociatedTokenAddress(
-        poolConfig.lpTokenMint,
-        publicKey
-      );
-
-      let custodyAccountMetas = [];
-      let custodyOracleAccountMetas = [];
-      for (const custody of poolConfig.custodies) {
-        custodyAccountMetas.push({
-          pubkey: custody.custodyAccount,
-          isSigner: false,
-          isWritable: false,
-        });
-
-        custodyOracleAccountMetas.push({
-          pubkey: custody.oracleAddress,
-          isSigner: false,
-          isWritable: false,
-        });
-      }
-
-      console.log("liquidityAmountIn", liquidityAmountIn.toString());
-
-      let removeLiquidityTx = await this.program.methods
-        .removeLiquidity({
-          lpAmountIn: liquidityAmountIn,
-          minAmountOut: minTokenAmountOut
-        })
-        .accounts({
-          owner: publicKey,
-          receivingAccount: userRecievingTokenAccount, // user token account for custody token account
-          lpTokenAccount,
-          transferAuthority: poolConfig.transferAuthority,
-          perpetuals: poolConfig.perpetuals,
-          pool: poolConfig.poolAddress,
-          custody: recieveTokenCustody.custodyAccount,
-          custodyOracleAccount: recieveTokenCustody.oracleAddress,
-          custodyTokenAccount: recieveTokenCustody.tokenAccount,
-          lpTokenMint: poolConfig.lpTokenMint,
-          tokenProgram: TOKEN_PROGRAM_ID,
-        })
-        .remainingAccounts([...custodyAccountMetas, ...custodyOracleAccountMetas])
-        .instruction();
-      instructions.push(removeLiquidityTx)
-
-      if (closeLpATA) {
-        const closeInx = createCloseAccountInstruction(lpTokenAccount, publicKey, publicKey);
-        instructions.push(closeInx);
-      }
-
-      // SOL is only retrievable by closing the token account and choosing the desired address to send the token account's lamports.
-      if (recieveTokenSymbol == 'SOL') {
-        // await closeAccount()
-        const closeWsolATAIns = createCloseAccountInstruction(userRecievingTokenAccount, publicKey, publicKey);
-        instructions.push(closeWsolATAIns);
-       }
-      
-    } catch (err) {
-      console.log("perpClient removeLiquidity error:: ", err);
-      throw err;
-    }
-
-    return instructions;
-  }
-
-  public async sendTransaction(
-    ixs: TransactionInstruction[],
-    opts: any = {},
-  ): Promise<string> {
-    return await sendTransaction(
-      this.program.provider as AnchorProvider,
-      ixs,
-      opts.alts ?? [],
-      {
-        postSendTxCallback: this.postSendTxCallback,
-        prioritizationFee: this.prioritizationFee,
-        txConfirmationCommitment: this.txConfirmationCommitment,
-        ...opts,
-      },
-    );
-  }
-
-}
-
-