flash-sdk 2.11.1 → 2.11.3

package/dist/PerpetualsClient.js

@@ -3140,6 +3140,133 @@ var PerpetualsClient = (function () {
                 });
             });
         };
+        this.addLiquidityAndStake = function (inputSymbol, amountIn, minLpAmountOut, poolConfig, skipBalanceChecks) {
+            if (skipBalanceChecks === void 0) { skipBalanceChecks = false; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var publicKey, wrappedSolAccount, preInstructions, instructions, postInstructions, additionalSigners, userInputTokenAccount, lpTokenMint, inputCustodyConfig, lpTokenAccount, flpStakeAccount, poolStakedFlpVault, accCreationLamports, lamports, unWrappedSolBalance, _a, tokenAccountBalance, _b, custodyAccountMetas, custodyOracleAccountMetas, markets, _i, _c, custody, _d, _e, market, instruction;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0:
+                            publicKey = this.provider.wallet.publicKey;
+                            preInstructions = [];
+                            instructions = [];
+                            postInstructions = [];
+                            additionalSigners = [];
+                            lpTokenMint = poolConfig.lpTokenMint;
+                            inputCustodyConfig = poolConfig.custodies.find(function (i) { return i.mintKey.equals(poolConfig.getTokenFromSymbol(inputSymbol).mintKey); });
+                            return [4, (0, spl_token_1.getAssociatedTokenAddress)(lpTokenMint, publicKey)];
+                        case 1:
+                            lpTokenAccount = _f.sent();
+                            flpStakeAccount = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("stake"), publicKey.toBuffer(), poolConfig.poolAddress.toBuffer()], this.programId)[0];
+                            poolStakedFlpVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("staked_lp_token_account"), poolConfig.poolAddress.toBuffer(), lpTokenMint.toBuffer()], this.programId)[0];
+                            if (!(inputSymbol == 'SOL')) return [3, 4];
+                            console.log("inputSymbol === SOL", inputSymbol);
+                            wrappedSolAccount = new web3_js_1.Keypair();
+                            return [4, (0, spl_token_1.getMinimumBalanceForRentExemptAccount)(this.provider.connection)];
+                        case 2:
+                            accCreationLamports = (_f.sent());
+                            console.log("accCreationLamports:", accCreationLamports);
+                            lamports = amountIn.add(new anchor_1.BN(accCreationLamports));
+                            console.log("lamports:", lamports.toNumber());
+                            _a = anchor_1.BN.bind;
+                            return [4, this.provider.connection.getBalance(publicKey)];
+                        case 3:
+                            unWrappedSolBalance = new (_a.apply(anchor_1.BN, [void 0, _f.sent()]))();
+                            if (unWrappedSolBalance.lt(lamports)) {
+                                throw "Insufficient SOL Funds";
+                            }
+                            preInstructions = [
+                                web3_js_1.SystemProgram.createAccount({
+                                    fromPubkey: publicKey,
+                                    newAccountPubkey: wrappedSolAccount.publicKey,
+                                    lamports: lamports.toNumber(),
+                                    space: 165,
+                                    programId: spl_token_1.TOKEN_PROGRAM_ID,
+                                }),
+                                (0, spl_token_1.createInitializeAccount3Instruction)(wrappedSolAccount.publicKey, spl_token_1.NATIVE_MINT, publicKey),
+                            ];
+                            postInstructions = [
+                                (0, spl_token_1.createCloseAccountInstruction)(wrappedSolAccount.publicKey, publicKey, publicKey),
+                            ];
+                            additionalSigners.push(wrappedSolAccount);
+                            return [3, 7];
+                        case 4:
+                            userInputTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(inputCustodyConfig.mintKey, publicKey, true);
+                            return [4, (0, utils_1.checkIfAccountExists)(userInputTokenAccount, this.provider.connection)];
+                        case 5:
+                            if (!(_f.sent())) {
+                                throw "Insufficient Funds , token Account doesn't exist";
+                            }
+                            if (!!skipBalanceChecks) return [3, 7];
+                            _b = anchor_1.BN.bind;
+                            return [4, this.provider.connection.getTokenAccountBalance(userInputTokenAccount)];
+                        case 6:
+                            tokenAccountBalance = new (_b.apply(anchor_1.BN, [void 0, (_f.sent()).value.amount]))();
+                            if (tokenAccountBalance.lt(amountIn)) {
+                                throw "Insufficient Funds need more ".concat(amountIn.sub(tokenAccountBalance), " tokens");
+                            }
+                            _f.label = 7;
+                        case 7:
+                            custodyAccountMetas = [];
+                            custodyOracleAccountMetas = [];
+                            markets = [];
+                            for (_i = 0, _c = poolConfig.custodies; _i < _c.length; _i++) {
+                                custody = _c[_i];
+                                custodyAccountMetas.push({
+                                    pubkey: custody.custodyAccount,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                                custodyOracleAccountMetas.push({
+                                    pubkey: this.useExtOracleAccount ? custody.extOracleAccount : custody.intOracleAccount,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                            }
+                            for (_d = 0, _e = poolConfig.markets; _d < _e.length; _d++) {
+                                market = _e[_d];
+                                markets.push({
+                                    pubkey: market.marketAccount,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                            }
+                            return [4, this.programPerpComposability.methods.addLiquidityAndStake({
+                                    amountIn: amountIn,
+                                    minLpAmountOut: minLpAmountOut,
+                                }).accounts({
+                                    perpProgram: this.programId,
+                                    owner: publicKey,
+                                    feePayer: publicKey,
+                                    fundingAccount: inputSymbol == 'SOL' ? wrappedSolAccount.publicKey : userInputTokenAccount,
+                                    lpTokenAccount: lpTokenAccount,
+                                    transferAuthority: poolConfig.transferAuthority,
+                                    perpetuals: poolConfig.perpetuals,
+                                    pool: poolConfig.poolAddress,
+                                    custody: inputCustodyConfig.custodyAccount,
+                                    custodyOracleAccount: this.useExtOracleAccount ? inputCustodyConfig.extOracleAccount : inputCustodyConfig.intOracleAccount,
+                                    custodyTokenAccount: inputCustodyConfig.tokenAccount,
+                                    lpTokenMint: lpTokenMint,
+                                    flpStakeAccount: flpStakeAccount,
+                                    poolStakedFlpVault: poolStakedFlpVault,
+                                    systemProgram: web3_js_1.SystemProgram.programId,
+                                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                                    eventAuthority: this.eventAuthority.publicKey,
+                                    ixSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY
+                                })
+                                    .remainingAccounts(__spreadArray(__spreadArray(__spreadArray([], custodyAccountMetas, true), custodyOracleAccountMetas, true), markets, true))
+                                    .instruction()];
+                        case 8:
+                            instruction = _f.sent();
+                            instructions.push(instruction);
+                            return [2, {
+                                    instructions: __spreadArray(__spreadArray(__spreadArray([], preInstructions, true), instructions, true), postInstructions, true),
+                                    additionalSigners: additionalSigners
+                                }];
+                    }
+                });
+            });
+        };
         this.removeLiquidity = function (recieveTokenSymbol, liquidityAmountIn, minTokenAmountOut, poolConfig, closeLpATA, createUserATA, closeUsersWSOLATA) {
             if (closeLpATA === void 0) { closeLpATA = false; }
             if (createUserATA === void 0) { createUserATA = true; }
@@ -3536,7 +3663,7 @@ var PerpetualsClient = (function () {
                         _a.trys.push([1, 3, , 4]);
                         rewardCustodyConfig = poolConfig.custodies.find(function (i) { return i.mintKey.equals(poolConfig.getTokenFromSymbol(rewardSymbol).mintKey); });
                         compoundingTokenMint = this.getPoolCompoundingTokenKey(poolConfig.poolName);
-                        compoundingVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("compounding_lp_token_account"), poolConfig.poolAddress.toBuffer(), compoundingTokenMint.toBuffer()], constants_1.METAPLEX_PROGRAM_ID)[0];
+                        compoundingVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("compounding_lp_token_account"), poolConfig.poolAddress.toBuffer(), poolConfig.lpTokenMint.toBuffer()], this.programId)[0];
                         metadataAccount = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("metadata"), constants_1.METAPLEX_PROGRAM_ID.toBuffer(), compoundingTokenMint.toBuffer()], constants_1.METAPLEX_PROGRAM_ID)[0];
                         return [4, this.program.methods
                                 .initCompounding({
@@ -4627,27 +4754,103 @@ var PerpetualsClient = (function () {
             });
         }); };
         this.addCompoundingLiquidity = function (amountIn, minSflpAmountOut, inTokenSymbol, rewardTokenMint, poolConfig) { return __awaiter(_this, void 0, void 0, function () {
-            var publicKey, instructions, additionalSigners, rewardCustody, inCustodyConfig, lpTokenMint, sFlpTokenMint, sflpTokenAccount, fundingAccount, compoundingVault, addCompoundingLiquidity, err_30;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var publicKey, preInstructions, instructions, additionalSigners, postInstructions, rewardCustody, inCustodyConfig, lpTokenMint, sFlpTokenMint, wrappedSolAccount, lpTokenAccount, sflpTokenAccount, fundingAccount, custodyAccountMetas, custodyOracleAccountMetas, markets, _i, _a, custody, _b, _c, market, accCreationLamports, lamports, unWrappedSolBalance, _d, compoundingVault, addCompoundingLiquidity, err_30;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         publicKey = this.provider.wallet.publicKey;
+                        preInstructions = [];
                         instructions = [];
                         additionalSigners = [];
+                        postInstructions = [];
                         rewardCustody = poolConfig.custodies.find(function (i) { return i.mintKey.equals(rewardTokenMint); });
                         inCustodyConfig = poolConfig.custodies.find(function (i) { return i.mintKey.equals(poolConfig.getTokenFromSymbol(inTokenSymbol).mintKey); });
                         lpTokenMint = poolConfig.lpTokenMint;
                         sFlpTokenMint = poolConfig.sFlpTokenMint;
-                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(sFlpTokenMint, publicKey)];
+                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(poolConfig.lpTokenMint, publicKey)];
                     case 1:
-                        sflpTokenAccount = _a.sent();
-                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(inCustodyConfig.mintKey, publicKey)];
+                        lpTokenAccount = _e.sent();
+                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(sFlpTokenMint, publicKey)];
                     case 2:
