flash-sdk 1.0.4 → 1.0.6

package/lib/PerpetualsClient.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -35,6 +46,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PerpetualsClient = void 0;
 var anchor_1 = require("@coral-xyz/anchor");
@@ -43,31 +63,14 @@ var spl_token_1 = require("@solana/spl-token");
 var js_sha256_1 = require("js-sha256");
 var bs58_1 = require("bs58");
 var PositionAccount_1 = require("./PositionAccount");
-var perpetuals_1 = require("./target/types/perpetuals");
-/* 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);
-
-*/
+var types_1 = require("./types");
+var perpetuals_1 = require("./idl/perpetuals");
+var rpc_1 = require("./utils/rpc");
+var utils_1 = require("./utils");
 var PerpetualsClient = /** @class */ (function () {
-    function PerpetualsClient(provider, programId) {
+    function PerpetualsClient(provider, programId, opts) {
         var _this = this;
+        var _a;
         this.findProgramAddress = function (label, extraSeeds) {
             if (extraSeeds === void 0) { extraSeeds = null; }
             var seeds = [Buffer.from(anchor_1.utils.bytes.utf8.encode(label))];
@@ -990,7 +993,7 @@ var PerpetualsClient = /** @class */ (function () {
                 }
             });
         }); };
-        this.getAum = function (poolName) { return __awaiter(_this, void 0, void 0, function () {
+        this.getAumView = function (poolName) { return __awaiter(_this, void 0, void 0, function () {
             var _a, _b;
             return __generator(this, function (_c) {
                 switch (_c.label) {
@@ -1013,6 +1016,567 @@ var PerpetualsClient = /** @class */ (function () {
                 }
             });
         }); };
+        this.getAumTrx = function (poolName) { return __awaiter(_this, void 0, void 0, function () {
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _b = (_a = this.program.methods
+                            .getAssetsUnderManagement({})
+                            .accounts({
+                            perpetuals: this.perpetuals.publicKey,
+                            pool: this.getPoolKey(poolName),
+                        }))
+                            .remainingAccounts;
+                        return [4 /*yield*/, this.getCustodyMetas(poolName)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.sent()])
+                            .rpc()
+                            .catch(function (err) {
+                            console.error(err);
+                            throw err;
+                        })];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        }); };
+        this.getAumSdk = function (poolAccount, token_prices, token_ema_prices, custodies, aum_calc_mode, currentTime) {
+            // 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
+        this.openPosition = function (payTokenSymbol, price, collateral, size, side, slippagePercentage, poolConfig) { return __awaiter(_this, void 0, void 0, function () {
+            var slippageMultiplier, priceAfterSlippage, publicKey, payTokenCustody, userCustodyTokenAccount, instructions, wsolAssociatedTokenAccount, wsolATAExist, wsolBalance, _a, _b, unWrappedSolBalance, _c, totalSolBal, conversionAmt, tokenAccountBalance, _d, positionAccount, params, instruction, error_2;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        console.log("open position :::", payTokenSymbol, poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey.toBase58());
+                        slippageMultiplier = (0, types_1.isVariant)(side, 'long') ? -1 : 1;
+                        priceAfterSlippage = price.mul(new anchor_1.BN((100 - (slippagePercentage * slippageMultiplier)) * 100)).div(new anchor_1.BN(100 * 100));
+                        publicKey = this.provider.wallet.publicKey;
+                        payTokenCustody = poolConfig.custodies.find(function (i) { return i.mintKey.equals(poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey); });
+                        return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey, publicKey)];
+                    case 1:
+                        userCustodyTokenAccount = _e.sent();
+                        instructions = [];
+                        _e.label = 2;
+                    case 2:
+                        _e.trys.push([2, 15, , 16]);
+                        if (!(payTokenSymbol == 'SOL')) return [3 /*break*/, 10];
+                        console.log("payTokenSymbol === sol", payTokenSymbol);
+                        return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(spl_token_1.NATIVE_MINT, publicKey)];
+                    case 3:
+                        wsolAssociatedTokenAccount = _e.sent();
+                        return [4 /*yield*/, (0, utils_1.checkIfAccountExists)(wsolAssociatedTokenAccount, this.provider.connection)];
+                    case 4:
+                        wsolATAExist = _e.sent();
+                        if (!wsolATAExist) {
+                            console.log("wsol ata does not exist");
+                            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, wsolAssociatedTokenAccount, publicKey, spl_token_1.NATIVE_MINT));
+                        }
+                        _a = anchor_1.BN.bind;
+                        if (!wsolATAExist) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.provider.connection.getTokenAccountBalance(wsolAssociatedTokenAccount)];
+                    case 5:
+                        _b = (_e.sent()).value.amount;
+                        return [3 /*break*/, 7];
+                    case 6:
+                        _b = 0;
+                        _e.label = 7;
+                    case 7:
+                        wsolBalance = new (_a.apply(anchor_1.BN, [void 0, _b]))();
+                        if (!wsolBalance.lt(collateral)) return [3 /*break*/, 9];
+                        _c = anchor_1.BN.bind;
+                        return [4 /*yield*/, this.provider.connection.getBalance(publicKey)];
+                    case 8:
+                        unWrappedSolBalance = new (_c.apply(anchor_1.BN, [void 0, _e.sent()]))();
+                        totalSolBal = unWrappedSolBalance.add(wsolBalance);
+                        if (totalSolBal.lt(collateral)) {
+                            throw "Insufficient SOL Funds";
+                        }
+                        conversionAmt = collateral.sub(wsolBalance);
+                        instructions.push(web3_js_1.SystemProgram.transfer({
+                            fromPubkey: publicKey,
+                            toPubkey: wsolAssociatedTokenAccount,
+                            lamports: conversionAmt.toNumber(), // IS IT SAFE TO PUT AS NUMBER
+                        }), (0, spl_token_1.createSyncNativeInstruction)(wsolAssociatedTokenAccount));
+                        _e.label = 9;
+                    case 9: return [3 /*break*/, 13];
+                    case 10: return [4 /*yield*/, (0, utils_1.checkIfAccountExists)(userCustodyTokenAccount, this.provider.connection)];
+                    case 11:
+                        if (!(_e.sent())) {
+                            throw "Insufficient Funds , token Account doesn't exist";
+                        }
+                        _d = anchor_1.BN.bind;
+                        return [4 /*yield*/, this.provider.connection.getTokenAccountBalance(userCustodyTokenAccount)];
+                    case 12:
+                        tokenAccountBalance = new (_d.apply(anchor_1.BN, [void 0, (_e.sent()).value.amount]))();
+                        if (tokenAccountBalance.lt(collateral)) {
+                            throw "Insufficient Funds";
+                        }
+                        _e.label = 13;
+                    case 13:
+                        positionAccount = web3_js_1.PublicKey.findProgramAddressSync([
+                            Buffer.from("position"),
+                            publicKey.toBuffer(),
+                            poolConfig.poolAddress.toBuffer(),
+                            payTokenCustody.custodyAccount.toBuffer(),
+                            (0, types_1.isVariant)(side, 'long') ? Buffer.from([1]) : Buffer.from([2]),
+                        ], this.programId)[0];
+                        params = {
+                            price: priceAfterSlippage,
+                            collateral: collateral,
+                            size: size,
+                            side: side,
+                        };
+                        return [4 /*yield*/, 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: web3_js_1.SystemProgram.programId,
+                                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                            }).instruction()];
+                    case 14:
+                        instruction = _e.sent();
+                        instructions.push(instruction);
+                        return [3 /*break*/, 16];
+                    case 15:
+                        error_2 = _e.sent();
+                        console.log("perpClient openPosition error:", error_2);
+                        return [3 /*break*/, 16];
+                    case 16: return [2 /*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
+        this.closePosition = function (receivingTokenSymbol, price, side, slippagePercentage, poolConfig) { return __awaiter(_this, void 0, void 0, function () {
+            var slippageMultiplier, priceAfterSlippage, publicKey, userReceivingTokenAccount, instructions, receivingTokenCustody, positionAccount, params, instruction, closeWsolATAIns, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("close position :::", receivingTokenSymbol, poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey.toBase58());
+                        slippageMultiplier = (0, types_1.isVariant)(side, 'long') ? -1 : 1;
+                        priceAfterSlippage = price.mul(new anchor_1.BN((100 - (slippagePercentage * slippageMultiplier)) * 100)).div(new anchor_1.BN(100 * 100));
+                        publicKey = this.provider.wallet.publicKey;
+                        return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey, publicKey)];
+                    case 1:
+                        userReceivingTokenAccount = _a.sent();
+                        instructions = [];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 5, , 6]);
+                        return [4 /*yield*/, (0, utils_1.checkIfAccountExists)(userReceivingTokenAccount, this.provider.connection)];
+                    case 3:
+                        if (!(_a.sent())) {
+                            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, userReceivingTokenAccount, publicKey, poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey));
+                        }
+                        receivingTokenCustody = poolConfig.custodies.find(function (i) { return i.mintKey.equals(poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey); });
+                        positionAccount = web3_js_1.PublicKey.findProgramAddressSync([
+                            Buffer.from("position"),
+                            publicKey.toBuffer(),
+                            poolConfig.poolAddress.toBuffer(),
+                            receivingTokenCustody.custodyAccount.toBuffer(),
+                            (0, types_1.isVariant)(side, 'long') ? Buffer.from([1]) : Buffer.from([2]),
+                        ], this.programId)[0];
+                        console.log("positionAccount:", positionAccount.toBase58());
+                        params = {
+                            price: priceAfterSlippage,
+                        };
+                        return [4 /*yield*/, 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: spl_token_1.TOKEN_PROGRAM_ID,
+                            }).instruction()];
+                    case 4:
+                        instruction = _a.sent();
+                        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') {
+                            closeWsolATAIns = (0, spl_token_1.createCloseAccountInstruction)(userReceivingTokenAccount, publicKey, publicKey);
+                            instructions.push(closeWsolATAIns);
+                        }
+                        return [3 /*break*/, 6];
+                    case 5:
+                        error_3 = _a.sent();
+                        console.error("perpclient closePosition error:", error_3);
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*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
+        this.swap = function (receivingTokenSymbol, dispensingTokenSymbol, amountIn, minAmountOut, poolConfig) { return __awaiter(_this, void 0, void 0, function () {
+            var receivingTokenCustody, dispensingTokenCustody, publicKey, instructions, receivingTokenAccount, dispensingCustodyTokenAccount, wsolAssociatedTokenAccount, wsolATAExist, wsolBalance, _a, _b, unWrappedSolBalance, _c, totalSolBal, conversionAmt, tokenAccountBalance, _d, params, inx, closeWsolATAIns, err_2;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        receivingTokenCustody = poolConfig.custodies.find(function (i) { return i.mintKey.toBase58() === poolConfig.getTokenFromSymbol(receivingTokenSymbol).mintKey.toBase58(); });
+                        if (!receivingTokenCustody) {
+                            throw "receivingTokenCustody  not found";
+                        }
+                        dispensingTokenCustody = poolConfig.custodies.find(function (i) { return i.mintKey.toBase58() === poolConfig.getTokenFromSymbol(dispensingTokenSymbol).mintKey.toBase58(); });
+                        if (!dispensingTokenCustody) {
+                            throw "dispensingTokenCustody  not found";
+                        }
+                        publicKey = this.provider.wallet.publicKey;
+                        instructions = [];
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 17, , 18]);
+                        return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(receivingTokenCustody.mintKey, publicKey)];
+                    case 2:
+                        receivingTokenAccount = _e.sent();
+                        return [4 /*yield*/, (0, utils_1.checkIfAccountExists)(receivingTokenAccount, this.provider.connection)];
+                    case 3:
+                        if (!(_e.sent())) {
+                            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, receivingTokenAccount, publicKey, receivingTokenCustody.mintKey));
+                        }
+                        return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(dispensingTokenCustody.mintKey, publicKey)];
+                    case 4:
+                        dispensingCustodyTokenAccount = _e.sent();
+                        if (!(dispensingTokenSymbol == 'SOL')) return [3 /*break*/, 12];
+                        console.log("dispensingTokenSymbol === sol", dispensingTokenSymbol);
+                        return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(spl_token_1.NATIVE_MINT, publicKey)];
+                    case 5:
+                        wsolAssociatedTokenAccount = _e.sent();
+                        return [4 /*yield*/, (0, utils_1.checkIfAccountExists)(wsolAssociatedTokenAccount, this.provider.connection)];
+                    case 6:
+                        wsolATAExist = _e.sent();
+                        if (!wsolATAExist) {
+                            console.log("wsol ata does not exist");
+                            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, wsolAssociatedTokenAccount, publicKey, spl_token_1.NATIVE_MINT));
+                        }
+                        _a = anchor_1.BN.bind;
+                        if (!wsolATAExist) return [3 /*break*/, 8];
+                        return [4 /*yield*/, this.provider.connection.getTokenAccountBalance(wsolAssociatedTokenAccount)];
+                    case 7:
+                        _b = (_e.sent()).value.amount;
+                        return [3 /*break*/, 9];
+                    case 8:
+                        _b = 0;
+                        _e.label = 9;
+                    case 9:
+                        wsolBalance = new (_a.apply(anchor_1.BN, [void 0, _b]))();
+                        if (!wsolBalance.lt(amountIn)) return [3 /*break*/, 11];
+                        _c = anchor_1.BN.bind;
+                        return [4 /*yield*/, this.provider.connection.getBalance(publicKey)];
+                    case 10:
+                        unWrappedSolBalance = new (_c.apply(anchor_1.BN, [void 0, _e.sent()]))();
+                        totalSolBal = unWrappedSolBalance.add(wsolBalance);
+                        if (totalSolBal.lt(amountIn)) {
+                            throw "Insufficient SOL Funds";
+                        }
+                        conversionAmt = amountIn.sub(wsolBalance);
+                        instructions.push(web3_js_1.SystemProgram.transfer({
+                            fromPubkey: publicKey,
+                            toPubkey: wsolAssociatedTokenAccount,
+                            lamports: conversionAmt.toNumber(), // IS IT SAFE TO PUT AS NUMBER ?
+                        }), (0, spl_token_1.createSyncNativeInstruction)(wsolAssociatedTokenAccount));
+                        _e.label = 11;
+                    case 11: return [3 /*break*/, 15];
+                    case 12: return [4 /*yield*/, (0, utils_1.checkIfAccountExists)(dispensingCustodyTokenAccount, this.provider.connection)];
+                    case 13:
+                        if (!(_e.sent())) {
+                            throw "Insufficient Funds , Token Account doesn't exist";
+                        }
+                        _d = anchor_1.BN.bind;
+                        return [4 /*yield*/, this.provider.connection.getTokenAccountBalance(dispensingCustodyTokenAccount)];
+                    case 14:
+                        tokenAccountBalance = new (_d.apply(anchor_1.BN, [void 0, (_e.sent()).value.amount]))();
+                        if (tokenAccountBalance.lt(amountIn)) {
+                            throw "Insufficient Funds";
+                        }
+                        _e.label = 15;
+                    case 15:
+                        params = {
+                            amountIn: amountIn,
+                            minAmountOut: minAmountOut,
+                        };
+                        return [4 /*yield*/, 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: spl_token_1.TOKEN_PROGRAM_ID,
+                            })
+                                .instruction()];
+                    case 16:
+                        inx = _e.sent();
+                        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') {
+                            closeWsolATAIns = (0, spl_token_1.createCloseAccountInstruction)(receivingTokenAccount, publicKey, publicKey);
+                            instructions.push(closeWsolATAIns);
+                        }
+                        return [3 /*break*/, 18];
+                    case 17:
+                        err_2 = _e.sent();
+                        console.log("perpClient Swap error:: ", err_2);
+                        throw err_2;
+                    case 18: return [2 /*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
+        this.addLiquidity = function (payTokenSymbol, tokenAmountIn, minLpAmountOut, // give this value based on slippage 
+        poolConfig) { return __awaiter(_this, void 0, void 0, function () {
+            var payTokenCustody, publicKey, instructions, userPayingTokenAccount, lpTokenAccount, custodyAccountMetas, custodyOracleAccountMetas, _i, _a, custody, wsolAssociatedTokenAccount, wsolATAExist, wsolBalance, _b, _c, unWrappedSolBalance, _d, totalSolBal, conversionAmt, tokenAccountBalance, _e, inx, err_3;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        payTokenCustody = poolConfig.custodies.find(function (i) { return i.mintKey.equals(poolConfig.getTokenFromSymbol(payTokenSymbol).mintKey); });
+                        if (!payTokenCustody) {
+                            throw "payTokenCustody  not found";
+                        }
+                        publicKey = this.provider.wallet.publicKey;
+                        instructions = [];
+                        _f.label = 1;
+                    case 1:
+                        _f.trys.push([1, 17, , 18]);
+                        return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(payTokenCustody.mintKey, publicKey)];
+                    case 2:
+                        userPayingTokenAccount = _f.sent();
+                        return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(poolConfig.lpTokenMint, publicKey)];
+                    case 3:
+                        lpTokenAccount = _f.sent();
+                        custodyAccountMetas = [];
+                        custodyOracleAccountMetas = [];
+                        for (_i = 0, _a = poolConfig.custodies; _i < _a.length; _i++) {
+                            custody = _a[_i];
+                            custodyAccountMetas.push({
+                                pubkey: custody.custodyAccount,
+                                isSigner: false,
+                                isWritable: false,
+                            });
+                            custodyOracleAccountMetas.push({
+                                pubkey: custody.oracleAddress,
+                                isSigner: false,
+                                isWritable: false,
+                            });
+                        }
+                        return [4 /*yield*/, (0, utils_1.checkIfAccountExists)(lpTokenAccount, this.provider.connection)];
+                    case 4:
+                        if (!(_f.sent())) {
+                            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, lpTokenAccount, publicKey, poolConfig.lpTokenMint));
+                        }
+                        if (!(payTokenSymbol == 'SOL')) return [3 /*break*/, 12];
+                        console.log("payTokenSymbol === sol", payTokenSymbol);
+                        return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(spl_token_1.NATIVE_MINT, publicKey)];
+                    case 5:
+                        wsolAssociatedTokenAccount = _f.sent();
+                        return [4 /*yield*/, (0, utils_1.checkIfAccountExists)(wsolAssociatedTokenAccount, this.provider.connection)];
+                    case 6:
+                        wsolATAExist = _f.sent();
+                        if (!wsolATAExist) {
+                            console.log("wsol ata does not exist");
+                            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, wsolAssociatedTokenAccount, publicKey, spl_token_1.NATIVE_MINT));
+                        }
+                        _b = anchor_1.BN.bind;
+                        if (!wsolATAExist) return [3 /*break*/, 8];
+                        return [4 /*yield*/, this.provider.connection.getTokenAccountBalance(wsolAssociatedTokenAccount)];
+                    case 7:
+                        _c = (_f.sent()).value.amount;
+                        return [3 /*break*/, 9];
+                    case 8:
+                        _c = 0;
+                        _f.label = 9;
+                    case 9:
+                        wsolBalance = new (_b.apply(anchor_1.BN, [void 0, _c]))();
+                        if (!wsolBalance.lt(tokenAmountIn)) return [3 /*break*/, 11];
+                        _d = anchor_1.BN.bind;
+                        return [4 /*yield*/, this.provider.connection.getBalance(publicKey)];
+                    case 10:
+                        unWrappedSolBalance = new (_d.apply(anchor_1.BN, [void 0, _f.sent()]))();
+                        totalSolBal = unWrappedSolBalance.add(wsolBalance);
+                        if (totalSolBal.lt(tokenAmountIn)) {
+                            throw "Insufficient SOL Funds";
+                        }
+                        conversionAmt = tokenAmountIn.sub(wsolBalance);
+                        instructions.push(web3_js_1.SystemProgram.transfer({
+                            fromPubkey: publicKey,
+                            toPubkey: wsolAssociatedTokenAccount,
+                            lamports: conversionAmt.toNumber(), // IS IT SAFE TO PUT AS NUMBER
+                        }), (0, spl_token_1.createSyncNativeInstruction)(wsolAssociatedTokenAccount));
+                        _f.label = 11;
+                    case 11: return [3 /*break*/, 15];
+                    case 12: return [4 /*yield*/, (0, utils_1.checkIfAccountExists)(userPayingTokenAccount, this.provider.connection)];
+                    case 13:
+                        if (!(_f.sent())) {
+                            throw "Insufficient Funds , token Account doesn't exist";
+                        }
+                        _e = anchor_1.BN.bind;
+                        return [4 /*yield*/, this.provider.connection.getTokenAccountBalance(userPayingTokenAccount)];
+                    case 14:
+                        tokenAccountBalance = new (_e.apply(anchor_1.BN, [void 0, (_f.sent()).value.amount]))();
+                        if (tokenAccountBalance.lt(tokenAmountIn)) {
+                            throw "Insufficient Funds";
+                        }
+                        _f.label = 15;
+                    case 15:
+                        console.log("in add liq", tokenAmountIn);
+                        return [4 /*yield*/, this.program.methods
+                                .addLiquidity({
+                                amountIn: tokenAmountIn,
+                                minLpAmountOut: minLpAmountOut
+                            })
+                                .accounts({
+                                owner: publicKey,
+                                fundingAccount: userPayingTokenAccount,
+                                lpTokenAccount: lpTokenAccount,
+                                transferAuthority: poolConfig.transferAuthority,
+                                perpetuals: poolConfig.perpetuals,
+                                pool: poolConfig.poolAddress,
+                                custody: payTokenCustody.custodyAccount,
+                                custodyOracleAccount: payTokenCustody.oracleAddress,
+                                custodyTokenAccount: payTokenCustody.tokenAccount,
+                                lpTokenMint: poolConfig.lpTokenMint,
+                                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                            })
+                                .remainingAccounts(__spreadArray(__spreadArray([], custodyAccountMetas, true), custodyOracleAccountMetas, true))
+                                .instruction()];
+                    case 16:
+                        inx = _f.sent();
+                        instructions.push(inx);
+                        return [3 /*break*/, 18];
+                    case 17:
+                        err_3 = _f.sent();
+                        console.log("perpClient addLiquidity error:: ", err_3);
+                        throw err_3;
+                    case 18: return [2 /*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
+        this.removeLiquidity = function (recieveTokenSymbol, liquidityAmountIn, minTokenAmountOut, // give this value based on slippage 
+        poolConfig, closeLpATA) {
+            if (closeLpATA === void 0) { closeLpATA = false; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var recieveTokenCustody, publicKey, instructions, userRecievingTokenAccount, lpTokenAccount, custodyAccountMetas, custodyOracleAccountMetas, _i, _a, custody, removeLiquidityTx, closeInx, closeWsolATAIns, err_4;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            recieveTokenCustody = poolConfig.custodies.find(function (i) { return i.mintKey.equals(poolConfig.getTokenFromSymbol(recieveTokenSymbol).mintKey); });
+                            if (!recieveTokenCustody) {
+                                throw "recieveTokenCustody not found";
+                            }
+                            publicKey = this.provider.wallet.publicKey;
+                            instructions = [];
+                            _b.label = 1;
+                        case 1:
+                            _b.trys.push([1, 6, , 7]);
+                            return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(recieveTokenCustody.mintKey, publicKey)];
+                        case 2:
+                            userRecievingTokenAccount = _b.sent();
+                            return [4 /*yield*/, (0, utils_1.checkIfAccountExists)(userRecievingTokenAccount, this.provider.connection)];
+                        case 3:
+                            if (!(_b.sent())) {
+                                instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, userRecievingTokenAccount, publicKey, recieveTokenCustody.mintKey));
+                            }
+                            return [4 /*yield*/, (0, spl_token_1.getAssociatedTokenAddress)(poolConfig.lpTokenMint, publicKey)];
+                        case 4:
+                            lpTokenAccount = _b.sent();
+                            custodyAccountMetas = [];
+                            custodyOracleAccountMetas = [];
+                            for (_i = 0, _a = poolConfig.custodies; _i < _a.length; _i++) {
+                                custody = _a[_i];
+                                custodyAccountMetas.push({
+                                    pubkey: custody.custodyAccount,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                                custodyOracleAccountMetas.push({
+                                    pubkey: custody.oracleAddress,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                            }
+                            console.log("liquidityAmountIn", liquidityAmountIn.toString());
+                            return [4 /*yield*/, this.program.methods
+                                    .removeLiquidity({
+                                    lpAmountIn: liquidityAmountIn,
+                                    minAmountOut: minTokenAmountOut
+                                })
+                                    .accounts({
+                                    owner: publicKey,
+                                    receivingAccount: userRecievingTokenAccount,
+                                    lpTokenAccount: lpTokenAccount,
+                                    transferAuthority: poolConfig.transferAuthority,
+                                    perpetuals: poolConfig.perpetuals,
+                                    pool: poolConfig.poolAddress,
+                                    custody: recieveTokenCustody.custodyAccount,
+                                    custodyOracleAccount: recieveTokenCustody.oracleAddress,
+                                    custodyTokenAccount: recieveTokenCustody.tokenAccount,
+                                    lpTokenMint: poolConfig.lpTokenMint,
+                                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                                })
+                                    .remainingAccounts(__spreadArray(__spreadArray([], custodyAccountMetas, true), custodyOracleAccountMetas, true))
+                                    .instruction()];
+                        case 5:
+                            removeLiquidityTx = _b.sent();
+                            instructions.push(removeLiquidityTx);
+                            if (closeLpATA) {
+                                closeInx = (0, spl_token_1.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') {
+                                closeWsolATAIns = (0, spl_token_1.createCloseAccountInstruction)(userRecievingTokenAccount, publicKey, publicKey);
+                                instructions.push(closeWsolATAIns);
+                            }
+                            return [3 /*break*/, 7];
+                        case 6:
+                            err_4 = _b.sent();
+                            console.log("perpClient removeLiquidity error:: ", err_4);
+                            throw err_4;
+                        case 7: return [2 /*return*/, instructions];
+                    }
+                });
+            });
+        };
         // this.provider = AnchorProvider.local(clusterUrl, {
         //   commitment: "confirmed",
         //   preflightCommitment: "confirmed",
