@drift-labs/sdk 2.145.0-beta.2 → 2.145.0

package/lib/browser/adminClient.js

@@ -205,10 +205,13 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
-    async initializePerpMarket(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, contractTier = types_1.ContractTier.SPECULATIVE, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidatorFee = 0, ifLiquidatorFee = 10000, imfFactor = 0, activeStatus = true, baseSpread = 0, maxSpread = 142500, maxOpenInterest = numericConstants_1.ZERO, maxRevenueWithdrawPerPeriod = numericConstants_1.ZERO, quoteMaxInsurance = numericConstants_1.ZERO, orderStepSize = numericConstants_1.BASE_PRECISION.divn(10000), orderTickSize = numericConstants_1.PRICE_PRECISION.divn(100000), minOrderSize = numericConstants_1.BASE_PRECISION.divn(10000), concentrationCoefScale = numericConstants_1.ONE, curveUpdateIntensity = 0, ammJitIntensity = 0, name = userName_1.DEFAULT_MARKET_NAME) {
+    async initializePerpMarket(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, contractTier = types_1.ContractTier.SPECULATIVE, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidatorFee = 0, ifLiquidatorFee = 10000, imfFactor = 0, activeStatus = true, baseSpread = 0, maxSpread = 142500, maxOpenInterest = numericConstants_1.ZERO, maxRevenueWithdrawPerPeriod = numericConstants_1.ZERO, quoteMaxInsurance = numericConstants_1.ZERO, orderStepSize = numericConstants_1.BASE_PRECISION.divn(10000), orderTickSize = numericConstants_1.PRICE_PRECISION.divn(100000), minOrderSize = numericConstants_1.BASE_PRECISION.divn(10000), concentrationCoefScale = numericConstants_1.ONE, curveUpdateIntensity = 0, ammJitIntensity = 0, name = userName_1.DEFAULT_MARKET_NAME, lpPoolId = 0) {
         const currentPerpMarketIndex = this.getStateAccount().numberOfMarkets;
-        const initializeMarketIx = await this.getInitializePerpMarketIx(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, contractTier, marginRatioInitial, marginRatioMaintenance, liquidatorFee, ifLiquidatorFee, imfFactor, activeStatus, baseSpread, maxSpread, maxOpenInterest, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, orderStepSize, orderTickSize, minOrderSize, concentrationCoefScale, curveUpdateIntensity, ammJitIntensity, name);
-        const tx = await this.buildTransaction(initializeMarketIx);
+        const ammCachePublicKey = (0, pda_1.getAmmCachePublicKey)(this.program.programId);
+        const ammCacheAccount = await this.connection.getAccountInfo(ammCachePublicKey);
+        const mustInitializeAmmCache = (ammCacheAccount === null || ammCacheAccount === void 0 ? void 0 : ammCacheAccount.data) == null;
+        const initializeMarketIxs = await this.getInitializePerpMarketIx(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, contractTier, marginRatioInitial, marginRatioMaintenance, liquidatorFee, ifLiquidatorFee, imfFactor, activeStatus, baseSpread, maxSpread, maxOpenInterest, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, orderStepSize, orderTickSize, minOrderSize, concentrationCoefScale, curveUpdateIntensity, ammJitIntensity, name, mustInitializeAmmCache, lpPoolId);
+        const tx = await this.buildTransaction(initializeMarketIxs);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         while (this.getStateAccount().numberOfMarkets <= currentPerpMarketIndex) {
             await this.fetchAccounts();
@@ -221,10 +224,14 @@ class AdminClient extends driftClient_1.DriftClient {
         await this.accountSubscriber.setPerpOracleMap();
         return txSig;
     }
-    async getInitializePerpMarketIx(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, contractTier = types_1.ContractTier.SPECULATIVE, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidatorFee = 0, ifLiquidatorFee = 10000, imfFactor = 0, activeStatus = true, baseSpread = 0, maxSpread = 142500, maxOpenInterest = numericConstants_1.ZERO, maxRevenueWithdrawPerPeriod = numericConstants_1.ZERO, quoteMaxInsurance = numericConstants_1.ZERO, orderStepSize = numericConstants_1.BASE_PRECISION.divn(10000), orderTickSize = numericConstants_1.PRICE_PRECISION.divn(100000), minOrderSize = numericConstants_1.BASE_PRECISION.divn(10000), concentrationCoefScale = numericConstants_1.ONE, curveUpdateIntensity = 0, ammJitIntensity = 0, name = userName_1.DEFAULT_MARKET_NAME) {
+    async getInitializePerpMarketIx(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, contractTier = types_1.ContractTier.SPECULATIVE, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidatorFee = 0, ifLiquidatorFee = 10000, imfFactor = 0, activeStatus = true, baseSpread = 0, maxSpread = 142500, maxOpenInterest = numericConstants_1.ZERO, maxRevenueWithdrawPerPeriod = numericConstants_1.ZERO, quoteMaxInsurance = numericConstants_1.ZERO, orderStepSize = numericConstants_1.BASE_PRECISION.divn(10000), orderTickSize = numericConstants_1.PRICE_PRECISION.divn(100000), minOrderSize = numericConstants_1.BASE_PRECISION.divn(10000), concentrationCoefScale = numericConstants_1.ONE, curveUpdateIntensity = 0, ammJitIntensity = 0, name = userName_1.DEFAULT_MARKET_NAME, includeInitAmmCacheIx = false, lpPoolId = 0) {
         const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        const ixs = [];
+        if (includeInitAmmCacheIx) {
+            ixs.push(await this.getInitializeAmmCacheIx());
+        }
         const nameBuffer = (0, userName_1.encodeName)(name);
-        return await this.program.instruction.initializePerpMarket(marketIndex, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, contractTier, marginRatioInitial, marginRatioMaintenance, liquidatorFee, ifLiquidatorFee, imfFactor, activeStatus, baseSpread, maxSpread, maxOpenInterest, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, orderStepSize, orderTickSize, minOrderSize, concentrationCoefScale, curveUpdateIntensity, ammJitIntensity, nameBuffer, {
+        const initPerpIx = await this.program.instruction.initializePerpMarket(marketIndex, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, contractTier, marginRatioInitial, marginRatioMaintenance, liquidatorFee, ifLiquidatorFee, imfFactor, activeStatus, baseSpread, maxSpread, maxOpenInterest, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, orderStepSize, orderTickSize, minOrderSize, concentrationCoefScale, curveUpdateIntensity, ammJitIntensity, nameBuffer, lpPoolId, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.isSubscribed
@@ -232,11 +239,98 @@ class AdminClient extends driftClient_1.DriftClient {
                     : this.wallet.publicKey,
                 oracle: priceOracle,
                 perpMarket: perpMarketPublicKey,
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+        ixs.push(initPerpIx);
+        return ixs;
+    }
+    async initializeAmmCache(txParams) {
+        const initializeAmmCacheIx = await this.getInitializeAmmCacheIx();
+        const tx = await this.buildTransaction(initializeAmmCacheIx, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getInitializeAmmCacheIx() {
+        return await this.program.instruction.initializeAmmCache({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
                 systemProgram: anchor.web3.SystemProgram.programId,
             },
         });
     }
+    async updateInitialAmmCacheInfo(perpMarketIndexes, txParams) {
+        const initializeAmmCacheIx = await this.getUpdateInitialAmmCacheInfoIx(perpMarketIndexes);
+        const tx = await this.buildTransaction(initializeAmmCacheIx, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateInitialAmmCacheInfoIx(perpMarketIndexes) {
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [],
+            readablePerpMarketIndex: perpMarketIndexes,
+            readableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
+        });
+        return await this.program.instruction.updateInitialAmmCacheInfo({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
+            },
+            remainingAccounts,
+        });
+    }
+    async overrideAmmCacheInfo(perpMarketIndex, params, txParams) {
+        const initializeAmmCacheIx = await this.getOverrideAmmCacheInfoIx(perpMarketIndex, params);
+        const tx = await this.buildTransaction(initializeAmmCacheIx, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getOverrideAmmCacheInfoIx(perpMarketIndex, params) {
+        return this.program.instruction.overrideAmmCacheInfo(perpMarketIndex, Object.assign({}, {
+            quoteOwedFromLpPool: null,
+            lastSettleSlot: null,
+            lastFeePoolTokenAmount: null,
+            lastNetPnlPoolTokenAmount: null,
+            ammPositionScalar: null,
+            ammInventoryLimit: null,
+        }, params), {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
+            },
+        });
+    }
+    async resetAmmCache(txParams) {
+        const initializeAmmCacheIx = await this.getResetAmmCacheIx();
+        const tx = await this.buildTransaction(initializeAmmCacheIx, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getResetAmmCacheIx() {
+        return this.program.instruction.resetAmmCache({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+    }
     async initializePredictionMarket(perpMarketIndex) {
         const updatePerpMarketConcentrationCoefIx = await this.getInitializePredictionMarketIx(perpMarketIndex);
         const tx = await this.buildTransaction(updatePerpMarketConcentrationCoefIx);
@@ -365,6 +459,41 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
+    async updatePerpMarketLpPoolId(perpMarketIndex, lpPoolId) {
+        const updatePerpMarketLpPoolIIx = await this.getUpdatePerpMarketLpPoolIdIx(perpMarketIndex, lpPoolId);
+        const tx = await this.buildTransaction(updatePerpMarketLpPoolIIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketLpPoolIdIx(perpMarketIndex, lpPoolId) {
+        return await this.program.instruction.updatePerpMarketLpPoolId(lpPoolId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketLpPoolStatus(perpMarketIndex, lpStatus) {
+        const updatePerpMarketLpPoolStatusIx = await this.getUpdatePerpMarketLpPoolStatusIx(perpMarketIndex, lpStatus);
+        const tx = await this.buildTransaction(updatePerpMarketLpPoolStatusIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketLpPoolStatusIx(perpMarketIndex, lpStatus) {
+        return await this.program.instruction.updatePerpMarketLpPoolStatus(lpStatus, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
+            },
+        });
+    }
     async moveAmmToPrice(perpMarketIndex, targetPrice) {
         const moveAmmPriceIx = await this.getMoveAmmToPriceIx(perpMarketIndex, targetPrice);
         const tx = await this.buildTransaction(moveAmmPriceIx);
@@ -455,6 +584,13 @@ class AdminClient extends driftClient_1.DriftClient {
     }
     async getDepositIntoPerpMarketFeePoolIx(perpMarketIndex, amount, sourceVault) {
         const spotMarket = this.getQuoteSpotMarketAccount();
+        const remainingAccounts = [
+            {
+                pubkey: spotMarket.mint,
+                isWritable: false,
+                isSigner: false,
+            },
+        ];
         return await this.program.instruction.depositIntoPerpMarketFeePool(amount, {
             accounts: {
                 admin: this.isSubscribed
@@ -468,6 +604,7 @@ class AdminClient extends driftClient_1.DriftClient {
                 spotMarketVault: spotMarket.vault,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
+            remainingAccounts,
         });
     }
     async updatePerpMarketPnlPool(perpMarketIndex, amount) {
@@ -1077,6 +1214,7 @@ class AdminClient extends driftClient_1.DriftClient {
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
                 oracle: oracle,
                 oldOracle: this.getPerpMarketAccount(perpMarketIndex).amm.oracle,
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
             },
         });
     }
@@ -1450,6 +1588,7 @@ class AdminClient extends driftClient_1.DriftClient {
                     : this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
             },
         });
     }
@@ -2148,9 +2287,9 @@ class AdminClient extends driftClient_1.DriftClient {
     async getZeroMMOracleFieldsIx(marketIndex) {
         return await this.program.instruction.zeroMmOracleFields({
             accounts: {
-                admin: this.isSubscribed
-                    ? this.getStateAccount().admin
-                    : this.wallet.publicKey,
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().admin,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex),
             },
@@ -2172,6 +2311,38 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
+    async updateFeatureBitFlagsBuilderCodes(enable) {
+        const updateFeatureBitFlagsBuilderCodesIx = await this.getUpdateFeatureBitFlagsBuilderCodesIx(enable);
+        const tx = await this.buildTransaction(updateFeatureBitFlagsBuilderCodesIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateFeatureBitFlagsBuilderCodesIx(enable) {
+        return this.program.instruction.updateFeatureBitFlagsBuilderCodes(enable, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().admin,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateFeatureBitFlagsBuilderReferral(enable) {
+        const updateFeatureBitFlagsBuilderReferralIx = await this.getUpdateFeatureBitFlagsBuilderReferralIx(enable);
+        const tx = await this.buildTransaction(updateFeatureBitFlagsBuilderReferralIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateFeatureBitFlagsBuilderReferralIx(enable) {
+        return this.program.instruction.updateFeatureBitFlagsBuilderReferral(enable, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().admin,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
     async updateFeatureBitFlagsMedianTriggerPrice(enable) {
         const updateFeatureBitFlagsMedianTriggerPriceIx = await this.getUpdateFeatureBitFlagsMedianTriggerPriceIx(enable);
         const tx = await this.buildTransaction(updateFeatureBitFlagsMedianTriggerPriceIx);
@@ -2233,14 +2404,14 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
-    async updateFeatureBitFlagsBuilderCodes(enable) {
-        const updateFeatureBitFlagsBuilderCodesIx = await this.getUpdateFeatureBitFlagsBuilderCodesIx(enable);
-        const tx = await this.buildTransaction(updateFeatureBitFlagsBuilderCodesIx);
+    async updateFeatureBitFlagsSettleLpPool(enable) {
+        const updateFeatureBitFlagsSettleLpPoolIx = await this.getUpdateFeatureBitFlagsSettleLpPoolIx(enable);
+        const tx = await this.buildTransaction(updateFeatureBitFlagsSettleLpPoolIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
-    async getUpdateFeatureBitFlagsBuilderCodesIx(enable) {
-        return this.program.instruction.updateFeatureBitFlagsBuilderCodes(enable, {
+    async getUpdateFeatureBitFlagsSettleLpPoolIx(enable) {
+        return await this.program.instruction.updateFeatureBitFlagsSettleLpPool(enable, {
             accounts: {
                 admin: this.useHotWalletAdmin
                     ? this.wallet.publicKey
@@ -2249,14 +2420,30 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
-    async updateFeatureBitFlagsBuilderReferral(enable) {
-        const updateFeatureBitFlagsBuilderReferralIx = await this.getUpdateFeatureBitFlagsBuilderReferralIx(enable);
-        const tx = await this.buildTransaction(updateFeatureBitFlagsBuilderReferralIx);
+    async updateFeatureBitFlagsSwapLpPool(enable) {
+        const updateFeatureBitFlagsSettleLpPoolIx = await this.getUpdateFeatureBitFlagsSwapLpPoolIx(enable);
+        const tx = await this.buildTransaction(updateFeatureBitFlagsSettleLpPoolIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
-    async getUpdateFeatureBitFlagsBuilderReferralIx(enable) {
-        return this.program.instruction.updateFeatureBitFlagsBuilderReferral(enable, {
+    async getUpdateFeatureBitFlagsSwapLpPoolIx(enable) {
+        return await this.program.instruction.updateFeatureBitFlagsSwapLpPool(enable, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().admin,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateFeatureBitFlagsMintRedeemLpPool(enable) {
+        const updateFeatureBitFlagsSettleLpPoolIx = await this.getUpdateFeatureBitFlagsMintRedeemLpPoolIx(enable);
+        const tx = await this.buildTransaction(updateFeatureBitFlagsSettleLpPoolIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateFeatureBitFlagsMintRedeemLpPoolIx(enable) {
+        return await this.program.instruction.updateFeatureBitFlagsMintRedeemLpPool(enable, {
             accounts: {
                 admin: this.useHotWalletAdmin
                     ? this.wallet.publicKey
@@ -2282,5 +2469,554 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
+    async initializeLpPool(lpPoolId, minMintFee, maxAum, maxSettleQuoteAmountPerMarket, mint, whitelistMint) {
+        const ixs = await this.getInitializeLpPoolIx(lpPoolId, minMintFee, maxAum, maxSettleQuoteAmountPerMarket, mint, whitelistMint);
+        const tx = await this.buildTransaction(ixs);
+        const { txSig } = await this.sendTransaction(tx, [mint]);
+        return txSig;
+    }
+    async getInitializeLpPoolIx(lpPoolId, minMintFee, maxAum, maxSettleQuoteAmountPerMarket, mint, whitelistMint) {
+        const lpPool = (0, pda_1.getLpPoolPublicKey)(this.program.programId, lpPoolId);
+        const ammConstituentMapping = (0, pda_1.getAmmConstituentMappingPublicKey)(this.program.programId, lpPool);
+        const constituentTargetBase = (0, pda_1.getConstituentTargetBasePublicKey)(this.program.programId, lpPool);
+        const lamports = await this.program.provider.connection.getMinimumBalanceForRentExemption(spl_token_1.MINT_SIZE);
+        const createMintAccountIx = web3_js_1.SystemProgram.createAccount({
+            fromPubkey: this.wallet.publicKey,
+            newAccountPubkey: mint.publicKey,
+            space: spl_token_1.MINT_SIZE,
+            lamports: Math.min(0.05 * web3_js_1.LAMPORTS_PER_SOL, lamports), // should be 0.0014616 ? but bankrun returns 10 SOL
+            programId: spl_token_1.TOKEN_PROGRAM_ID,
+        });
+        const createMintIx = (0, spl_token_1.createInitializeMint2Instruction)(mint.publicKey, 6, lpPool, null, spl_token_1.TOKEN_PROGRAM_ID);
+        return [
+            createMintAccountIx,
+            createMintIx,
+            this.program.instruction.initializeLpPool(lpPoolId, minMintFee, maxAum, maxSettleQuoteAmountPerMarket, whitelistMint !== null && whitelistMint !== void 0 ? whitelistMint : web3_js_1.PublicKey.default, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    lpPool,
+                    lpPoolTokenVault: (0, pda_1.getLpPoolTokenVaultPublicKey)(this.program.programId, lpPool),
+                    constituentCorrelations: (0, pda_1.getConstituentCorrelationsPublicKey)(this.program.programId, lpPool),
+                    ammConstituentMapping,
+                    constituentTargetBase,
+                    mint: mint.publicKey,
+                    state: await this.getStatePublicKey(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: web3_js_1.SystemProgram.programId,
+                },
+                signers: [mint],
+            }),
+        ];
+    }
+    async initializeConstituent(lpPoolId, initializeConstituentParams) {
+        const ixs = await this.getInitializeConstituentIx(lpPoolId, initializeConstituentParams);
+        const tx = await this.buildTransaction(ixs);
+        const { txSig } = await this.sendTransaction(tx, []);
+        return txSig;
+    }
+    async getInitializeConstituentIx(lpPoolId, initializeConstituentParams) {
+        const lpPool = (0, pda_1.getLpPoolPublicKey)(this.program.programId, lpPoolId);
+        const spotMarketIndex = initializeConstituentParams.spotMarketIndex;
+        const constituentTargetBase = (0, pda_1.getConstituentTargetBasePublicKey)(this.program.programId, lpPool);
+        const constituent = (0, pda_1.getConstituentPublicKey)(this.program.programId, lpPool, spotMarketIndex);
+        const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
+        return [
+            this.program.instruction.initializeConstituent(spotMarketIndex, initializeConstituentParams.decimals, initializeConstituentParams.maxWeightDeviation, initializeConstituentParams.swapFeeMin, initializeConstituentParams.swapFeeMax, initializeConstituentParams.maxBorrowTokenAmount, initializeConstituentParams.oracleStalenessThreshold, initializeConstituentParams.costToTrade, initializeConstituentParams.constituentDerivativeIndex != null
+                ? initializeConstituentParams.constituentDerivativeIndex
+                : null, initializeConstituentParams.constituentDerivativeDepegThreshold != null
+                ? initializeConstituentParams.constituentDerivativeDepegThreshold
+                : numericConstants_1.ZERO, initializeConstituentParams.constituentDerivativeIndex != null
+                ? initializeConstituentParams.derivativeWeight
+                : numericConstants_1.ZERO, initializeConstituentParams.volatility != null
+                ? initializeConstituentParams.volatility
+                : 10, initializeConstituentParams.gammaExecution != null
+                ? initializeConstituentParams.gammaExecution
+                : 2, initializeConstituentParams.gammaInventory != null
+                ? initializeConstituentParams.gammaInventory
+                : 2, initializeConstituentParams.xi != null
+                ? initializeConstituentParams.xi
+                : 2, initializeConstituentParams.constituentCorrelations, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    lpPool,
+                    constituentTargetBase,
+                    constituent,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: web3_js_1.SystemProgram.programId,
+                    state: await this.getStatePublicKey(),
+                    spotMarketMint: spotMarketAccount.mint,
+                    constituentVault: (0, pda_1.getConstituentVaultPublicKey)(this.program.programId, lpPool, spotMarketIndex),
+                    constituentCorrelations: (0, pda_1.getConstituentCorrelationsPublicKey)(this.program.programId, lpPool),
+                    spotMarket: spotMarketAccount.pubkey,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+                signers: [],
+            }),
+        ];
+    }
+    async updateConstituentStatus(constituent, constituentStatus) {
+        const updateConstituentStatusIx = await this.getUpdateConstituentStatusIx(constituent, constituentStatus);
+        const tx = await this.buildTransaction(updateConstituentStatusIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateConstituentStatusIx(constituent, constituentStatus) {
+        return await this.program.instruction.updateConstituentStatus(constituentStatus, {
+            accounts: {
+                constituent,
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateConstituentPausedOperations(constituent, pausedOperations) {
+        const updateConstituentPausedOperationsIx = await this.getUpdateConstituentPausedOperationsIx(constituent, pausedOperations);
+        const tx = await this.buildTransaction(updateConstituentPausedOperationsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateConstituentPausedOperationsIx(constituent, pausedOperations) {
+        return await this.program.instruction.updateConstituentPausedOperations(pausedOperations, {
+            accounts: {
+                constituent,
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateConstituentParams(lpPoolId, constituentPublicKey, updateConstituentParams) {
+        const ixs = await this.getUpdateConstituentParamsIx(lpPoolId, constituentPublicKey, updateConstituentParams);
+        const tx = await this.buildTransaction(ixs);
+        const { txSig } = await this.sendTransaction(tx, []);
+        return txSig;
+    }
+    async getUpdateConstituentParamsIx(lpPoolId, constituentPublicKey, updateConstituentParams) {
+        const lpPool = (0, pda_1.getLpPoolPublicKey)(this.program.programId, lpPoolId);
+        return [
+            this.program.instruction.updateConstituentParams(Object.assign({
+                maxWeightDeviation: null,
+                swapFeeMin: null,
+                swapFeeMax: null,
+                maxBorrowTokenAmount: null,
+                oracleStalenessThreshold: null,
+                costToTradeBps: null,
+                stablecoinWeight: null,
+                derivativeWeight: null,
+                constituentDerivativeIndex: null,
+                volatility: null,
+                gammaExecution: null,
+                gammaInventory: null,
+                xi: null,
+            }, updateConstituentParams), {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    constituent: constituentPublicKey,
+                    state: await this.getStatePublicKey(),
+                    lpPool,
+                    constituentTargetBase: (0, pda_1.getConstituentTargetBasePublicKey)(this.program.programId, lpPool),
+                },
+                signers: [],
+            }),
+        ];
+    }
+    async updateLpPoolParams(lpPoolId, updateLpPoolParams) {
+        const ixs = await this.getUpdateLpPoolParamsIx(lpPoolId, updateLpPoolParams);
+        const tx = await this.buildTransaction(ixs);
+        const { txSig } = await this.sendTransaction(tx, []);
+        return txSig;
+    }
+    async getUpdateLpPoolParamsIx(lpPoolId, updateLpPoolParams) {
+        const lpPool = (0, pda_1.getLpPoolPublicKey)(this.program.programId, lpPoolId);
+        return [
+            this.program.instruction.updateLpPoolParams(Object.assign({
+                maxSettleQuoteAmount: null,
+                volatility: null,
+                gammaExecution: null,
+                xi: null,
+                whitelistMint: null,
+                maxAum: null,
+            }, updateLpPoolParams), {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: await this.getStatePublicKey(),
+                    lpPool,
+                },
+                signers: [],
+            }),
+        ];
+    }
+    async addAmmConstituentMappingData(lpPoolId, addAmmConstituentMappingData) {
+        const ixs = await this.getAddAmmConstituentMappingDataIx(lpPoolId, addAmmConstituentMappingData);
+        const tx = await this.buildTransaction(ixs);
+        const { txSig } = await this.sendTransaction(tx, []);
+        return txSig;
+    }
+    async getAddAmmConstituentMappingDataIx(lpPoolId, addAmmConstituentMappingData) {
+        const lpPool = (0, pda_1.getLpPoolPublicKey)(this.program.programId, lpPoolId);
+        const ammConstituentMapping = (0, pda_1.getAmmConstituentMappingPublicKey)(this.program.programId, lpPool);
+        const constituentTargetBase = (0, pda_1.getConstituentTargetBasePublicKey)(this.program.programId, lpPool);
+        return [
+            this.program.instruction.addAmmConstituentMappingData(addAmmConstituentMappingData, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    lpPool,
+                    ammConstituentMapping,
+                    constituentTargetBase,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: web3_js_1.SystemProgram.programId,
+                    state: await this.getStatePublicKey(),
+                },
+            }),
+        ];
+    }
+    async updateAmmConstituentMappingData(lpPoolId, addAmmConstituentMappingData) {
+        const ixs = await this.getUpdateAmmConstituentMappingDataIx(lpPoolId, addAmmConstituentMappingData);
+        const tx = await this.buildTransaction(ixs);
+        const { txSig } = await this.sendTransaction(tx, []);
+        return txSig;
+    }
+    async getUpdateAmmConstituentMappingDataIx(lpPoolId, addAmmConstituentMappingData) {
+        const lpPool = (0, pda_1.getLpPoolPublicKey)(this.program.programId, lpPoolId);
+        const ammConstituentMapping = (0, pda_1.getAmmConstituentMappingPublicKey)(this.program.programId, lpPool);
+        return [
+            this.program.instruction.updateAmmConstituentMappingData(addAmmConstituentMappingData, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    lpPool,
+                    ammConstituentMapping,
+                    systemProgram: web3_js_1.SystemProgram.programId,
+                    state: await this.getStatePublicKey(),
+                },
+            }),
+        ];
+    }
+    async removeAmmConstituentMappingData(lpPoolId, perpMarketIndex, constituentIndex) {
+        const ixs = await this.getRemoveAmmConstituentMappingDataIx(lpPoolId, perpMarketIndex, constituentIndex);
+        const tx = await this.buildTransaction(ixs);
+        const { txSig } = await this.sendTransaction(tx, []);
+        return txSig;
+    }
+    async getRemoveAmmConstituentMappingDataIx(lpPoolId, perpMarketIndex, constituentIndex) {
+        const lpPool = (0, pda_1.getLpPoolPublicKey)(this.program.programId, lpPoolId);
+        const ammConstituentMapping = (0, pda_1.getAmmConstituentMappingPublicKey)(this.program.programId, lpPool);
+        return [
+            this.program.instruction.removeAmmConstituentMappingData(perpMarketIndex, constituentIndex, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    lpPool,
+                    ammConstituentMapping,
+                    systemProgram: web3_js_1.SystemProgram.programId,
+                    state: await this.getStatePublicKey(),
+                },
+            }),
+        ];
+    }
+    async updateConstituentCorrelationData(lpPoolId, index1, index2, correlation) {
+        const ixs = await this.getUpdateConstituentCorrelationDataIx(lpPoolId, index1, index2, correlation);
+        const tx = await this.buildTransaction(ixs);
+        const { txSig } = await this.sendTransaction(tx, []);
+        return txSig;
+    }
+    async getUpdateConstituentCorrelationDataIx(lpPoolId, index1, index2, correlation) {
+        const lpPool = (0, pda_1.getLpPoolPublicKey)(this.program.programId, lpPoolId);
+        return [
+            this.program.instruction.updateConstituentCorrelationData(index1, index2, correlation, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    lpPool,
+                    constituentCorrelations: (0, pda_1.getConstituentCorrelationsPublicKey)(this.program.programId, lpPool),
+                    state: await this.getStatePublicKey(),
+                },
+            }),
+        ];
+    }
+    /**
+     * Get the drift begin_swap and end_swap instructions
+     *
+     * @param outMarketIndex the market index of the token you're buying
+     * @param inMarketIndex the market index of the token you're selling
+     * @param amountIn the amount of the token to sell
+     * @param inTokenAccount the token account to move the tokens being sold (admin signer ata for lp swap)
+     * @param outTokenAccount the token account to receive the tokens being bought (admin signer ata for lp swap)
+     * @param limitPrice the limit price of the swap
+     * @param reduceOnly
+     * @param userAccountPublicKey optional, specify a custom userAccountPublicKey to use instead of getting the current user account; can be helpful if the account is being created within the current tx
+     */
+    async getSwapIx({ lpPoolId, outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, userAccountPublicKey, }, lpSwap) {
+        if (!lpSwap) {
+            return super.getSwapIx({
+                outMarketIndex,
+                inMarketIndex,
+                amountIn,
+                inTokenAccount,
+                outTokenAccount,
+                limitPrice,
+                reduceOnly,
+                userAccountPublicKey,
+            });
+        }
+        const outSpotMarket = this.getSpotMarketAccount(outMarketIndex);
+        const inSpotMarket = this.getSpotMarketAccount(inMarketIndex);
+        const outTokenProgram = this.getTokenProgramForSpotMarket(outSpotMarket);
+        const inTokenProgram = this.getTokenProgramForSpotMarket(inSpotMarket);
+        const lpPool = (0, pda_1.getLpPoolPublicKey)(this.program.programId, lpPoolId);
+        const outConstituent = (0, pda_1.getConstituentPublicKey)(this.program.programId, lpPool, outMarketIndex);
+        const inConstituent = (0, pda_1.getConstituentPublicKey)(this.program.programId, lpPool, inMarketIndex);
+        const outConstituentTokenAccount = (0, pda_1.getConstituentVaultPublicKey)(this.program.programId, lpPool, outMarketIndex);
+        const inConstituentTokenAccount = (0, pda_1.getConstituentVaultPublicKey)(this.program.programId, lpPool, inMarketIndex);
+        const beginSwapIx = this.program.instruction.beginLpSwap(inMarketIndex, outMarketIndex, amountIn, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                signerOutTokenAccount: outTokenAccount,
+                signerInTokenAccount: inTokenAccount,
+                constituentOutTokenAccount: outConstituentTokenAccount,
+                constituentInTokenAccount: inConstituentTokenAccount,
+                outConstituent,
+                inConstituent,
+                lpPool,
+                instructions: anchor.web3.SYSVAR_INSTRUCTIONS_PUBKEY,
+                tokenProgram: inTokenProgram,
+            },
+        });
+        const remainingAccounts = [];
+        remainingAccounts.push({
+            pubkey: outTokenProgram,
+            isWritable: false,
+            isSigner: false,
+        });
+        const endSwapIx = this.program.instruction.endLpSwap(inMarketIndex, outMarketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                signerOutTokenAccount: outTokenAccount,
+                signerInTokenAccount: inTokenAccount,
+                constituentOutTokenAccount: outConstituentTokenAccount,
+                constituentInTokenAccount: inConstituentTokenAccount,
+                outConstituent,
+                inConstituent,
+                lpPool,
+                tokenProgram: inTokenProgram,
+                instructions: anchor.web3.SYSVAR_INSTRUCTIONS_PUBKEY,
+            },
+            remainingAccounts,
+        });
+        return { beginSwapIx, endSwapIx };
+    }
+    async getLpJupiterSwapIxV6({ jupiterClient, outMarketIndex, inMarketIndex, amount, slippageBps, swapMode, onlyDirectRoutes, quote, lpPoolId, }) {
+        const outMarket = this.getSpotMarketAccount(outMarketIndex);
+        const inMarket = this.getSpotMarketAccount(inMarketIndex);
+        if (!quote) {
+            const fetchedQuote = await jupiterClient.getQuote({
+                inputMint: inMarket.mint,
+                outputMint: outMarket.mint,
+                amount,
+                slippageBps,
+                swapMode,
+                onlyDirectRoutes,
+            });
+            quote = fetchedQuote;
+        }
+        if (!quote) {
+            throw new Error("Could not fetch Jupiter's quote. Please try again.");
+        }
+        const isExactOut = swapMode === 'ExactOut' || quote.swapMode === 'ExactOut';
+        const amountIn = new anchor_1.BN(quote.inAmount);
+        const exactOutBufferedAmountIn = amountIn.muln(1001).divn(1000); // Add 10bp buffer
+        const transaction = await jupiterClient.getSwap({
+            quote,
+            userPublicKey: this.provider.wallet.publicKey,
+            slippageBps,
+        });
+        const { transactionMessage, lookupTables } = await jupiterClient.getTransactionMessageAndLookupTables({
+            transaction,
+        });
+        const jupiterInstructions = jupiterClient.getJupiterInstructions({
+            transactionMessage,
+            inputMint: inMarket.mint,
+            outputMint: outMarket.mint,
+        });
+        const preInstructions = [];
+        const tokenProgram = this.getTokenProgramForSpotMarket(outMarket);
+        const outAssociatedTokenAccount = await this.getAssociatedTokenAccount(outMarket.marketIndex, false, tokenProgram);
+        const outAccountInfo = await this.connection.getAccountInfo(outAssociatedTokenAccount);
+        if (!outAccountInfo) {
+            preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(outAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, outMarket.mint, tokenProgram));
+        }
+        const inTokenProgram = this.getTokenProgramForSpotMarket(inMarket);
+        const inAssociatedTokenAccount = await this.getAssociatedTokenAccount(inMarket.marketIndex, false, inTokenProgram);
+        const inAccountInfo = await this.connection.getAccountInfo(inAssociatedTokenAccount);
+        if (!inAccountInfo) {
+            preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(inAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, inMarket.mint, tokenProgram));
+        }
+        const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+            lpPoolId,
+            outMarketIndex,
+            inMarketIndex,
+            amountIn: isExactOut ? exactOutBufferedAmountIn : amountIn,
+            inTokenAccount: inAssociatedTokenAccount,
+            outTokenAccount: outAssociatedTokenAccount,
+        });
+        const ixs = [
+            ...preInstructions,
+            beginSwapIx,
+            ...jupiterInstructions,
+            endSwapIx,
+        ];
+        return { ixs, lookupTables };
+    }
+    async getDevnetLpSwapIxs(amountIn, amountOut, externalUserAuthority, externalUserInTokenAccount, externalUserOutTokenAccount, inSpotMarketIndex, outSpotMarketIndex) {
+        const inSpotMarketAccount = this.getSpotMarketAccount(inSpotMarketIndex);
+        const outSpotMarketAccount = this.getSpotMarketAccount(outSpotMarketIndex);
+        const outTokenAccount = await this.getAssociatedTokenAccount(outSpotMarketAccount.marketIndex, false, (0, pda_1.getTokenProgramForSpotMarket)(outSpotMarketAccount));
+        const inTokenAccount = await this.getAssociatedTokenAccount(inSpotMarketAccount.marketIndex, false, (0, pda_1.getTokenProgramForSpotMarket)(inSpotMarketAccount));
+        const externalCreateInTokenAccountIx = this.createAssociatedTokenAccountIdempotentInstruction(externalUserInTokenAccount, this.wallet.publicKey, externalUserAuthority, this.getSpotMarketAccount(inSpotMarketIndex).mint);
+        const externalCreateOutTokenAccountIx = this.createAssociatedTokenAccountIdempotentInstruction(externalUserOutTokenAccount, this.wallet.publicKey, externalUserAuthority, this.getSpotMarketAccount(outSpotMarketIndex).mint);
+        const outTransferIx = (0, spl_token_1.createTransferCheckedInstruction)(externalUserOutTokenAccount, outSpotMarketAccount.mint, outTokenAccount, externalUserAuthority, amountOut.toNumber(), outSpotMarketAccount.decimals, undefined, (0, pda_1.getTokenProgramForSpotMarket)(outSpotMarketAccount));
+        const inTransferIx = (0, spl_token_1.createTransferCheckedInstruction)(inTokenAccount, inSpotMarketAccount.mint, externalUserInTokenAccount, this.wallet.publicKey, amountIn.toNumber(), inSpotMarketAccount.decimals, undefined, (0, pda_1.getTokenProgramForSpotMarket)(inSpotMarketAccount));
+        const ixs = [
+            externalCreateInTokenAccountIx,
+            externalCreateOutTokenAccountIx,
+            outTransferIx,
+            inTransferIx,
+        ];
+        return ixs;
+    }
+    async getAllDevnetLpSwapIxs(lpPoolId, inMarketIndex, outMarketIndex, inAmount, minOutAmount, externalUserAuthority) {
+        const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+            lpPoolId,
+            inMarketIndex,
+            outMarketIndex,
+            amountIn: inAmount,
+            inTokenAccount: await this.getAssociatedTokenAccount(inMarketIndex, false),
+            outTokenAccount: await this.getAssociatedTokenAccount(outMarketIndex, false),
+        }, true);
+        const devnetLpSwapIxs = await this.getDevnetLpSwapIxs(inAmount, minOutAmount, externalUserAuthority, await this.getAssociatedTokenAccount(inMarketIndex, false, (0, pda_1.getTokenProgramForSpotMarket)(this.getSpotMarketAccount(inMarketIndex)), externalUserAuthority), await this.getAssociatedTokenAccount(outMarketIndex, false, (0, pda_1.getTokenProgramForSpotMarket)(this.getSpotMarketAccount(outMarketIndex)), externalUserAuthority), inMarketIndex, outMarketIndex);
+        return [
+            beginSwapIx,
+            ...devnetLpSwapIxs,
+            endSwapIx,
+        ];
+    }
+    async depositWithdrawToProgramVault(lpPoolId, depositMarketIndex, borrowMarketIndex, amountToDeposit, amountToBorrow) {
+        const { depositIx, withdrawIx } = await this.getDepositWithdrawToProgramVaultIxs(lpPoolId, depositMarketIndex, borrowMarketIndex, amountToDeposit, amountToBorrow);
+        const tx = await this.buildTransaction([depositIx, withdrawIx]);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getDepositWithdrawToProgramVaultIxs(lpPoolId, depositMarketIndex, borrowMarketIndex, amountToDeposit, amountToBorrow) {
+        const lpPool = (0, pda_1.getLpPoolPublicKey)(this.program.programId, lpPoolId);
+        const depositSpotMarket = this.getSpotMarketAccount(depositMarketIndex);
+        const withdrawSpotMarket = this.getSpotMarketAccount(borrowMarketIndex);
+        const depositTokenProgram = this.getTokenProgramForSpotMarket(depositSpotMarket);
+        const withdrawTokenProgram = this.getTokenProgramForSpotMarket(withdrawSpotMarket);
+        const depositConstituent = (0, pda_1.getConstituentPublicKey)(this.program.programId, lpPool, depositMarketIndex);
+        const withdrawConstituent = (0, pda_1.getConstituentPublicKey)(this.program.programId, lpPool, borrowMarketIndex);
+        const depositConstituentTokenAccount = (0, pda_1.getConstituentVaultPublicKey)(this.program.programId, lpPool, depositMarketIndex);
+        const withdrawConstituentTokenAccount = (0, pda_1.getConstituentVaultPublicKey)(this.program.programId, lpPool, borrowMarketIndex);
+        const depositIx = this.program.instruction.depositToProgramVault(amountToDeposit, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                constituent: depositConstituent,
+                constituentTokenAccount: depositConstituentTokenAccount,
+                spotMarket: depositSpotMarket.pubkey,
+                spotMarketVault: depositSpotMarket.vault,
+                tokenProgram: depositTokenProgram,
+                mint: depositSpotMarket.mint,
+                oracle: depositSpotMarket.oracle,
+            },
+        });
+        const withdrawIx = this.program.instruction.withdrawFromProgramVault(amountToBorrow, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                constituent: withdrawConstituent,
+                constituentTokenAccount: withdrawConstituentTokenAccount,
+                spotMarket: withdrawSpotMarket.pubkey,
+                spotMarketVault: withdrawSpotMarket.vault,
+                tokenProgram: withdrawTokenProgram,
+                mint: withdrawSpotMarket.mint,
+                driftSigner: (0, pda_1.getDriftSignerPublicKey)(this.program.programId),
+                oracle: withdrawSpotMarket.oracle,
+            },
+        });
+        return { depositIx, withdrawIx };
+    }
+    async depositToProgramVault(lpPoolId, depositMarketIndex, amountToDeposit) {
+        const depositIx = await this.getDepositToProgramVaultIx(lpPoolId, depositMarketIndex, amountToDeposit);
+        const tx = await this.buildTransaction([depositIx]);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async withdrawFromProgramVault(lpPoolId, borrowMarketIndex, amountToWithdraw) {
+        const withdrawIx = await this.getWithdrawFromProgramVaultIx(lpPoolId, borrowMarketIndex, amountToWithdraw);
+        const tx = await this.buildTransaction([withdrawIx]);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getDepositToProgramVaultIx(lpPoolId, depositMarketIndex, amountToDeposit) {
+        const { depositIx } = await this.getDepositWithdrawToProgramVaultIxs(lpPoolId, depositMarketIndex, depositMarketIndex, amountToDeposit, new anchor_1.BN(0));
+        return depositIx;
+    }
+    async getWithdrawFromProgramVaultIx(lpPoolId, borrowMarketIndex, amountToWithdraw) {
+        const { withdrawIx } = await this.getDepositWithdrawToProgramVaultIxs(lpPoolId, borrowMarketIndex, borrowMarketIndex, new anchor_1.BN(0), amountToWithdraw);
+        return withdrawIx;
+    }
+    async updatePerpMarketLpPoolFeeTransferScalar(marketIndex, lpFeeTransferScalar, lpExchangeFeeExcluscionScalar) {
+        const ix = await this.getUpdatePerpMarketLpPoolFeeTransferScalarIx(marketIndex, lpFeeTransferScalar, lpExchangeFeeExcluscionScalar);
+        const tx = await this.buildTransaction(ix);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketLpPoolFeeTransferScalarIx(marketIndex, lpFeeTransferScalar, lpExchangeFeeExcluscionScalar) {
+        return this.program.instruction.updatePerpMarketLpPoolFeeTransferScalar(lpFeeTransferScalar !== null && lpFeeTransferScalar !== void 0 ? lpFeeTransferScalar : null, lpExchangeFeeExcluscionScalar !== null && lpExchangeFeeExcluscionScalar !== void 0 ? lpExchangeFeeExcluscionScalar : null, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: this.getPerpMarketAccount(marketIndex).pubkey,
+            },
+        });
+    }
+    async updatePerpMarketLpPoolPausedOperations(marketIndex, pausedOperations) {
+        const ix = await this.getUpdatePerpMarketLpPoolPausedOperationsIx(marketIndex, pausedOperations);
+        const tx = await this.buildTransaction(ix);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketLpPoolPausedOperationsIx(marketIndex, pausedOperations) {
+        return this.program.instruction.updatePerpMarketLpPoolPausedOperations(pausedOperations, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: this.getPerpMarketAccount(marketIndex).pubkey,
+            },
+        });
+    }
+    async mintLpWhitelistToken(lpPool, authority) {
+        const ix = await this.getMintLpWhitelistTokenIx(lpPool, authority);
+        const tx = await this.buildTransaction(ix);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getMintLpWhitelistTokenIx(lpPool, authority) {
+        const mintAmount = 1000;
+        const associatedTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(lpPool.whitelistMint, authority, false);
+        const ixs = [];
+        const createInstruction = this.createAssociatedTokenAccountIdempotentInstruction(associatedTokenAccount, this.wallet.publicKey, authority, lpPool.whitelistMint);
+        ixs.push(createInstruction);
+        const mintToInstruction = (0, spl_token_1.createMintToInstruction)(lpPool.whitelistMint, associatedTokenAccount, this.wallet.publicKey, mintAmount, [], spl_token_1.TOKEN_PROGRAM_ID);
+        ixs.push(mintToInstruction);
+        return ixs;
+    }
 }
 exports.AdminClient = AdminClient;