flash-sdk 1.0.4 → 1.0.6

package/src/PerpetualsClient.ts

@@ -14,6 +14,8 @@ import {
   AccountMeta,
   Keypair,
   SYSVAR_RENT_PUBKEY,
+  Commitment,
+  LAMPORTS_PER_SOL,
 } from "@solana/web3.js";
 import {
   getAccount,
@@ -22,22 +24,26 @@ import {
   createCloseAccountInstruction,
   createSyncNativeInstruction,
   TOKEN_PROGRAM_ID,
+  NATIVE_MINT,
 } from "@solana/spl-token";
 
 import { sha256 } from "js-sha256";
 import { encode } from "bs58";
 import { PoolAccount } from "./PoolAccount";
 import { PositionAccount } from "./PositionAccount";
-import { BorrowRateParams, Custody, Fees, OracleParams, Permissions, Position, PositionSide, PricingParams, TokenRatios, isVariant } from "./types";
+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 "./target/types/perpetuals";
-import {IDL}  from './target/types/perpetuals';
+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 ---  
+UI -----  
 provider = from phatom 
 
 client = new PerpetualsClient(provider, user.pubkey , programId);
@@ -56,6 +62,13 @@ 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>;
@@ -67,7 +80,11 @@ export class PerpetualsClient {
   authority: { publicKey: PublicKey; bump: number };
   perpetuals: { publicKey: PublicKey; bump: number };
 
-  constructor(provider: AnchorProvider, programId: PublicKey) {
+  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",
@@ -80,27 +97,32 @@ export class PerpetualsClient {
     // 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.program = new Program(IDL, programId);
+    this.programId = programId;
     //this.program =  workspace.Perpetuals as Program<Perpetuals>;
-    console.log("client constructor programID : ",this.program.programId.toBase58());
+    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.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) => {
+  findProgramAddress = (label: string, extraSeeds: any = null) => {
     let seeds = [Buffer.from(utils.bytes.utf8.encode(label))];
     if (extraSeeds) {
       for (let extraSeed of extraSeeds) {
@@ -117,7 +139,7 @@ export class PerpetualsClient {
     return { publicKey: res[0], bump: res[1] };
   };
 
-  adjustTokenRatios = (ratios : TokenRatios[]) => {
+  adjustTokenRatios = (ratios: TokenRatios[]) => {
     if (ratios.length == 0) {
       return ratios;
     }
@@ -145,7 +167,7 @@ export class PerpetualsClient {
   };
 
   getPool = async (name: string) => {
-    console.log("pool:",this.getPoolKey(name).toBase58())
+    console.log("pool:", this.getPoolKey(name).toBase58())
     return this.program.account.pool.fetch(this.getPoolKey(name));
   };
 
@@ -189,7 +211,7 @@ export class PerpetualsClient {
   };
 
   getCustody = async (poolName: string, tokenMint: PublicKey) => {
-    console.log("custody key :",this.getCustodyKey(poolName, tokenMint).toBase58());
+    console.log("custody key :", this.getCustodyKey(poolName, tokenMint).toBase58());
     return this.program.account.custody.fetch(
       this.getCustodyKey(poolName, tokenMint)
     );
@@ -197,7 +219,7 @@ export class PerpetualsClient {
 
   getCustodies = async (poolName: string) => {
     //return this.program.account.custody.all();
-    let pool  = await this.getPool(poolName);
+    let pool = await this.getPool(poolName);
     return this.program.account.custody.fetchMultiple(
       pool.custodies
     );
@@ -205,7 +227,7 @@ export class PerpetualsClient {
 
   getCustodyMetas = async (poolName: string) => {
     let pool = await this.getPool(poolName);
-    let custodies :any = await this.program.account.custody.fetchMultiple(
+    let custodies: any = await this.program.account.custody.fetchMultiple(
       pool.custodies
     );
     let custodyMetas = [];
@@ -246,7 +268,7 @@ export class PerpetualsClient {
     ]).publicKey;
   };
 
-  getPosition = async (postionKey : PublicKey) => {
+  getPosition = async (postionKey: PublicKey) => {
     return this.program.account.position.fetch(postionKey);
   };
 
@@ -433,55 +455,55 @@ export class PerpetualsClient {
     poolName: string,
     tokenMint: PublicKey,
     isStable: boolean,
-    oracle : OracleParams,
+    oracle: OracleParams,
     pricing: PricingParams,
-    permissions : Permissions,
-    fees : Fees,
-    borrowRate : BorrowRateParams,
-    ratios : TokenRatios[]
+    permissions: Permissions,
+    fees: Fees,
+    borrowRate: BorrowRateParams,
+    ratios: TokenRatios[]
   ) => {
-    console.log("CustodyKey",  this.getCustodyKey(poolName, tokenMint).toBase58())
-    console.log("getCustodyTokenAccountKey",  this.getCustodyTokenAccountKey(poolName, tokenMint).toBase58())
+    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;
-      });
+      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.log("cli error :",error);
+      console.log("cli error :", error);
     }
-    
+
 
   };
 
@@ -489,18 +511,18 @@ export class PerpetualsClient {
     poolName: string,
     tokenMint: PublicKey,
     isStable: boolean,
-    oracle : OracleParams,
+    oracle: OracleParams,
     pricing: PricingParams,
-    permissions : Permissions,
-    fees : Fees,
-    borrowRate : BorrowRateParams,
-    ratios : TokenRatios[]
+    permissions: Permissions,
+    fees: Fees,
+    borrowRate: BorrowRateParams,
+    ratios: TokenRatios[]
   ) => {
-    console.log("CustodyKey",  this.getCustodyKey(poolName, tokenMint).toBase58())
-    console.log("getCustodyTokenAccountKey",  this.getCustodyTokenAccountKey(poolName, tokenMint).toBase58())
+    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
+    const trx_id = await this.program.methods
+      //@ts-ignore
       .testingEditCustody({
         isStable,
         oracle,
@@ -532,10 +554,10 @@ export class PerpetualsClient {
         console.error(err);
         throw err;
       });
-      console.log("trx_id:", `https://explorer.solana.com/tx/${trx_id}?cluster=devnet`)
+    console.log("trx_id:", `https://explorer.solana.com/tx/${trx_id}?cluster=devnet`)
   };
 
-  removeCustody = async (poolName: string, tokenMint: PublicKey, ratios:TokenRatios[]) => {
+  removeCustody = async (poolName: string, tokenMint: PublicKey, ratios: TokenRatios[]) => {
     await this.program.methods
       .removeCustody({ ratios })
       .accounts({
@@ -646,7 +668,7 @@ export class PerpetualsClient {
     amount: BN
   ) => {
     return await this.program.methods
-      .getAddLiquidityAmountAndFee({ 
+      .getAddLiquidityAmountAndFee({
         amountIn: amount,
       })
       .accounts({
@@ -667,8 +689,6 @@ export class PerpetualsClient {
       });
   };
 
-
-
   getRemoveLiquidityAmountAndFee = async (
     poolName: string,
     tokenMint: PublicKey,
@@ -699,23 +719,23 @@ export class PerpetualsClient {
   getEntryPriceAndFee = async (
     poolName: string,
     tokenMint: PublicKey,
-    collateral:  BN,
-    size:  BN,
+    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())
+    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({ 
+      //@ts-ignore
+      .getEntryPriceAndFee({
         collateral,
         size,
-        side: side == "long" ? { long: {} } : { short: {} }, 
+        side: side == "long" ? { long: {} } : { short: {} },
       })
       .accounts({
         // signer: this.provider.wallet.publicKey,
@@ -886,7 +906,7 @@ export class PerpetualsClient {
     side: PositionSide
   ) => {
     const pos = this.getPositionKey(wallet, poolName, tokenMint, side);
-    console.log("pos:",pos.toBase58())
+    console.log("pos:", pos.toBase58())
     return await this.program.methods
       .getPnl({})
       .accounts({
@@ -914,7 +934,7 @@ export class PerpetualsClient {
     side: PositionSide
   ) => {
     const pos = this.getPositionKey(wallet, poolName, tokenMint, side);
-    console.log("pos:",pos.toBase58())
+    console.log("pos:", pos.toBase58())
     return await this.program.methods
       .getPnl({})
       .accounts({
@@ -935,33 +955,33 @@ export class PerpetualsClient {
   };
 
 
-  getPnl2 =  (
-    postionKey : PublicKey,
+  getPnl2 = (
+    postionKey: PublicKey,
     postionData: Position,
-    tokenPrice : OraclePrice,
-    tokenEmaPrice : OraclePrice,
-    custodyAccount : CustodyAccount,
-    poolAccount : PoolAccount,
-    currentTime : BN
+    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(
+    let { profit, loss, exitFee } = poolAccount.getPnlUsd(
       positionAccount,
       tokenPrice,
       tokenEmaPrice,
       custodyAccount,
       currentTime,
       false,
-      );
+    );
 
-      return {
-        profit,
-        loss
-      }
+    return {
+      profit,
+      loss
+    }
 
   }
 
@@ -996,7 +1016,7 @@ export class PerpetualsClient {
       });
   };
 
-  getAum = async (poolName: string) => {
+  getAumView = async (poolName: string) => {
     return await this.program.methods
       .getAssetsUnderManagement({})
       .accounts({
@@ -1010,4 +1030,651 @@ export class PerpetualsClient {
         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 
+  // TODO:  for close Accounts - NOT NEEDED
+  openPosition = async (
+    payTokenSymbol: string,
+    price: BN,
+    collateral: BN,
+    size: BN,
+    side: Side,
+    slippagePercentage: number,
+    poolConfig: PoolConfig
+  ): 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') {
+        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(collateral)) {
+          // 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(collateral)) {
+            throw "Insufficient SOL Funds"
+          }
+
+          let conversionAmt = collateral.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(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)) {
+          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;
+  }
+
+  // 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,
+    price: BN,
+    side: Side,
+    slippagePercentage: number,
+    poolConfig: PoolConfig
+  ): Promise<TransactionInstruction[]> => {
+
+    console.log("close position :::", receivingTokenSymbol, poolConfig.getTokenFromSymbol(receivingTokenSymbol).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;
+
+    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 (
+    receivingTokenSymbol: string,
+    dispensingTokenSymbol: string,
+    amountIn: BN,
+    minAmountOut: BN,
+    poolConfig: PoolConfig
+  ): Promise<TransactionInstruction[]> => {
+
+    const receivingTokenCustody = poolConfig.custodies.find(
+      (i) => i.mintKey.toBase58() === poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey.toBase58()
+    );
+    if (!receivingTokenCustody) {
+      throw "receivingTokenCustody  not found";
+    }
+    const dispensingTokenCustody = poolConfig.custodies.find(
+      (i) => i.mintKey.toBase58() === poolConfig.getTokenFromSymbol(dispensingTokenSymbol).mintKey.toBase58()
+    );
+    if (!dispensingTokenCustody) {
+      throw "dispensingTokenCustody  not found";
+    }
+    let publicKey = this.provider.wallet.publicKey;
+
+
+    const instructions = [];
+    try {
+      let receivingTokenAccount = await getAssociatedTokenAddress(
+        receivingTokenCustody.mintKey,
+        publicKey
+      );
+      if (!(await checkIfAccountExists(receivingTokenAccount, this.provider.connection))) {
+        instructions.push(
+          createAssociatedTokenAccountInstruction(
+            publicKey,
+            receivingTokenAccount,
+            publicKey,
+            receivingTokenCustody.mintKey
+          )
+        );
+      }
+
+      let dispensingCustodyTokenAccount = await getAssociatedTokenAddress(
+        dispensingTokenCustody.mintKey,
+        publicKey
+      );
+      if (dispensingTokenSymbol == 'SOL') {
+        console.log("dispensingTokenSymbol === sol", dispensingTokenSymbol);
+        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(dispensingCustodyTokenAccount, this.provider.connection))) {
+          throw "Insufficient Funds , Token Account doesn't exist"
+        }
+        const tokenAccountBalance = new BN((await this.provider.connection.getTokenAccountBalance(dispensingCustodyTokenAccount)).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: dispensingCustodyTokenAccount,
+          receivingAccount: receivingTokenAccount,
+          transferAuthority: poolConfig.transferAuthority,
+          perpetuals: poolConfig.perpetuals,
+          pool: poolConfig.poolAddress,
+
+          receivingCustody: dispensingTokenCustody.custodyAccount,
+          receivingCustodyOracleAccount: dispensingTokenCustody.oracleAddress,
+          receivingCustodyTokenAccount: dispensingTokenCustody.tokenAccount,
+
+          dispensingCustody: receivingTokenCustody.custodyAccount,
+          dispensingCustodyOracleAccount: receivingTokenCustody.oracleAddress,
+          dispensingCustodyTokenAccount: receivingTokenCustody.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 (receivingTokenSymbol == 'SOL') {
+        // await closeAccount()
+        const closeWsolATAIns = createCloseAccountInstruction(receivingTokenAccount, publicKey, publicKey);
+        instructions.push(closeWsolATAIns);
+       }
+
+    } catch (err) {
+      console.log("perpClient Swap error:: ", err);
+      throw err;
+    }
+
+    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.log("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,
+      },
+    );
+  }
+
 }
+
+