-                        fundingAccount = _a.sent();
-                        compoundingVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("compounding_lp_token_account"), poolConfig.poolAddress.toBuffer(), sFlpTokenMint.toBuffer()], constants_1.METAPLEX_PROGRAM_ID)[0];
-                        _a.label = 3;
+                        sflpTokenAccount = _e.sent();
+                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(inCustodyConfig.mintKey, publicKey)];
                     case 3:
-                        _a.trys.push([3, 5, , 6]);
+                        fundingAccount = _e.sent();
+                        custodyAccountMetas = [];
+                        custodyOracleAccountMetas = [];
+                        markets = [];
+                        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: this.useExtOracleAccount ? custody.extOracleAccount : custody.intOracleAccount,
+                                isSigner: false,
+                                isWritable: false,
+                            });
+                        }
+                        for (_b = 0, _c = poolConfig.markets; _b < _c.length; _b++) {
+                            market = _c[_b];
+                            markets.push({
+                                pubkey: market.marketAccount,
+                                isSigner: false,
+                                isWritable: false,
+                            });
+                        }
+                        return [4, (0, utils_1.checkIfAccountExists)(lpTokenAccount, this.provider.connection)];
+                    case 4:
+                        if (!(_e.sent())) {
+                            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, lpTokenAccount, publicKey, poolConfig.lpTokenMint));
+                        }
+                        return [4, (0, utils_1.checkIfAccountExists)(sflpTokenAccount, this.provider.connection)];
+                    case 5:
+                        if (!(_e.sent())) {
+                            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, sflpTokenAccount, publicKey, poolConfig.sFlpTokenMint));
+                        }
+                        if (!(inTokenSymbol == 'SOL')) return [3, 8];
+                        console.log("inTokenSymbol === SOL", inTokenSymbol);
+                        wrappedSolAccount = new web3_js_1.Keypair();
+                        return [4, (0, spl_token_1.getMinimumBalanceForRentExemptAccount)(this.provider.connection)];
+                    case 6:
+                        accCreationLamports = (_e.sent());
+                        console.log("accCreationLamports:", accCreationLamports);
+                        lamports = amountIn.add(new anchor_1.BN(accCreationLamports));
+                        _d = anchor_1.BN.bind;
+                        return [4, this.provider.connection.getBalance(publicKey)];
+                    case 7:
+                        unWrappedSolBalance = new (_d.apply(anchor_1.BN, [void 0, _e.sent()]))();
+                        if (unWrappedSolBalance.lt(lamports)) {
+                            throw "Insufficient SOL Funds";
+                        }
+                        preInstructions = [
+                            web3_js_1.SystemProgram.createAccount({
+                                fromPubkey: publicKey,
+                                newAccountPubkey: wrappedSolAccount.publicKey,
+                                lamports: lamports.toNumber(),
+                                space: 165,
+                                programId: spl_token_1.TOKEN_PROGRAM_ID,
+                            }),
+                            (0, spl_token_1.createInitializeAccount3Instruction)(wrappedSolAccount.publicKey, spl_token_1.NATIVE_MINT, publicKey),
+                        ];
+                        postInstructions = [
+                            (0, spl_token_1.createCloseAccountInstruction)(wrappedSolAccount.publicKey, publicKey, publicKey),
+                        ];
+                        additionalSigners.push(wrappedSolAccount);
+                        return [3, 10];
+                    case 8: return [4, (0, utils_1.checkIfAccountExists)(fundingAccount, this.provider.connection)];
+                    case 9:
+                        if (!(_e.sent())) {
+                            throw "Insufficient Funds , token Account doesn't exist";
+                        }
+                        _e.label = 10;
+                    case 10:
+                        compoundingVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("compounding_lp_token_account"), poolConfig.poolAddress.toBuffer(), lpTokenMint.toBuffer()], this.programId)[0];
+                        _e.label = 11;
+                    case 11:
+                        _e.trys.push([11, 13, , 14]);
                         return [4, this.program.methods
                                 .addCompoundingLiquidity({
                                 amountIn: amountIn,
@@ -4673,138 +4876,250 @@ var PerpetualsClient = (function () {
                                 program: this.program.programId,
                                 ixSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY
                             })
+                                .remainingAccounts(__spreadArray(__spreadArray(__spreadArray([], custodyAccountMetas, true), custodyOracleAccountMetas, true), markets, true))
                                 .instruction()];
-                    case 4:
-                        addCompoundingLiquidity = _a.sent();
+                    case 12:
+                        addCompoundingLiquidity = _e.sent();
                         instructions.push(addCompoundingLiquidity);
-                        return [3, 6];
-                    case 5:
-                        err_30 = _a.sent();
+                        return [3, 14];
+                    case 13:
+                        err_30 = _e.sent();
                         console.log("perpClient addCompoundingLiquidity error:: ", err_30);
-                        return [3, 6];
-                    case 6: return [2, {
+                        return [3, 14];
+                    case 14: return [2, {
                             instructions: __spreadArray([], instructions, true),
                             additionalSigners: additionalSigners
                         }];
                 }
             });
         }); };