@@ -1025,6 +1589,7 @@ var PerpetualsClient = /** @class */ (function () {
         // const idl = JSON.parse(IDL);
         // const program = new anchor.Program(idl, programId, provider);
         this.program = new anchor_1.Program(perpetuals_1.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(
@@ -1035,10 +1600,25 @@ var PerpetualsClient = /** @class */ (function () {
         this.multisig = this.findProgramAddress("multisig");
         this.authority = this.findProgramAddress("transfer_authority");
         this.perpetuals = this.findProgramAddress("perpetuals");
+        this.prioritizationFee = (opts === null || opts === void 0 ? void 0 : opts.prioritizationFee) || 0;
+        this.postSendTxCallback = opts === null || opts === void 0 ? void 0 : opts.postSendTxCallback;
+        this.txConfirmationCommitment = (_a = opts === null || opts === void 0 ? void 0 : opts.txConfirmationCommitment) !== null && _a !== void 0 ? _a : 'processed';
         anchor_1.BN.prototype.toJSON = function () {
             return this.toString(10);
         };
     }
+    PerpetualsClient.prototype.sendTransaction = function (ixs, opts) {
+        var _a;
+        if (opts === void 0) { opts = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, (0, rpc_1.sendTransaction)(this.program.provider, ixs, (_a = opts.alts) !== null && _a !== void 0 ? _a : [], __assign({ postSendTxCallback: this.postSendTxCallback, prioritizationFee: this.prioritizationFee, txConfirmationCommitment: this.txConfirmationCommitment }, opts))];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
     return PerpetualsClient;
 }());
 exports.PerpetualsClient = PerpetualsClient;