@velocity-exchange/sdk 0.0.1

package/lib/browser/adminClient.js

@@ -0,0 +1,2798 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HotRole = exports.AdminClient = void 0;
+/**
+ * AdminClient — governance and protocol administration instruction builders.
+ * Extends {@link VelocityClient}; all trading/keeper methods are also available.
+ *
+ * Covers: perp/spot market initialization and updates, oracle guard rail config,
+ * fee structure updates, insurance fund operations, vault management, IF rebalancing,
+ * pause/unpause exchange, and all ~126 admin instruction handlers in `instructions/admin.rs`.
+ */
+const web3_js_1 = require("@solana/web3.js");
+const types_1 = require("./types");
+const userName_1 = require("./userName");
+const anchor_1 = require("./isomorphic/anchor");
+const anchor = __importStar(require("./isomorphic/anchor"));
+const pda_1 = require("./addresses/pda");
+const utils_1 = require("./math/utils");
+const spl_token_1 = require("@solana/spl-token");
+const velocityClient_1 = require("./velocityClient");
+const numericConstants_1 = require("./constants/numericConstants");
+const trade_1 = require("./math/trade");
+const amm_1 = require("./math/amm");
+class AdminClient extends velocityClient_1.VelocityClient {
+    async initialize(usdcMint, _adminControlsPrices) {
+        const stateAccountRPCResponse = await this.connection.getParsedAccountInfo(await this.getStatePublicKey());
+        if (stateAccountRPCResponse.value !== null) {
+            throw new Error('Clearing house already initialized');
+        }
+        const [driftStatePublicKey] = await (0, pda_1.getVelocityStateAccountPublicKeyAndNonce)(this.program.programId);
+        const initializeIx = await this.program.instruction.initialize({
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: driftStatePublicKey,
+                quoteAssetMint: usdcMint,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                driftSigner: this.getSignerPublicKey(),
+                systemProgram: anchor.web3.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+        });
+        const tx = await this.buildTransaction(initializeIx);
+        const { txSig } = await super.sendTransaction(tx, [], this.opts);
+        return [txSig];
+    }
+    async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0, liquidatorFee = 0, ifLiquidationFee = 0, activeStatus = true, assetTier = types_1.AssetTier.COLLATERAL, scaleInitialAssetWeightStart = numericConstants_1.ZERO, withdrawGuardThreshold = numericConstants_1.ZERO, orderTickSize = numericConstants_1.ONE, orderStepSize = numericConstants_1.ONE, ifTotalFactor = 0, name = userName_1.DEFAULT_MARKET_NAME, marketIndex) {
+        const spotMarketIndex = marketIndex !== null && marketIndex !== void 0 ? marketIndex : this.getStateAccount().numberOfSpotMarkets;
+        const initializeIx = await this.getInitializeSpotMarketIx(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidatorFee, ifLiquidationFee, activeStatus, assetTier, scaleInitialAssetWeightStart, withdrawGuardThreshold, orderTickSize, orderStepSize, ifTotalFactor, name, marketIndex);
+        const tx = await this.buildTransaction(initializeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        await this.accountSubscriber.addSpotMarket(spotMarketIndex);
+        await this.accountSubscriber.addOracle({
+            source: oracleSource,
+            publicKey: oracle,
+        });
+        await this.accountSubscriber.setSpotOracleMap();
+        return txSig;
+    }
+    async getInitializeSpotMarketIx(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0, liquidatorFee = 0, ifLiquidationFee = 0, activeStatus = true, assetTier = types_1.AssetTier.COLLATERAL, scaleInitialAssetWeightStart = numericConstants_1.ZERO, withdrawGuardThreshold = numericConstants_1.ZERO, orderTickSize = numericConstants_1.ONE, orderStepSize = numericConstants_1.ONE, ifTotalFactor = 0, name = userName_1.DEFAULT_MARKET_NAME, marketIndex) {
+        const spotMarketIndex = marketIndex !== null && marketIndex !== void 0 ? marketIndex : this.getStateAccount().numberOfSpotMarkets;
+        const spotMarket = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex);
+        const spotMarketVault = await (0, pda_1.getSpotMarketVaultPublicKey)(this.program.programId, spotMarketIndex);
+        const insuranceFundVault = await (0, pda_1.getInsuranceFundVaultPublicKey)(this.program.programId, spotMarketIndex);
+        const tokenProgram = (await this.connection.getAccountInfo(mint)).owner;
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        const initializeIx = await this.program.instruction.initializeSpotMarket(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidatorFee, ifLiquidationFee, activeStatus, assetTier, scaleInitialAssetWeightStart, withdrawGuardThreshold, orderTickSize, orderStepSize, ifTotalFactor, nameBuffer, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.isSubscribed
+                        ? this.getStateAccount().coldAdmin
+                        : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket,
+                spotMarketVault,
+                insuranceFundVault,
+                driftSigner: this.getSignerPublicKey(),
+                spotMarketMint: mint,
+                oracle,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                tokenProgram,
+            },
+        });
+        return initializeIx;
+    }
+    async deleteInitializedSpotMarket(marketIndex) {
+        const deleteInitializeMarketIx = await this.getDeleteInitializedSpotMarketIx(marketIndex);
+        const tx = await this.buildTransaction(deleteInitializeMarketIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getDeleteInitializedSpotMarketIx(marketIndex) {
+        const spotMarketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex);
+        const spotMarketVaultPublicKey = await (0, pda_1.getSpotMarketVaultPublicKey)(this.program.programId, marketIndex);
+        const insuranceFundVaultPublicKey = await (0, pda_1.getInsuranceFundVaultPublicKey)(this.program.programId, marketIndex);
+        return await this.program.instruction.deleteInitializedSpotMarket(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                spotMarket: spotMarketPublicKey,
+                spotMarketVault: spotMarketVaultPublicKey,
+                insuranceFundVault: insuranceFundVaultPublicKey,
+                driftSigner: this.getSignerPublicKey(),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+        });
+    }
+    async initializePerpMarket(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH_LAZER, 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 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, lpPoolId);
+        const tx = await this.buildTransaction(initializeMarketIxs);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        while (this.getStateAccount().numberOfMarkets <= currentPerpMarketIndex) {
+            await this.fetchAccounts();
+        }
+        await this.accountSubscriber.addPerpMarket(marketIndex);
+        await this.accountSubscriber.addOracle({
+            source: oracleSource,
+            publicKey: priceOracle,
+        });
+        await this.accountSubscriber.setPerpOracleMap();
+        return txSig;
+    }
+    async getInitializePerpMarketIx(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH_LAZER, 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 perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        const ixs = [];
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        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.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.isSubscribed
+                        ? this.getStateAccount().coldAdmin
+                        : this.wallet.publicKey,
+                oracle: priceOracle,
+                perpMarket: perpMarketPublicKey,
+                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.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+    }
+    async addMarketToAmmCache(perpMarketIndex, txParams) {
+        const initializeAmmCacheIx = await this.getAddMarketToAmmCacheIx(perpMarketIndex);
+        const tx = await this.buildTransaction(initializeAmmCacheIx, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getAddMarketToAmmCacheIx(perpMarketIndex) {
+        return await this.program.instruction.addMarketToAmmCache({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                perpMarket: this.getPerpMarketAccount(perpMarketIndex).pubkey,
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+    }
+    async deleteAmmCache(txParams) {
+        const deleteAmmCacheIx = await this.getDeleteAmmCacheIx();
+        const tx = await this.buildTransaction(deleteAmmCacheIx, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getDeleteAmmCacheIx() {
+        return await this.program.instruction.deleteAmmCache({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.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.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                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.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                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.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                ammCache: (0, pda_1.getAmmCachePublicKey)(this.program.programId),
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+    }
+    async deleteInitializedPerpMarket(marketIndex) {
+        const deleteInitializeMarketIx = await this.getDeleteInitializedPerpMarketIx(marketIndex);
+        const tx = await this.buildTransaction(deleteInitializeMarketIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getDeleteInitializedPerpMarketIx(marketIndex) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        return await this.program.instruction.deleteInitializedPerpMarket(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    async moveAmmPrice(perpMarketIndex, baseAssetReserve, quoteAssetReserve, sqrtK) {
+        const moveAmmPriceIx = await this.getMoveAmmPriceIx(perpMarketIndex, baseAssetReserve, quoteAssetReserve, sqrtK);
+        const tx = await this.buildTransaction(moveAmmPriceIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getMoveAmmPriceIx(perpMarketIndex, baseAssetReserve, quoteAssetReserve, sqrtK) {
+        const marketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        if (sqrtK == undefined) {
+            sqrtK = (0, utils_1.squareRootBN)(baseAssetReserve.mul(quoteAssetReserve));
+        }
+        return await this.program.instruction.moveAmmPrice(baseAssetReserve, quoteAssetReserve, sqrtK, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                perpMarket: marketPublicKey,
+            },
+        });
+    }
+    async updateK(perpMarketIndex, sqrtK) {
+        const updateKIx = await this.getUpdateKIx(perpMarketIndex, sqrtK);
+        const tx = await this.buildTransaction(updateKIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateKIx(perpMarketIndex, sqrtK) {
+        return await this.program.instruction.updateK(sqrtK, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                oracle: this.getPerpMarketAccount(perpMarketIndex).amm.oracle,
+            },
+        });
+    }
+    async recenterPerpMarketAmm(perpMarketIndex, pegMultiplier, sqrtK) {
+        const recenterPerpMarketAmmIx = await this.getRecenterPerpMarketAmmIx(perpMarketIndex, pegMultiplier, sqrtK);
+        const tx = await this.buildTransaction(recenterPerpMarketAmmIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getRecenterPerpMarketAmmIx(perpMarketIndex, pegMultiplier, sqrtK) {
+        const marketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.instruction.recenterPerpMarketAmm(pegMultiplier, sqrtK, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                perpMarket: marketPublicKey,
+            },
+        });
+    }
+    async recenterPerpMarketAmmCrank(perpMarketIndex, depth) {
+        const recenterPerpMarketAmmIx = await this.getRecenterPerpMarketAmmCrankIx(perpMarketIndex, depth);
+        const tx = await this.buildTransaction(recenterPerpMarketAmmIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getRecenterPerpMarketAmmCrankIx(perpMarketIndex, depth) {
+        return await this.program.instruction.recenterPerpMarketAmmCrank(depth !== null && depth !== void 0 ? depth : null, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, numericConstants_1.QUOTE_SPOT_MARKET_INDEX),
+                oracle: this.getPerpMarketAccount(perpMarketIndex).amm.oracle,
+            },
+        });
+    }
+    async updatePerpMarketConcentrationScale(perpMarketIndex, concentrationScale) {
+        const updatePerpMarketConcentrationCoefIx = await this.getUpdatePerpMarketConcentrationScaleIx(perpMarketIndex, concentrationScale);
+        const tx = await this.buildTransaction(updatePerpMarketConcentrationCoefIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketConcentrationScaleIx(perpMarketIndex, concentrationScale) {
+        return await this.program.instruction.updatePerpMarketConcentrationCoef(concentrationScale, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    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().coldAdmin
+                    : 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().coldAdmin
+                    : 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);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getMoveAmmToPriceIx(perpMarketIndex, targetPrice) {
+        const perpMarket = this.getPerpMarketAccount(perpMarketIndex);
+        const [direction, tradeSize, _] = (0, trade_1.calculateTargetPriceTrade)(perpMarket, targetPrice, new anchor_1.BN(1000), 'quote', undefined //todo
+        );
+        const [newQuoteAssetAmount, newBaseAssetAmount] = (0, amm_1.calculateAmmReservesAfterSwap)(perpMarket.amm, 'quote', tradeSize, (0, amm_1.getSwapDirection)('quote', direction));
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.instruction.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, perpMarket.amm.sqrtK, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    async repegAmmCurve(newPeg, perpMarketIndex) {
+        const repegAmmCurveIx = await this.getRepegAmmCurveIx(newPeg, perpMarketIndex);
+        const tx = await this.buildTransaction(repegAmmCurveIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getRepegAmmCurveIx(newPeg, perpMarketIndex) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
+        return await this.program.instruction.repegAmmCurve(newPeg, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                oracle: ammData.oracle,
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    async updatePerpMarketAmmOracleTwap(perpMarketIndex) {
+        const updatePerpMarketAmmOracleTwapIx = await this.getUpdatePerpMarketAmmOracleTwapIx(perpMarketIndex);
+        const tx = await this.buildTransaction(updatePerpMarketAmmOracleTwapIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketAmmOracleTwapIx(perpMarketIndex) {
+        const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.instruction.updatePerpMarketAmmOracleTwap({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                oracle: ammData.oracle,
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    async resetPerpMarketAmmOracleTwap(perpMarketIndex) {
+        const resetPerpMarketAmmOracleTwapIx = await this.getResetPerpMarketAmmOracleTwapIx(perpMarketIndex);
+        const tx = await this.buildTransaction(resetPerpMarketAmmOracleTwapIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getResetPerpMarketAmmOracleTwapIx(perpMarketIndex) {
+        const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.instruction.resetPerpMarketAmmOracleTwap({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                oracle: ammData.oracle,
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    async depositIntoPerpMarketFeePool(perpMarketIndex, amount, sourceVault) {
+        const depositIntoPerpMarketFeePoolIx = await this.getDepositIntoPerpMarketFeePoolIx(perpMarketIndex, amount, sourceVault);
+        const tx = await this.buildTransaction(depositIntoPerpMarketFeePoolIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    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
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                sourceVault,
+                driftSigner: this.getSignerPublicKey(),
+                quoteSpotMarket: spotMarket.pubkey,
+                spotMarketVault: spotMarket.vault,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+    }
+    async updatePerpMarketPnlPool(perpMarketIndex, amount) {
+        const updatePerpMarketPnlPoolIx = await this.getUpdatePerpMarketPnlPoolIx(perpMarketIndex, amount);
+        const tx = await this.buildTransaction(updatePerpMarketPnlPoolIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketPnlPoolIx(perpMarketIndex, amount) {
+        return await this.program.instruction.updatePerpMarketPnlPool(amount, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                spotMarket: this.getQuoteSpotMarketAccount().pubkey,
+                spotMarketVault: this.getQuoteSpotMarketAccount().vault,
+            },
+        });
+    }
+    async depositIntoSpotMarketVault(spotMarketIndex, amount, sourceVault) {
+        const depositIntoPerpMarketFeePoolIx = await this.getDepositIntoSpotMarketVaultIx(spotMarketIndex, amount, sourceVault);
+        const tx = await this.buildTransaction(depositIntoPerpMarketFeePoolIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getDepositIntoSpotMarketVaultIx(spotMarketIndex, amount, sourceVault) {
+        const spotMarket = this.getSpotMarketAccount(spotMarketIndex);
+        const remainingAccounts = [];
+        this.addTokenMintToRemainingAccounts(spotMarket, remainingAccounts);
+        if (this.isTransferHook(spotMarket)) {
+            await this.addExtraAccountMetasToRemainingAccounts(spotMarket.mint, remainingAccounts);
+        }
+        const tokenProgram = this.getTokenProgramForSpotMarket(spotMarket);
+        return await this.program.instruction.depositIntoSpotMarketVault(amount, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                sourceVault,
+                spotMarket: spotMarket.pubkey,
+                spotMarketVault: spotMarket.vault,
+                tokenProgram,
+            },
+            remainingAccounts,
+        });
+    }
+    async updateAdmin(admin) {
+        const updateAdminIx = await this.getUpdateAdminIx(admin);
+        const tx = await this.buildTransaction(updateAdminIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateAdminIx(admin) {
+        return await this.program.instruction.updateAdmin(admin, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updatePerpMarketCurveUpdateIntensity(perpMarketIndex, curveUpdateIntensity) {
+        const updatePerpMarketCurveUpdateIntensityIx = await this.getUpdatePerpMarketCurveUpdateIntensityIx(perpMarketIndex, curveUpdateIntensity);
+        const tx = await this.buildTransaction(updatePerpMarketCurveUpdateIntensityIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketCurveUpdateIntensityIx(perpMarketIndex, curveUpdateIntensity) {
+        return await this.program.instruction.updatePerpMarketCurveUpdateIntensity(curveUpdateIntensity, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketReferencePriceOffsetDeadbandPct(perpMarketIndex, referencePriceOffsetDeadbandPct) {
+        const updatePerpMarketReferencePriceOffsetDeadbandPctIx = await this.getUpdatePerpMarketReferencePriceOffsetDeadbandPctIx(perpMarketIndex, referencePriceOffsetDeadbandPct);
+        const tx = await this.buildTransaction(updatePerpMarketReferencePriceOffsetDeadbandPctIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketReferencePriceOffsetDeadbandPctIx(perpMarketIndex, referencePriceOffsetDeadbandPct) {
+        return await this.program.instruction.updatePerpMarketReferencePriceOffsetDeadbandPct(referencePriceOffsetDeadbandPct, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketTargetBaseAssetAmountPerLp(perpMarketIndex, targetBaseAssetAmountPerLP) {
+        const updatePerpMarketTargetBaseAssetAmountPerLpIx = await this.getUpdatePerpMarketTargetBaseAssetAmountPerLpIx(perpMarketIndex, targetBaseAssetAmountPerLP);
+        const tx = await this.buildTransaction(updatePerpMarketTargetBaseAssetAmountPerLpIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async updatePerpMarketAmmSummaryStats(perpMarketIndex, updateAmmSummaryStats, netUnsettledFundingPnl, excludeTotalLiqFee) {
+        const updatePerpMarketMarginRatioIx = await this.getUpdatePerpMarketAmmSummaryStatsIx(perpMarketIndex, updateAmmSummaryStats, netUnsettledFundingPnl, excludeTotalLiqFee);
+        const tx = await this.buildTransaction(updatePerpMarketMarginRatioIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketAmmSummaryStatsIx(perpMarketIndex, updateAmmSummaryStats, netUnsettledFundingPnl, excludeTotalLiqFee) {
+        return await this.program.instruction.updatePerpMarketAmmSummaryStats({
+            updateAmmSummaryStats: updateAmmSummaryStats !== null && updateAmmSummaryStats !== void 0 ? updateAmmSummaryStats : null,
+            netUnsettledFundingPnl: netUnsettledFundingPnl !== null && netUnsettledFundingPnl !== void 0 ? netUnsettledFundingPnl : null,
+            excludeTotalLiqFee: excludeTotalLiqFee !== null && excludeTotalLiqFee !== void 0 ? excludeTotalLiqFee : null,
+        }, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, numericConstants_1.QUOTE_SPOT_MARKET_INDEX),
+                oracle: this.getPerpMarketAccount(perpMarketIndex).amm.oracle,
+            },
+        });
+    }
+    async getUpdatePerpMarketTargetBaseAssetAmountPerLpIx(perpMarketIndex, targetBaseAssetAmountPerLP) {
+        return await this.program.instruction.updatePerpMarketTargetBaseAssetAmountPerLp(targetBaseAssetAmountPerLP, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketMarginRatio(perpMarketIndex, marginRatioInitial, marginRatioMaintenance) {
+        const updatePerpMarketMarginRatioIx = await this.getUpdatePerpMarketMarginRatioIx(perpMarketIndex, marginRatioInitial, marginRatioMaintenance);
+        const tx = await this.buildTransaction(updatePerpMarketMarginRatioIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketMarginRatioIx(perpMarketIndex, marginRatioInitial, marginRatioMaintenance) {
+        return await this.program.instruction.updatePerpMarketMarginRatio(marginRatioInitial, marginRatioMaintenance, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketImfFactor(perpMarketIndex, imfFactor, unrealizedPnlImfFactor) {
+        const updatePerpMarketImfFactorIx = await this.getUpdatePerpMarketImfFactorIx(perpMarketIndex, imfFactor, unrealizedPnlImfFactor);
+        const tx = await this.buildTransaction(updatePerpMarketImfFactorIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketImfFactorIx(perpMarketIndex, imfFactor, unrealizedPnlImfFactor) {
+        return await this.program.instruction.updatePerpMarketImfFactor(imfFactor, unrealizedPnlImfFactor, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketBaseSpread(perpMarketIndex, baseSpread) {
+        const updatePerpMarketBaseSpreadIx = await this.getUpdatePerpMarketBaseSpreadIx(perpMarketIndex, baseSpread);
+        const tx = await this.buildTransaction(updatePerpMarketBaseSpreadIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketBaseSpreadIx(perpMarketIndex, baseSpread) {
+        return await this.program.instruction.updatePerpMarketBaseSpread(baseSpread, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateAmmJitIntensity(perpMarketIndex, ammJitIntensity) {
+        const updateAmmJitIntensityIx = await this.getUpdateAmmJitIntensityIx(perpMarketIndex, ammJitIntensity);
+        const tx = await this.buildTransaction(updateAmmJitIntensityIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateAmmJitIntensityIx(perpMarketIndex, ammJitIntensity) {
+        return await this.program.instruction.updateAmmJitIntensity(ammJitIntensity, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketName(perpMarketIndex, name) {
+        const updatePerpMarketNameIx = await this.getUpdatePerpMarketNameIx(perpMarketIndex, name);
+        const tx = await this.buildTransaction(updatePerpMarketNameIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketNameIx(perpMarketIndex, name) {
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        return await this.program.instruction.updatePerpMarketName(nameBuffer, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketName(spotMarketIndex, name) {
+        const updateSpotMarketNameIx = await this.getUpdateSpotMarketNameIx(spotMarketIndex, name);
+        const tx = await this.buildTransaction(updateSpotMarketNameIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketNameIx(spotMarketIndex, name) {
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        return await this.program.instruction.updateSpotMarketName(nameBuffer, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketPoolId(spotMarketIndex, poolId) {
+        const updateSpotMarketPoolIdIx = await this.getUpdateSpotMarketPoolIdIx(spotMarketIndex, poolId);
+        const tx = await this.buildTransaction(updateSpotMarketPoolIdIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketPoolIdIx(spotMarketIndex, poolId) {
+        return await this.program.instruction.updateSpotMarketPoolId(poolId, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketMaxSpread(perpMarketIndex, maxSpread) {
+        const updatePerpMarketMaxSpreadIx = await this.getUpdatePerpMarketMaxSpreadIx(perpMarketIndex, maxSpread);
+        const tx = await this.buildTransaction(updatePerpMarketMaxSpreadIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketMaxSpreadIx(perpMarketIndex, maxSpread) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.instruction.updatePerpMarketMaxSpread(maxSpread, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    async updatePerpFeeStructure(feeStructure) {
+        const updatePerpFeeStructureIx = await this.getUpdatePerpFeeStructureIx(feeStructure);
+        const tx = await this.buildTransaction(updatePerpFeeStructureIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpFeeStructureIx(feeStructure) {
+        return this.program.instruction.updatePerpFeeStructure(feeStructure, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateSpotFeeStructure(feeStructure) {
+        const updateSpotFeeStructureIx = await this.getUpdateSpotFeeStructureIx(feeStructure);
+        const tx = await this.buildTransaction(updateSpotFeeStructureIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotFeeStructureIx(feeStructure) {
+        return await this.program.instruction.updateSpotFeeStructure(feeStructure, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateInitialPctToLiquidate(initialPctToLiquidate) {
+        const updateInitialPctToLiquidateIx = await this.getUpdateInitialPctToLiquidateIx(initialPctToLiquidate);
+        const tx = await this.buildTransaction(updateInitialPctToLiquidateIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateInitialPctToLiquidateIx(initialPctToLiquidate) {
+        return await this.program.instruction.updateInitialPctToLiquidate(initialPctToLiquidate, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateLiquidationDuration(liquidationDuration) {
+        const updateLiquidationDurationIx = await this.getUpdateLiquidationDurationIx(liquidationDuration);
+        const tx = await this.buildTransaction(updateLiquidationDurationIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateLiquidationDurationIx(liquidationDuration) {
+        return await this.program.instruction.updateLiquidationDuration(liquidationDuration, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateLiquidationMarginBufferRatio(updateLiquidationMarginBufferRatio) {
+        const updateLiquidationMarginBufferRatioIx = await this.getUpdateLiquidationMarginBufferRatioIx(updateLiquidationMarginBufferRatio);
+        const tx = await this.buildTransaction(updateLiquidationMarginBufferRatioIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateLiquidationMarginBufferRatioIx(updateLiquidationMarginBufferRatio) {
+        return await this.program.instruction.updateLiquidationMarginBufferRatio(updateLiquidationMarginBufferRatio, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateOracleGuardRails(oracleGuardRails) {
+        const updateOracleGuardRailsIx = await this.getUpdateOracleGuardRailsIx(oracleGuardRails);
+        const tx = await this.buildTransaction(updateOracleGuardRailsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateOracleGuardRailsIx(oracleGuardRails) {
+        return await this.program.instruction.updateOracleGuardRails(oracleGuardRails, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateStateSettlementDuration(settlementDuration) {
+        const updateStateSettlementDurationIx = await this.getUpdateStateSettlementDurationIx(settlementDuration);
+        const tx = await this.buildTransaction(updateStateSettlementDurationIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateStateSettlementDurationIx(settlementDuration) {
+        return await this.program.instruction.updateStateSettlementDuration(settlementDuration, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateStateMaxNumberOfSubAccounts(maxNumberOfSubAccounts) {
+        const updateStateMaxNumberOfSubAccountsIx = await this.getUpdateStateMaxNumberOfSubAccountsIx(maxNumberOfSubAccounts);
+        const tx = await this.buildTransaction(updateStateMaxNumberOfSubAccountsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateStateMaxNumberOfSubAccountsIx(maxNumberOfSubAccounts) {
+        return await this.program.instruction.updateStateMaxNumberOfSubAccounts(maxNumberOfSubAccounts, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateStateMaxInitializeUserFee(maxInitializeUserFee) {
+        const updateStateMaxInitializeUserFeeIx = await this.getUpdateStateMaxInitializeUserFeeIx(maxInitializeUserFee);
+        const tx = await this.buildTransaction(updateStateMaxInitializeUserFeeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateStateMaxInitializeUserFeeIx(maxInitializeUserFee) {
+        return await this.program.instruction.updateStateMaxInitializeUserFee(maxInitializeUserFee, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateWithdrawGuardThreshold(spotMarketIndex, withdrawGuardThreshold) {
+        const updateWithdrawGuardThresholdIx = await this.getUpdateWithdrawGuardThresholdIx(spotMarketIndex, withdrawGuardThreshold);
+        const tx = await this.buildTransaction(updateWithdrawGuardThresholdIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateWithdrawGuardThresholdIx(spotMarketIndex, withdrawGuardThreshold) {
+        return await this.program.instruction.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketIfFactor(spotMarketIndex, userIfFactor, totalIfFactor) {
+        const updateSpotMarketIfFactorIx = await this.getUpdateSpotMarketIfFactorIx(spotMarketIndex, userIfFactor, totalIfFactor);
+        const tx = await this.buildTransaction(updateSpotMarketIfFactorIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketIfFactorIx(spotMarketIndex, userIfFactor, totalIfFactor) {
+        return await this.program.instruction.updateSpotMarketIfFactor(spotMarketIndex, userIfFactor, totalIfFactor, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketRevenueSettlePeriod(spotMarketIndex, revenueSettlePeriod) {
+        const updateSpotMarketRevenueSettlePeriodIx = await this.getUpdateSpotMarketRevenueSettlePeriodIx(spotMarketIndex, revenueSettlePeriod);
+        const tx = await this.buildTransaction(updateSpotMarketRevenueSettlePeriodIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketRevenueSettlePeriodIx(spotMarketIndex, revenueSettlePeriod) {
+        return await this.program.instruction.updateSpotMarketRevenueSettlePeriod(revenueSettlePeriod, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketMaxTokenDeposits(spotMarketIndex, maxTokenDeposits) {
+        const updateSpotMarketMaxTokenDepositsIx = await this.getUpdateSpotMarketMaxTokenDepositsIx(spotMarketIndex, maxTokenDeposits);
+        const tx = await this.buildTransaction(updateSpotMarketMaxTokenDepositsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketMaxTokenDepositsIx(spotMarketIndex, maxTokenDeposits) {
+        return this.program.instruction.updateSpotMarketMaxTokenDeposits(maxTokenDeposits, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketMaxTokenBorrows(spotMarketIndex, maxTokenBorrowsFraction) {
+        const updateSpotMarketMaxTokenBorrowsIx = await this.getUpdateSpotMarketMaxTokenBorrowsIx(spotMarketIndex, maxTokenBorrowsFraction);
+        const tx = await this.buildTransaction(updateSpotMarketMaxTokenBorrowsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketMaxTokenBorrowsIx(spotMarketIndex, maxTokenBorrowsFraction) {
+        return this.program.instruction.updateSpotMarketMaxTokenBorrows(maxTokenBorrowsFraction, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketScaleInitialAssetWeightStart(spotMarketIndex, scaleInitialAssetWeightStart) {
+        const updateSpotMarketScaleInitialAssetWeightStartIx = await this.getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex, scaleInitialAssetWeightStart);
+        const tx = await this.buildTransaction(updateSpotMarketScaleInitialAssetWeightStartIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex, scaleInitialAssetWeightStart) {
+        return this.program.instruction.updateSpotMarketScaleInitialAssetWeightStart(scaleInitialAssetWeightStart, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateInsuranceFundUnstakingPeriod(spotMarketIndex, insuranceWithdrawEscrowPeriod) {
+        const updateInsuranceFundUnstakingPeriodIx = await this.getUpdateInsuranceFundUnstakingPeriodIx(spotMarketIndex, insuranceWithdrawEscrowPeriod);
+        const tx = await this.buildTransaction(updateInsuranceFundUnstakingPeriodIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateInsuranceFundUnstakingPeriodIx(spotMarketIndex, insuranceWithdrawEscrowPeriod) {
+        return await this.program.instruction.updateInsuranceFundUnstakingPeriod(insuranceWithdrawEscrowPeriod, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketOracle(perpMarketIndex, oracle, oracleSource, skipInvaraintCheck = false) {
+        const updatePerpMarketOracleIx = await this.getUpdatePerpMarketOracleIx(perpMarketIndex, oracle, oracleSource, skipInvaraintCheck);
+        const tx = await this.buildTransaction(updatePerpMarketOracleIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketOracleIx(perpMarketIndex, oracle, oracleSource, skipInvaraintCheck = false) {
+        return await this.program.instruction.updatePerpMarketOracle(oracle, oracleSource, skipInvaraintCheck, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                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),
+            },
+        });
+    }
+    async updatePerpMarketStepSizeAndTickSize(perpMarketIndex, stepSize, tickSize) {
+        const updatePerpMarketStepSizeAndTickSizeIx = await this.getUpdatePerpMarketStepSizeAndTickSizeIx(perpMarketIndex, stepSize, tickSize);
+        const tx = await this.buildTransaction(updatePerpMarketStepSizeAndTickSizeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketStepSizeAndTickSizeIx(perpMarketIndex, stepSize, tickSize) {
+        return await this.program.instruction.updatePerpMarketStepSizeAndTickSize(stepSize, tickSize, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketMinOrderSize(perpMarketIndex, orderSize) {
+        const updatePerpMarketMinOrderSizeIx = await this.getUpdatePerpMarketMinOrderSizeIx(perpMarketIndex, orderSize);
+        const tx = await this.buildTransaction(updatePerpMarketMinOrderSizeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketMinOrderSizeIx(perpMarketIndex, orderSize) {
+        return await this.program.instruction.updatePerpMarketMinOrderSize(orderSize, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketStepSizeAndTickSize(spotMarketIndex, stepSize, tickSize) {
+        const updateSpotMarketStepSizeAndTickSizeIx = await this.getUpdateSpotMarketStepSizeAndTickSizeIx(spotMarketIndex, stepSize, tickSize);
+        const tx = await this.buildTransaction(updateSpotMarketStepSizeAndTickSizeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketStepSizeAndTickSizeIx(spotMarketIndex, stepSize, tickSize) {
+        return await this.program.instruction.updateSpotMarketStepSizeAndTickSize(stepSize, tickSize, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketMinOrderSize(spotMarketIndex, orderSize) {
+        const updateSpotMarketMinOrderSizeIx = await this.program.instruction.updateSpotMarketMinOrderSize(orderSize, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+        const tx = await this.buildTransaction(updateSpotMarketMinOrderSizeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketMinOrderSizeIx(spotMarketIndex, orderSize) {
+        return await this.program.instruction.updateSpotMarketMinOrderSize(orderSize, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketExpiry(perpMarketIndex, expiryTs) {
+        const updatePerpMarketExpiryIx = await this.getUpdatePerpMarketExpiryIx(perpMarketIndex, expiryTs);
+        const tx = await this.buildTransaction(updatePerpMarketExpiryIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketExpiryIx(perpMarketIndex, expiryTs) {
+        return await this.program.instruction.updatePerpMarketExpiry(expiryTs, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketOracle(spotMarketIndex, oracle, oracleSource, skipInvaraintCheck = false) {
+        const updateSpotMarketOracleIx = await this.getUpdateSpotMarketOracleIx(spotMarketIndex, oracle, oracleSource, skipInvaraintCheck);
+        const tx = await this.buildTransaction(updateSpotMarketOracleIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketOracleIx(spotMarketIndex, oracle, oracleSource, skipInvaraintCheck = false) {
+        return await this.program.instruction.updateSpotMarketOracle(oracle, oracleSource, skipInvaraintCheck, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+                oracle: oracle,
+                oldOracle: this.getSpotMarketAccount(spotMarketIndex).oracle,
+            },
+        });
+    }
+    async updateSpotMarketOrdersEnabled(spotMarketIndex, ordersEnabled) {
+        const updateSpotMarketOrdersEnabledIx = await this.getUpdateSpotMarketOrdersEnabledIx(spotMarketIndex, ordersEnabled);
+        const tx = await this.buildTransaction(updateSpotMarketOrdersEnabledIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketOrdersEnabledIx(spotMarketIndex, ordersEnabled) {
+        return await this.program.instruction.updateSpotMarketOrdersEnabled(ordersEnabled, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketIfPausedOperations(spotMarketIndex, pausedOperations) {
+        const updateSpotMarketIfStakingDisabledIx = await this.getUpdateSpotMarketIfPausedOperationsIx(spotMarketIndex, pausedOperations);
+        const tx = await this.buildTransaction(updateSpotMarketIfStakingDisabledIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketIfPausedOperationsIx(spotMarketIndex, pausedOperations) {
+        return await this.program.instruction.updateSpotMarketIfPausedOperations(pausedOperations, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketExpiry(spotMarketIndex, expiryTs) {
+        const updateSpotMarketExpiryIx = await this.getUpdateSpotMarketExpiryIx(spotMarketIndex, expiryTs);
+        const tx = await this.buildTransaction(updateSpotMarketExpiryIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketExpiryIx(spotMarketIndex, expiryTs) {
+        return await this.program.instruction.updateSpotMarketExpiry(expiryTs, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateWhitelistMint(whitelistMint) {
+        const updateWhitelistMintIx = await this.getUpdateWhitelistMintIx(whitelistMint);
+        const tx = await this.buildTransaction(updateWhitelistMintIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateWhitelistMintIx(whitelistMint) {
+        return await this.program.instruction.updateWhitelistMint(whitelistMint, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateDiscountMint(discountMint) {
+        const updateDiscountMintIx = await this.getUpdateDiscountMintIx(discountMint);
+        const tx = await this.buildTransaction(updateDiscountMintIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateDiscountMintIx(discountMint) {
+        return await this.program.instruction.updateDiscountMint(discountMint, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateSpotMarketMarginWeights(spotMarketIndex, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0) {
+        const updateSpotMarketMarginWeightsIx = await this.getUpdateSpotMarketMarginWeightsIx(spotMarketIndex, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor);
+        const tx = await this.buildTransaction(updateSpotMarketMarginWeightsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketMarginWeightsIx(spotMarketIndex, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0) {
+        return await this.program.instruction.updateSpotMarketMarginWeights(initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketBorrowRate(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate) {
+        const updateSpotMarketBorrowRateIx = await this.getUpdateSpotMarketBorrowRateIx(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate);
+        const tx = await this.buildTransaction(updateSpotMarketBorrowRateIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketBorrowRateIx(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate) {
+        return await this.program.instruction.updateSpotMarketBorrowRate(optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketAssetTier(spotMarketIndex, assetTier) {
+        const updateSpotMarketAssetTierIx = await this.getUpdateSpotMarketAssetTierIx(spotMarketIndex, assetTier);
+        const tx = await this.buildTransaction(updateSpotMarketAssetTierIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketAssetTierIx(spotMarketIndex, assetTier) {
+        return await this.program.instruction.updateSpotMarketAssetTier(assetTier, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketStatus(spotMarketIndex, marketStatus) {
+        const updateSpotMarketStatusIx = await this.getUpdateSpotMarketStatusIx(spotMarketIndex, marketStatus);
+        const tx = await this.buildTransaction(updateSpotMarketStatusIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketStatusIx(spotMarketIndex, marketStatus) {
+        return await this.program.instruction.updateSpotMarketStatus(marketStatus, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketPausedOperations(spotMarketIndex, pausedOperations) {
+        const updateSpotMarketPausedOperationsIx = await this.getUpdateSpotMarketPausedOperationsIx(spotMarketIndex, pausedOperations);
+        const tx = await this.buildTransaction(updateSpotMarketPausedOperationsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketPausedOperationsIx(spotMarketIndex, pausedOperations) {
+        return await this.program.instruction.updateSpotMarketPausedOperations(pausedOperations, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketStatus(perpMarketIndex, marketStatus) {
+        const updatePerpMarketStatusIx = await this.getUpdatePerpMarketStatusIx(perpMarketIndex, marketStatus);
+        const tx = await this.buildTransaction(updatePerpMarketStatusIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketStatusIx(perpMarketIndex, marketStatus) {
+        return await this.program.instruction.updatePerpMarketStatus(marketStatus, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketPausedOperations(perpMarketIndex, pausedOperations) {
+        const updatePerpMarketPausedOperationsIx = await this.getUpdatePerpMarketPausedOperationsIx(perpMarketIndex, pausedOperations);
+        const tx = await this.buildTransaction(updatePerpMarketPausedOperationsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketPausedOperationsIx(perpMarketIndex, pausedOperations) {
+        return await this.program.instruction.updatePerpMarketPausedOperations(pausedOperations, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketContractTier(perpMarketIndex, contractTier) {
+        const updatePerpMarketContractTierIx = await this.getUpdatePerpMarketContractTierIx(perpMarketIndex, contractTier);
+        const tx = await this.buildTransaction(updatePerpMarketContractTierIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketContractTierIx(perpMarketIndex, contractTier) {
+        return await this.program.instruction.updatePerpMarketContractTier(contractTier, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : 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),
+            },
+        });
+    }
+    async updateExchangeStatus(exchangeStatus) {
+        const updateExchangeStatusIx = await this.getUpdateExchangeStatusIx(exchangeStatus);
+        const tx = await this.buildTransaction(updateExchangeStatusIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateExchangeStatusIx(exchangeStatus) {
+        return await this.program.instruction.updateExchangeStatus(exchangeStatus, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updatePerpAuctionDuration(minDuration) {
+        const updatePerpAuctionDurationIx = await this.getUpdatePerpAuctionDurationIx(minDuration);
+        const tx = await this.buildTransaction(updatePerpAuctionDurationIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpAuctionDurationIx(minDuration) {
+        return await this.program.instruction.updatePerpAuctionDuration(typeof minDuration === 'number' ? minDuration : minDuration.toNumber(), {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateSpotAuctionDuration(defaultAuctionDuration) {
+        const updateSpotAuctionDurationIx = await this.getUpdateSpotAuctionDurationIx(defaultAuctionDuration);
+        const tx = await this.buildTransaction(updateSpotAuctionDurationIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotAuctionDurationIx(defaultAuctionDuration) {
+        return await this.program.instruction.updateSpotAuctionDuration(defaultAuctionDuration, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updatePerpMarketMaxFillReserveFraction(perpMarketIndex, maxBaseAssetAmountRatio) {
+        const updatePerpMarketMaxFillReserveFractionIx = await this.getUpdatePerpMarketMaxFillReserveFractionIx(perpMarketIndex, maxBaseAssetAmountRatio);
+        const tx = await this.buildTransaction(updatePerpMarketMaxFillReserveFractionIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketMaxFillReserveFractionIx(perpMarketIndex, maxBaseAssetAmountRatio) {
+        return await this.program.instruction.updatePerpMarketMaxFillReserveFraction(maxBaseAssetAmountRatio, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateMaxSlippageRatio(perpMarketIndex, maxSlippageRatio) {
+        const updateMaxSlippageRatioIx = await this.getUpdateMaxSlippageRatioIx(perpMarketIndex, maxSlippageRatio);
+        const tx = await this.buildTransaction(updateMaxSlippageRatioIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateMaxSlippageRatioIx(perpMarketIndex, maxSlippageRatio) {
+        return await this.program.instruction.updateMaxSlippageRatio(maxSlippageRatio, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: this.getPerpMarketAccount(perpMarketIndex).pubkey,
+            },
+        });
+    }
+    async updatePerpMarketUnrealizedAssetWeight(perpMarketIndex, unrealizedInitialAssetWeight, unrealizedMaintenanceAssetWeight) {
+        const updatePerpMarketUnrealizedAssetWeightIx = await this.getUpdatePerpMarketUnrealizedAssetWeightIx(perpMarketIndex, unrealizedInitialAssetWeight, unrealizedMaintenanceAssetWeight);
+        const tx = await this.buildTransaction(updatePerpMarketUnrealizedAssetWeightIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketUnrealizedAssetWeightIx(perpMarketIndex, unrealizedInitialAssetWeight, unrealizedMaintenanceAssetWeight) {
+        return await this.program.instruction.updatePerpMarketUnrealizedAssetWeight(unrealizedInitialAssetWeight, unrealizedMaintenanceAssetWeight, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketMaxImbalances(perpMarketIndex, unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance) {
+        const updatePerpMarketMaxImabalancesIx = await this.getUpdatePerpMarketMaxImbalancesIx(perpMarketIndex, unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance);
+        const tx = await this.buildTransaction(updatePerpMarketMaxImabalancesIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketMaxImbalancesIx(perpMarketIndex, unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance) {
+        return await this.program.instruction.updatePerpMarketMaxImbalances(unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketMaxOpenInterest(perpMarketIndex, maxOpenInterest) {
+        const updatePerpMarketMaxOpenInterestIx = await this.getUpdatePerpMarketMaxOpenInterestIx(perpMarketIndex, maxOpenInterest);
+        const tx = await this.buildTransaction(updatePerpMarketMaxOpenInterestIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketMaxOpenInterestIx(perpMarketIndex, maxOpenInterest) {
+        return await this.program.instruction.updatePerpMarketMaxOpenInterest(maxOpenInterest, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketNumberOfUser(perpMarketIndex, numberOfUsers, numberOfUsersWithBase) {
+        const updatepPerpMarketFeeAdjustmentIx = await this.getUpdatePerpMarketNumberOfUsersIx(perpMarketIndex, numberOfUsers, numberOfUsersWithBase);
+        const tx = await this.buildTransaction(updatepPerpMarketFeeAdjustmentIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketNumberOfUsersIx(perpMarketIndex, numberOfUsers, numberOfUsersWithBase) {
+        return await this.program.instruction.updatePerpMarketNumberOfUsers(numberOfUsers, numberOfUsersWithBase, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketFeeAdjustment(perpMarketIndex, feeAdjustment) {
+        const updatepPerpMarketFeeAdjustmentIx = await this.getUpdatePerpMarketFeeAdjustmentIx(perpMarketIndex, feeAdjustment);
+        const tx = await this.buildTransaction(updatepPerpMarketFeeAdjustmentIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketFeeAdjustmentIx(perpMarketIndex, feeAdjustment) {
+        return await this.program.instruction.updatePerpMarketFeeAdjustment(feeAdjustment, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketFeeAdjustment(perpMarketIndex, feeAdjustment) {
+        const updateSpotMarketFeeAdjustmentIx = await this.getUpdateSpotMarketFeeAdjustmentIx(perpMarketIndex, feeAdjustment);
+        const tx = await this.buildTransaction(updateSpotMarketFeeAdjustmentIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketFeeAdjustmentIx(spotMarketIndex, feeAdjustment) {
+        return await this.program.instruction.updateSpotMarketFeeAdjustment(feeAdjustment, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketLiquidationFee(perpMarketIndex, liquidatorFee, ifLiquidationFee) {
+        const updatePerpMarketLiquidationFeeIx = await this.getUpdatePerpMarketLiquidationFeeIx(perpMarketIndex, liquidatorFee, ifLiquidationFee);
+        const tx = await this.buildTransaction(updatePerpMarketLiquidationFeeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketLiquidationFeeIx(perpMarketIndex, liquidatorFee, ifLiquidationFee) {
+        return await this.program.instruction.updatePerpMarketLiquidationFee(liquidatorFee, ifLiquidationFee, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketLiquidationFee(spotMarketIndex, liquidatorFee, ifLiquidationFee) {
+        const updateSpotMarketLiquidationFeeIx = await this.getUpdateSpotMarketLiquidationFeeIx(spotMarketIndex, liquidatorFee, ifLiquidationFee);
+        const tx = await this.buildTransaction(updateSpotMarketLiquidationFeeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketLiquidationFeeIx(spotMarketIndex, liquidatorFee, ifLiquidationFee) {
+        return await this.program.instruction.updateSpotMarketLiquidationFee(liquidatorFee, ifLiquidationFee, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async initializeProtocolIfSharesTransferConfig() {
+        const initializeProtocolIfSharesTransferConfigIx = await this.getInitializeProtocolIfSharesTransferConfigIx();
+        const tx = await this.buildTransaction(initializeProtocolIfSharesTransferConfigIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getInitializeProtocolIfSharesTransferConfigIx() {
+        return await this.program.instruction.initializeProtocolIfSharesTransferConfig({
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                protocolIfSharesTransferConfig: (0, pda_1.getProtocolIfSharesTransferConfigPublicKey)(this.program.programId),
+            },
+        });
+    }
+    async updateProtocolIfSharesTransferConfig(whitelistedSigners, maxTransferPerEpoch) {
+        const updateProtocolIfSharesTransferConfigIx = await this.getUpdateProtocolIfSharesTransferConfigIx(whitelistedSigners, maxTransferPerEpoch);
+        const tx = await this.buildTransaction(updateProtocolIfSharesTransferConfigIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateProtocolIfSharesTransferConfigIx(whitelistedSigners, maxTransferPerEpoch) {
+        return await this.program.instruction.updateProtocolIfSharesTransferConfig(whitelistedSigners || null, maxTransferPerEpoch, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                protocolIfSharesTransferConfig: (0, pda_1.getProtocolIfSharesTransferConfigPublicKey)(this.program.programId),
+            },
+        });
+    }
+    async transferProtocolIfSharesToRevenuePool(outMarketIndex, inMarketIndex, amount) {
+        const transferProtocolIfSharesToRevenuePoolIx = await this.getTransferProtocolIfSharesToRevenuePoolIx(outMarketIndex, inMarketIndex, amount);
+        const tx = await this.buildTransaction(transferProtocolIfSharesToRevenuePoolIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getTransferProtocolIfSharesToRevenuePoolIx(outMarketIndex, inMarketIndex, amount) {
+        const remainingAccounts = await this.getRemainingAccounts({
+            userAccounts: [],
+            writableSpotMarketIndexes: [outMarketIndex],
+        });
+        return await this.program.instruction.transferProtocolIfSharesToRevenuePool(outMarketIndex, amount, {
+            accounts: {
+                authority: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                insuranceFundVault: await (0, pda_1.getInsuranceFundVaultPublicKey)(this.program.programId, outMarketIndex),
+                spotMarketVault: await (0, pda_1.getSpotMarketVaultPublicKey)(this.program.programId, outMarketIndex),
+                ifRebalanceConfig: await (0, pda_1.getIfRebalanceConfigPublicKey)(this.program.programId, inMarketIndex, outMarketIndex),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                driftSigner: this.getStateAccount().signer,
+            },
+            remainingAccounts,
+        });
+    }
+    async adminWithdrawFromInsuranceFundVault(marketIndex, amount, recipientTokenAccount, txParams) {
+        const ix = await this.getAdminWithdrawFromInsuranceFundVaultIx(marketIndex, amount, recipientTokenAccount);
+        const tx = await this.buildTransaction(ix, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getAdminWithdrawFromInsuranceFundVaultIx(marketIndex, amount, recipientTokenAccount) {
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        const tokenProgramId = this.getTokenProgramForSpotMarket(spotMarket);
+        const remainingAccounts = [];
+        this.addTokenMintToRemainingAccounts(spotMarket, remainingAccounts);
+        if (this.isTransferHook(spotMarket)) {
+            await this.addExtraAccountMetasToRemainingAccounts(spotMarket.mint, remainingAccounts);
+        }
+        return await this.program.instruction.adminWithdrawFromInsuranceFundVault(marketIndex, amount, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                spotMarket: spotMarket.pubkey,
+                insuranceFundVault: spotMarket.insuranceFund.vault,
+                recipientTokenAccount,
+                tokenProgram: tokenProgramId,
+                driftSigner: this.getSignerPublicKey(),
+            },
+            remainingAccounts,
+        });
+    }
+    async initializePrelaunchOracle(perpMarketIndex, price, maxPrice) {
+        const initializePrelaunchOracleIx = await this.getInitializePrelaunchOracleIx(perpMarketIndex, price, maxPrice);
+        const tx = await this.buildTransaction(initializePrelaunchOracleIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getInitializePrelaunchOracleIx(perpMarketIndex, price, maxPrice) {
+        const params = {
+            perpMarketIndex,
+            price: price || null,
+            maxPrice: maxPrice || null,
+        };
+        return await this.program.instruction.initializePrelaunchOracle(params, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                prelaunchOracle: await (0, pda_1.getPrelaunchOraclePublicKey)(this.program.programId, perpMarketIndex),
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+    }
+    async updatePrelaunchOracleParams(perpMarketIndex, price, maxPrice) {
+        const updatePrelaunchOracleParamsIx = await this.getUpdatePrelaunchOracleParamsIx(perpMarketIndex, price, maxPrice);
+        const tx = await this.buildTransaction(updatePrelaunchOracleParamsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePrelaunchOracleParamsIx(perpMarketIndex, price, maxPrice) {
+        const params = {
+            perpMarketIndex,
+            price: price || null,
+            maxPrice: maxPrice || null,
+        };
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.instruction.updatePrelaunchOracleParams(params, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: perpMarketPublicKey,
+                prelaunchOracle: await (0, pda_1.getPrelaunchOraclePublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async deletePrelaunchOracle(perpMarketIndex) {
+        const deletePrelaunchOracleIx = await this.getDeletePrelaunchOracleIx(perpMarketIndex);
+        const tx = await this.buildTransaction(deletePrelaunchOracleIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getDeletePrelaunchOracleIx(perpMarketIndex, price, maxPrice) {
+        const params = {
+            perpMarketIndex,
+            price: price || null,
+            maxPrice: maxPrice || null,
+        };
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.instruction.deletePrelaunchOracle(params, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: perpMarketPublicKey,
+                prelaunchOracle: await (0, pda_1.getPrelaunchOraclePublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketOracleLowRiskSlotDelayOverride(perpMarketIndex, oracleLowRiskSlotDelayOverride) {
+        const updatePerpMarketOracleLowRiskSlotDelayOverrideIx = await this.getUpdatePerpMarketOracleLowRiskSlotDelayOverrideIx(perpMarketIndex, oracleLowRiskSlotDelayOverride);
+        const tx = await this.buildTransaction(updatePerpMarketOracleLowRiskSlotDelayOverrideIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketOracleLowRiskSlotDelayOverrideIx(perpMarketIndex, oracleLowRiskSlotDelayOverride) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.instruction.updatePerpMarketOracleLowRiskSlotDelayOverride(oracleLowRiskSlotDelayOverride, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    async updatePerpMarketOracleSlotDelayOverride(perpMarketIndex, oracleSlotDelay) {
+        const updatePerpMarketOracleSlotDelayOverrideIx = await this.getUpdatePerpMarketOracleSlotDelayOverrideIx(perpMarketIndex, oracleSlotDelay);
+        const tx = await this.buildTransaction(updatePerpMarketOracleSlotDelayOverrideIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketOracleSlotDelayOverrideIx(perpMarketIndex, oracleSlotDelay) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.instruction.updatePerpMarketOracleSlotDelayOverride(oracleSlotDelay, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    async updatePerpMarketAmmSpreadAdjustment(perpMarketIndex, ammSpreadAdjustment, ammInventorySpreadAdjustment, referencePriceOffset) {
+        const updatePerpMarketAmmSpreadAdjustmentIx = await this.getUpdatePerpMarketAmmSpreadAdjustmentIx(perpMarketIndex, ammSpreadAdjustment, ammInventorySpreadAdjustment, referencePriceOffset);
+        const tx = await this.buildTransaction(updatePerpMarketAmmSpreadAdjustmentIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketAmmSpreadAdjustmentIx(perpMarketIndex, ammSpreadAdjustment, ammInventorySpreadAdjustment, referencePriceOffset) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.instruction.updatePerpMarketAmmSpreadAdjustment(ammSpreadAdjustment, ammInventorySpreadAdjustment, referencePriceOffset, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    async initializeIfRebalanceConfig(params) {
+        const initializeIfRebalanceConfigIx = await this.getInitializeIfRebalanceConfigIx(params);
+        const tx = await this.buildTransaction(initializeIfRebalanceConfigIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getInitializeIfRebalanceConfigIx(params) {
+        return await this.program.instruction.initializeIfRebalanceConfig(params, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                ifRebalanceConfig: await (0, pda_1.getIfRebalanceConfigPublicKey)(this.program.programId, params.inMarketIndex, params.outMarketIndex),
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+    }
+    async initializePythLazerOracle(feedId) {
+        const initializePythLazerOracleIx = await this.getInitializePythLazerOracleIx(feedId);
+        const tx = await this.buildTransaction(initializePythLazerOracleIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getInitializePythLazerOracleIx(feedId) {
+        return await this.program.instruction.initializePythLazerOracle(feedId, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                systemProgram: web3_js_1.SystemProgram.programId,
+                lazerOracle: (0, pda_1.getPythLazerOraclePublicKey)(this.program.programId, feedId),
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+            },
+        });
+    }
+    async adminDeposit(marketIndex, amount, depositUserAccount, adminTokenAccount) {
+        const ix = await this.getAdminDepositIx(marketIndex, amount, depositUserAccount, adminTokenAccount);
+        const tx = await this.buildTransaction(ix);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getAdminDepositIx(marketIndex, amount, depositUserAccount, adminTokenAccount) {
+        const state = await this.getStatePublicKey();
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [],
+            writableSpotMarketIndexes: [marketIndex],
+        });
+        this.addTokenMintToRemainingAccounts(spotMarket, remainingAccounts);
+        if (this.isTransferHook(spotMarket)) {
+            await this.addExtraAccountMetasToRemainingAccounts(spotMarket.mint, remainingAccounts);
+        }
+        return this.program.instruction.adminDeposit(marketIndex, amount, {
+            remainingAccounts,
+            accounts: {
+                state,
+                user: depositUserAccount,
+                admin: this.wallet.publicKey,
+                spotMarketVault: spotMarket.vault,
+                adminTokenAccount: adminTokenAccount !== null && adminTokenAccount !== void 0 ? adminTokenAccount : (await this.getAssociatedTokenAccount(marketIndex)),
+                tokenProgram: (0, pda_1.getTokenProgramForSpotMarket)(spotMarket),
+            },
+        });
+    }
+    async zeroMMOracleFields(marketIndex) {
+        const zeroMMOracleFieldsIx = await this.getZeroMMOracleFieldsIx(marketIndex);
+        const tx = await this.buildTransaction(zeroMMOracleFieldsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getZeroMMOracleFieldsIx(marketIndex) {
+        return await this.program.instruction.zeroMmOracleFields({
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateFeatureBitFlagsMMOracle(enable) {
+        const updateFeatureBitFlagsMMOracleIx = await this.getUpdateFeatureBitFlagsMMOracleIx(enable);
+        const tx = await this.buildTransaction(updateFeatureBitFlagsMMOracleIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateFeatureBitFlagsMMOracleIx(enable) {
+        return await this.program.instruction.updateFeatureBitFlagsMmOracle(enable, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    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().coldAdmin,
+                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().coldAdmin,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateFeatureBitFlagsMedianTriggerPrice(enable) {
+        const updateFeatureBitFlagsMedianTriggerPriceIx = await this.getUpdateFeatureBitFlagsMedianTriggerPriceIx(enable);
+        const tx = await this.buildTransaction(updateFeatureBitFlagsMedianTriggerPriceIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateFeatureBitFlagsMedianTriggerPriceIx(enable) {
+        return await this.program.instruction.updateFeatureBitFlagsMedianTriggerPrice(enable, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateDelegateUserGovTokenInsuranceStake(authority, delegate) {
+        const updateDelegateUserGovTokenInsuranceStakeIx = await this.getUpdateDelegateUserGovTokenInsuranceStakeIx(authority, delegate);
+        const tx = await this.buildTransaction(updateDelegateUserGovTokenInsuranceStakeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateDelegateUserGovTokenInsuranceStakeIx(authority, delegate) {
+        const marketIndex = numericConstants_1.GOV_SPOT_MARKET_INDEX;
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, delegate, marketIndex);
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, authority);
+        const ix = this.program.instruction.getUpdateDelegateUserGovTokenInsuranceStakeIx({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                spotMarket: spotMarket.pubkey,
+                insuranceFundStake: ifStakeAccountPublicKey,
+                userStats: userStatsPublicKey,
+                signer: this.wallet.publicKey,
+                insuranceFundVault: spotMarket.insuranceFund.vault,
+            },
+        });
+        return ix;
+    }
+    async depositIntoInsuranceFundStake(marketIndex, amount, userStatsPublicKey, insuranceFundStakePublicKey, userTokenAccountPublicKey, txParams) {
+        const tx = await this.buildTransaction(await this.getDepositIntoInsuranceFundStakeIx(marketIndex, amount, userStatsPublicKey, insuranceFundStakePublicKey, userTokenAccountPublicKey), txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getDepositIntoInsuranceFundStakeIx(marketIndex, amount, userStatsPublicKey, insuranceFundStakePublicKey, userTokenAccountPublicKey) {
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        return await this.program.instruction.depositIntoInsuranceFundStake(marketIndex, amount, {
+            accounts: {
+                signer: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: spotMarket.pubkey,
+                insuranceFundStake: insuranceFundStakePublicKey,
+                userStats: userStatsPublicKey,
+                spotMarketVault: spotMarket.vault,
+                insuranceFundVault: spotMarket.insuranceFund.vault,
+                userTokenAccount: userTokenAccountPublicKey,
+                tokenProgram: this.getTokenProgramForSpotMarket(spotMarket),
+                driftSigner: this.getSignerPublicKey(),
+            },
+        });
+    }
+    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 getUpdateFeatureBitFlagsSettleLpPoolIx(enable) {
+        return await this.program.instruction.updateFeatureBitFlagsSettleLpPool(enable, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    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 getUpdateFeatureBitFlagsSwapLpPoolIx(enable) {
+        return await this.program.instruction.updateFeatureBitFlagsSwapLpPool(enable, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                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
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async adminUpdateUserStatsPausedOperations(authority, pausedOperations) {
+        const updateUserStatsPausedOperationsIx = await this.getAdminUpdateUserStatsPausedOperationsIx(authority, pausedOperations);
+        const tx = await this.buildTransaction(updateUserStatsPausedOperationsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getAdminUpdateUserStatsPausedOperationsIx(authority, pausedOperations) {
+        return await this.program.instruction.adminUpdateUserStatsPausedOperations(pausedOperations, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                userStats: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, authority),
+            },
+        });
+    }
+    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().coldAdmin
+                    : 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.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                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 swap 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,
+        }, true);
+        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.getVelocitySignerPublicKey)(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.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                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.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                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;
+    }
+    async updatePerpMarketConfig(marketIndex, marketConfig) {
+        const ix = await this.getUpdatePerpMarketConfigIx(marketIndex, marketConfig);
+        const tx = await this.buildTransaction(ix);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdatePerpMarketConfigIx(marketIndex, marketConfig) {
+        return this.program.instruction.updatePerpMarketConfig(marketConfig, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                perpMarket: this.getPerpMarketAccount(marketIndex).pubkey,
+            },
+        });
+    }
+    async transferFeeAndPnlPool(perpMarketIndexWithFeePool, perpMarketIndexWithPnlPool, amount, direction) {
+        const transferFeeAndPnlPoolIx = await this.getTransferFeeAndPnlPoolIx(perpMarketIndexWithFeePool, perpMarketIndexWithPnlPool, amount, direction);
+        const tx = await this.buildTransaction(transferFeeAndPnlPoolIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getTransferFeeAndPnlPoolIx(perpMarketIndexWithFeePool, perpMarketIndexWithPnlPool, amount, direction) {
+        return await this.program.instruction.transferFeeAndPnlPool(amount, direction, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarketWithFeePool: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndexWithFeePool),
+                perpMarketWithPnlPool: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndexWithPnlPool),
+                spotMarket: this.getQuoteSpotMarketAccount().pubkey,
+                spotMarketVault: this.getQuoteSpotMarketAccount().vault,
+            },
+        });
+    }
+    async updateSpecialUserStatus(userAccountPublicKey, status, txParams) {
+        const ix = await this.getUpdateSpecialUserStatusIx(userAccountPublicKey, status);
+        const tx = await this.buildTransaction(ix, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpecialUserStatusIx(userAccountPublicKey, status) {
+        return this.program.instruction.updateSpecialUserStatus(status, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().coldAdmin,
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+            },
+        });
+    }
+    // ----- Tiered admin authority -----
+    //
+    // `state.coldAdmin` is the root. `state.warmAdmin` is rotated by cold; each
+    // `state.hot*` field is rotated by warm (or cold). COLD ⊇ WARM ⊇ HOT(role).
+    // `handleInitialize` seeds `coldAdmin = warmAdmin = signer`; there is no
+    // separate "initialize admin authority config" ix.
+    async updateWarmAdmin(newWarmAdmin) {
+        const ix = await this.getUpdateWarmAdminIx(newWarmAdmin);
+        const tx = await this.buildTransaction(ix);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateWarmAdminIx(newWarmAdmin) {
+        return this.program.instruction.updateWarmAdmin(newWarmAdmin, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.isSubscribed
+                    ? this.getStateAccount().coldAdmin
+                    : this.wallet.publicKey,
+            },
+        });
+    }
+    async updateHotAdmin(role, newPubkey) {
+        const ix = await this.getUpdateHotAdminIx(role, newPubkey);
+        const tx = await this.buildTransaction(ix);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateHotAdminIx(role, newPubkey) {
+        return this.program.instruction.updateHotAdmin(encodeHotRole(role), newPubkey, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+            },
+        });
+    }
+}
+exports.AdminClient = AdminClient;
+/**
+ * Hot-admin role identifier. Each role is a separate purpose-specific signer key
+ * stored on the `AdminAuthorityConfig` PDA. Compromise of one role's key only
+ * enables that role's instructions.
+ */
+var HotRole;
+(function (HotRole) {
+    HotRole["AmmCrank"] = "ammCrank";
+    HotRole["LpCache"] = "lpCache";
+    HotRole["LpSwap"] = "lpSwap";
+    HotRole["LpSettle"] = "lpSettle";
+    HotRole["IfRebalance"] = "ifRebalance";
+    HotRole["FeatureFlag"] = "featureFlag";
+    HotRole["Fuel"] = "fuel";
+    HotRole["UserFlag"] = "userFlag";
+    HotRole["VaultDeposit"] = "vaultDeposit";
+    HotRole["MmOracleCrank"] = "mmOracleCrank";
+    HotRole["AmmSpreadAdjust"] = "ammSpreadAdjust";
+})(HotRole || (exports.HotRole = HotRole = {}));
+/** Anchor encodes Rust enums as `{ <variant>: {} }`. */
+function encodeHotRole(role) {
+    return { [role]: {} };
+}