-        this.removeCompoundingLiquidity = function (sflpAmountIn, minAmountOut, outTokenSymbol, rewardTokenMint, poolConfig) { return __awaiter(_this, void 0, void 0, function () {
-            var publicKey, instructions, additionalSigners, rewardCustody, outCustodyConfig, lpTokenMint, sFlpTokenMint, sflpTokenAccount, receivingAccount, compoundingVault, removeCompoundingLiquidity, err_31;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        publicKey = this.provider.wallet.publicKey;
-                        instructions = [];
-                        additionalSigners = [];
-                        rewardCustody = poolConfig.custodies.find(function (i) { return i.mintKey.equals(rewardTokenMint); });
-                        outCustodyConfig = poolConfig.custodies.find(function (i) { return i.mintKey.equals(poolConfig.getTokenFromSymbol(outTokenSymbol).mintKey); });
-                        lpTokenMint = poolConfig.lpTokenMint;
-                        sFlpTokenMint = poolConfig.sFlpTokenMint;
-                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(sFlpTokenMint, publicKey)];
-                    case 1:
-                        sflpTokenAccount = _a.sent();
-                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(outCustodyConfig.mintKey, publicKey)];
-                    case 2:
-                        receivingAccount = _a.sent();
-                        compoundingVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("compounding_lp_token_account"), poolConfig.poolAddress.toBuffer(), sFlpTokenMint.toBuffer()], constants_1.METAPLEX_PROGRAM_ID)[0];
-                        _a.label = 3;
-                    case 3:
-                        _a.trys.push([3, 5, , 6]);
-                        return [4, this.program.methods
-                                .removeCompoundingLiquidity({
-                                sflpAmountIn: sflpAmountIn,
-                                minAmountOut: minAmountOut
-                            })
-                                .accounts({
-                                owner: publicKey,
-                                receivingAccount: receivingAccount,
-                                sflpTokenAccount: sflpTokenAccount,
-                                poolCompoundingFlpVault: compoundingVault,
-                                transferAuthority: poolConfig.transferAuthority,
-                                perpetuals: poolConfig.perpetuals,
-                                pool: poolConfig.poolAddress,
-                                outCustody: outCustodyConfig.custodyAccount,
-                                outCustodyOracleAccount: this.useExtOracleAccount ? outCustodyConfig.extOracleAccount : outCustodyConfig.intOracleAccount,
-                                outCustodyTokenAccount: outCustodyConfig.tokenAccount,
-                                rewardCustody: rewardCustody.custodyAccount,
-                                rewardCustodyOracleAccount: this.useExtOracleAccount ? rewardCustody.extOracleAccount : rewardCustody.intOracleAccount,
-                                lpTokenMint: lpTokenMint,
-                                sflpTokenMint: sFlpTokenMint,
-                                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                                eventAuthority: this.eventAuthority.publicKey,
-                                program: this.program.programId,
-                                ixSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY
-                            })
-                                .instruction()];
-                    case 4:
-                        removeCompoundingLiquidity = _a.sent();
-                        instructions.push(removeCompoundingLiquidity);
-                        return [3, 6];
-                    case 5:
-                        err_31 = _a.sent();
-                        console.log("perpClient removeCompoundingLiquidity error:: ", err_31);
-                        return [3, 6];
-                    case 6: return [2, {
-                            instructions: __spreadArray([], instructions, true),
-                            additionalSigners: additionalSigners
-                        }];
-                }
+        this.removeCompoundingLiquidity = function (sflpAmountIn, minAmountOut, outTokenSymbol, rewardTokenMint, poolConfig, createUserATA) {
+            if (createUserATA === void 0) { createUserATA = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var publicKey, userReceivingTokenAccount, wrappedSolAccount, preInstructions, instructions, postInstructions, additionalSigners, rewardCustody, outCustodyConfig, lpTokenMint, sFlpTokenMint, lamports, _a, custodyAccountMetas, custodyOracleAccountMetas, markets, _i, _b, custody, _c, _d, market, sflpTokenAccount, receivingAccount, compoundingVault, removeCompoundingLiquidity, err_31;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            publicKey = this.provider.wallet.publicKey;
+                            preInstructions = [];
+                            instructions = [];
+                            postInstructions = [];
+                            additionalSigners = [];
+                            rewardCustody = poolConfig.custodies.find(function (i) { return i.mintKey.equals(rewardTokenMint); });
+                            outCustodyConfig = poolConfig.custodies.find(function (i) { return i.mintKey.equals(poolConfig.getTokenFromSymbol(outTokenSymbol).mintKey); });
+                            lpTokenMint = poolConfig.lpTokenMint;
+                            sFlpTokenMint = poolConfig.sFlpTokenMint;
+                            if (!(outCustodyConfig.symbol == 'SOL')) return [3, 2];
+                            wrappedSolAccount = new web3_js_1.Keypair();
+                            userReceivingTokenAccount = wrappedSolAccount.publicKey;
+                            return [4, (0, spl_token_1.getMinimumBalanceForRentExemptAccount)(this.provider.connection)];
+                        case 1:
+                            lamports = (_e.sent());
+                            preInstructions = [
+                                web3_js_1.SystemProgram.createAccount({
+                                    fromPubkey: publicKey,
+                                    newAccountPubkey: wrappedSolAccount.publicKey,
+                                    lamports: lamports,
+                                    space: 165,
+                                    programId: spl_token_1.TOKEN_PROGRAM_ID,
+                                }),
+                                (0, spl_token_1.createInitializeAccount3Instruction)(wrappedSolAccount.publicKey, spl_token_1.NATIVE_MINT, publicKey),
+                            ];
+                            postInstructions = [
+                                (0, spl_token_1.createCloseAccountInstruction)(wrappedSolAccount.publicKey, publicKey, publicKey),
+                            ];
+                            additionalSigners.push(wrappedSolAccount);
+                            return [3, 6];
+                        case 2: return [4, (0, spl_token_1.getAssociatedTokenAddress)(outCustodyConfig.mintKey, publicKey)];
+                        case 3:
+                            userReceivingTokenAccount = _e.sent();
+                            _a = createUserATA;
+                            if (!_a) return [3, 5];
+                            return [4, (0, utils_1.checkIfAccountExists)(userReceivingTokenAccount, this.provider.connection)];
+                        case 4:
+                            _a = !(_e.sent());
+                            _e.label = 5;
+                        case 5:
+                            if (_a) {
+                                preInstructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, userReceivingTokenAccount, publicKey, outCustodyConfig.mintKey));
+                            }
+                            _e.label = 6;
+                        case 6:
+                            custodyAccountMetas = [];
+                            custodyOracleAccountMetas = [];
+                            markets = [];
+                            for (_i = 0, _b = poolConfig.custodies; _i < _b.length; _i++) {
+                                custody = _b[_i];
+                                custodyAccountMetas.push({
+                                    pubkey: custody.custodyAccount,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                                custodyOracleAccountMetas.push({
+                                    pubkey: this.useExtOracleAccount ? custody.extOracleAccount : custody.intOracleAccount,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                            }
+                            for (_c = 0, _d = poolConfig.markets; _c < _d.length; _c++) {
+                                market = _d[_c];
+                                markets.push({
+                                    pubkey: market.marketAccount,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                            }
+                            return [4, (0, spl_token_1.getAssociatedTokenAddress)(sFlpTokenMint, publicKey)];
+                        case 7:
+                            sflpTokenAccount = _e.sent();
+                            return [4, (0, spl_token_1.getAssociatedTokenAddress)(outCustodyConfig.mintKey, publicKey)];
+                        case 8:
+                            receivingAccount = _e.sent();
+                            compoundingVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("compounding_lp_token_account"), poolConfig.poolAddress.toBuffer(), lpTokenMint.toBuffer()], this.programId)[0];
+                            _e.label = 9;
+                        case 9:
+                            _e.trys.push([9, 11, , 12]);
+                            return [4, this.program.methods
+                                    .removeCompoundingLiquidity({
+                                    sflpAmountIn: sflpAmountIn,
+                                    minAmountOut: minAmountOut
+                                })
+                                    .accounts({
+                                    owner: publicKey,
+                                    receivingAccount: outCustodyConfig.symbol == 'SOL' ? wrappedSolAccount.publicKey : userReceivingTokenAccount,
+                                    sflpTokenAccount: sflpTokenAccount,
+                                    poolCompoundingFlpVault: compoundingVault,
+                                    transferAuthority: poolConfig.transferAuthority,
+                                    perpetuals: poolConfig.perpetuals,
+                                    pool: poolConfig.poolAddress,
+                                    outCustody: outCustodyConfig.custodyAccount,
+                                    outCustodyOracleAccount: this.useExtOracleAccount ? outCustodyConfig.extOracleAccount : outCustodyConfig.intOracleAccount,
+                                    outCustodyTokenAccount: outCustodyConfig.tokenAccount,
+                                    rewardCustody: rewardCustody.custodyAccount,
+                                    rewardCustodyOracleAccount: this.useExtOracleAccount ? rewardCustody.extOracleAccount : rewardCustody.intOracleAccount,
+                                    lpTokenMint: lpTokenMint,
+                                    sflpTokenMint: sFlpTokenMint,
+                                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                                    eventAuthority: this.eventAuthority.publicKey,
+                                    program: this.program.programId,
+                                    ixSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY
+                                })
+                                    .remainingAccounts(__spreadArray(__spreadArray(__spreadArray([], custodyAccountMetas, true), custodyOracleAccountMetas, true), markets, true))
+                                    .instruction()];
+                        case 10:
+                            removeCompoundingLiquidity = _e.sent();
+                            instructions.push(removeCompoundingLiquidity);
+                            return [3, 12];
+                        case 11:
+                            err_31 = _e.sent();
+                            console.log("perpClient removeCompoundingLiquidity error:: ", err_31);
+                            return [3, 12];
+                        case 12: return [2, {
+                                instructions: __spreadArray(__spreadArray(__spreadArray([], preInstructions, true), instructions, true), postInstructions, true),
+                                additionalSigners: additionalSigners
+                            }];
+                    }
+                });
             });
-        }); };
-        this.migrateStake = function (amount, rewardTokenMint, poolConfig) { return __awaiter(_this, void 0, void 0, function () {
-            var publicKey, instructions, additionalSigners, rewardCustody, lpTokenMint, sFlpTokenMint, sflpTokenAccount, flpStakeAccount, compoundingVault, poolStakedFlpVault, migrateStake, err_32;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        publicKey = this.provider.wallet.publicKey;
-                        instructions = [];
-                        additionalSigners = [];
-                        rewardCustody = poolConfig.custodies.find(function (i) { return i.mintKey.equals(rewardTokenMint); });
-                        lpTokenMint = poolConfig.lpTokenMint;
-                        sFlpTokenMint = poolConfig.sFlpTokenMint;
-                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(sFlpTokenMint, publicKey)];
-                    case 1:
-                        sflpTokenAccount = _a.sent();
-                        flpStakeAccount = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("stake"), publicKey.toBuffer(), poolConfig.poolAddress.toBuffer()], this.programId)[0];
-                        compoundingVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("compounding_lp_token_account"), poolConfig.poolAddress.toBuffer(), sFlpTokenMint.toBuffer()], constants_1.METAPLEX_PROGRAM_ID)[0];
-                        poolStakedFlpVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("staked_lp_token_account"), poolConfig.poolAddress.toBuffer(), lpTokenMint.toBuffer()], this.programId)[0];
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        return [4, this.program.methods
-                                .migrateStake({
-                                amount: amount
-                            })
-                                .accounts({
-                                owner: publicKey,
-                                sflpTokenAccount: sflpTokenAccount,
-                                transferAuthority: poolConfig.transferAuthority,
-                                perpetuals: poolConfig.perpetuals,
-                                pool: poolConfig.poolAddress,
-                                flpStakeAccount: flpStakeAccount,
-                                rewardCustody: rewardCustody.custodyAccount,
-                                poolStakedFlpVault: poolStakedFlpVault,
-                                poolCompoundingFlpVault: compoundingVault,
-                                sflpTokenMint: sFlpTokenMint,
-                                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                            })
-                                .instruction()];
-                    case 3:
-                        migrateStake = _a.sent();
-                        instructions.push(migrateStake);
-                        return [3, 5];
-                    case 4:
-                        err_32 = _a.sent();
-                        console.log("perpClient migrateStake error:: ", err_32);
-                        return [3, 5];
-                    case 5: return [2, {
-                            instructions: __spreadArray([], instructions, true),
-                            additionalSigners: additionalSigners
-                        }];
-                }
+        };
+        this.migrateStake = function (amount, rewardTokenMint, poolConfig, createUserATA) {
+            if (createUserATA === void 0) { createUserATA = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var publicKey, preInstructions, instructions, postInstructions, additionalSigners, rewardCustody, lpTokenMint, sFlpTokenMint, sflpTokenAccount, _a, flpStakeAccount, compoundingVault, poolStakedFlpVault, custodyAccountMetas, custodyOracleAccountMetas, markets, _i, _b, custody, _c, _d, market, migrateStake, err_32;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            publicKey = this.provider.wallet.publicKey;
+                            preInstructions = [];
+                            instructions = [];
+                            postInstructions = [];
+                            additionalSigners = [];
+                            rewardCustody = poolConfig.custodies.find(function (i) { return i.mintKey.equals(rewardTokenMint); });
+                            lpTokenMint = poolConfig.lpTokenMint;
+                            sFlpTokenMint = poolConfig.sFlpTokenMint;
+                            return [4, (0, spl_token_1.getAssociatedTokenAddress)(sFlpTokenMint, publicKey)];
+                        case 1:
+                            sflpTokenAccount = _e.sent();
+                            _a = createUserATA;
+                            if (!_a) return [3, 3];
+                            return [4, (0, utils_1.checkIfAccountExists)(sflpTokenAccount, this.provider.connection)];
+                        case 2:
+                            _a = !(_e.sent());
+                            _e.label = 3;
+                        case 3:
+                            if (_a) {
+                                preInstructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(publicKey, sflpTokenAccount, publicKey, sFlpTokenMint));
+                            }
+                            flpStakeAccount = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("stake"), publicKey.toBuffer(), poolConfig.poolAddress.toBuffer()], this.programId)[0];
+                            compoundingVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("compounding_lp_token_account"), poolConfig.poolAddress.toBuffer(), poolConfig.lpTokenMint.toBuffer()], this.programId)[0];
+                            poolStakedFlpVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("staked_lp_token_account"), poolConfig.poolAddress.toBuffer(), lpTokenMint.toBuffer()], this.programId)[0];
+                            custodyAccountMetas = [];
+                            custodyOracleAccountMetas = [];
+                            markets = [];
+                            for (_i = 0, _b = poolConfig.custodies; _i < _b.length; _i++) {
+                                custody = _b[_i];
+                                custodyAccountMetas.push({
+                                    pubkey: custody.custodyAccount,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                                custodyOracleAccountMetas.push({
+                                    pubkey: this.useExtOracleAccount ? custody.extOracleAccount : custody.intOracleAccount,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                            }
+                            for (_c = 0, _d = poolConfig.markets; _c < _d.length; _c++) {
+                                market = _d[_c];
+                                markets.push({
+                                    pubkey: market.marketAccount,
+                                    isSigner: false,
+                                    isWritable: false,
+                                });
+                            }
+                            _e.label = 4;
+                        case 4:
+                            _e.trys.push([4, 6, , 7]);
+                            return [4, this.program.methods
+                                    .migrateStake({
+                                    amount: amount
+                                })
+                                    .accounts({
+                                    owner: publicKey,
+                                    sflpTokenAccount: sflpTokenAccount,
+                                    transferAuthority: poolConfig.transferAuthority,
+                                    perpetuals: poolConfig.perpetuals,
+                                    pool: poolConfig.poolAddress,
+                                    flpStakeAccount: flpStakeAccount,
+                                    rewardCustody: rewardCustody.custodyAccount,
+                                    rewardCustodyOracleAccount: rewardCustody.intOracleAccount,
+                                    poolStakedFlpVault: poolStakedFlpVault,
+                                    poolCompoundingFlpVault: compoundingVault,
+                                    lpTokenMint: lpTokenMint,
+                                    sflpTokenMint: sFlpTokenMint,
+                                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                                    eventAuthority: this.eventAuthority.publicKey,
+                                    program: this.program.programId,
+                                    ixSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY
+                                })
+                                    .remainingAccounts(__spreadArray(__spreadArray(__spreadArray([], custodyAccountMetas, true), custodyOracleAccountMetas, true), markets, true))
+                                    .instruction()];
+                        case 5:
+                            migrateStake = _e.sent();
+                            instructions.push(migrateStake);
+                            return [3, 7];
+                        case 6:
+                            err_32 = _e.sent();
+                            console.log("perpClient migrateStake error:: ", err_32);
+                            return [3, 7];
+                        case 7: return [2, {
+                                instructions: __spreadArray(__spreadArray(__spreadArray([], preInstructions, true), instructions, true), postInstructions, true),
+                                additionalSigners: additionalSigners
+                            }];
+                    }
+                });
             });
-        }); };
+        };
         this.compoundingFee = function (rewardTokenMint, poolConfig) { return __awaiter(_this, void 0, void 0, function () {
             var publicKey, instructions, additionalSigners, rewardCustody, lpTokenMint, sFlpTokenMint, compoundingVault, custodyAccountMetas, custodyOracleAccountMetas, markets, _i, _a, custody, _b, _c, market, compoundingFee, err_33;
             return __generator(this, function (_d) {