@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.31

package/lib/admin.js

@@ -29,28 +29,26 @@ const types_1 = require("./types");
 const anchor_1 = require("@project-serum/anchor");
 const anchor = __importStar(require("@project-serum/anchor"));
 const pda_1 = require("./addresses/pda");
+const utils_1 = require("./math/utils");
 const spl_token_1 = require("@solana/spl-token");
 const clearingHouse_1 = require("./clearingHouse");
 const numericConstants_1 = require("./constants/numericConstants");
 const trade_1 = require("./math/trade");
 const amm_1 = require("./math/amm");
 class Admin extends clearingHouse_1.ClearingHouse {
-    async initialize(usdcMint, adminControlsPrices) {
+    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 [insuranceVaultPublicKey] = await web3_js_1.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('insurance_vault'))], this.program.programId);
-        const [insuranceVaultAuthority] = await web3_js_1.PublicKey.findProgramAddress([insuranceVaultPublicKey.toBuffer()], this.program.programId);
         const [clearingHouseStatePublicKey] = await (0, pda_1.getClearingHouseStateAccountPublicKeyAndNonce)(this.program.programId);
-        const initializeTx = await this.program.transaction.initialize(adminControlsPrices, {
+        const initializeTx = await this.program.transaction.initialize({
             accounts: {
                 admin: this.wallet.publicKey,
                 state: clearingHouseStatePublicKey,
                 quoteAssetMint: usdcMint,
-                insuranceVault: insuranceVaultPublicKey,
-                insuranceVaultAuthority: insuranceVaultAuthority,
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                clearingHouseSigner: this.getSignerPublicKey(),
                 systemProgram: anchor.web3.SystemProgram.programId,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
@@ -58,19 +56,20 @@ class Admin extends clearingHouse_1.ClearingHouse {
         const { txSig: initializeTxSig } = await this.txSender.send(initializeTx, [], this.opts);
         return [initializeTxSig];
     }
-    async initializeBank(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight) {
-        const bankIndex = this.getStateAccount().numberOfBanks;
-        const bank = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
-        const bankVault = await (0, pda_1.getBankVaultPublicKey)(this.program.programId, bankIndex);
-        const bankVaultAuthority = await (0, pda_1.getBankVaultAuthorityPublicKey)(this.program.programId, bankIndex);
-        const initializeTx = await this.program.transaction.initializeBank(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, {
+    async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0), liquidationFee = numericConstants_1.ZERO, activeStatus = true) {
+        const spotMarketIndex = 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 initializeTx = await this.program.transaction.initializeSpotMarket(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidationFee, activeStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                bank,
-                bankVault,
-                bankVaultAuthority,
-                bankMint: mint,
+                spotMarket,
+                spotMarketVault,
+                insuranceFundVault,
+                clearingHouseSigner: this.getSignerPublicKey(),
+                spotMarketMint: mint,
                 oracle,
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
                 systemProgram: anchor.web3.SystemProgram.programId,
@@ -78,16 +77,35 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
         const { txSig } = await this.txSender.send(initializeTx, [], this.opts);
-        await this.accountSubscriber.addBank(bankIndex);
+        await this.accountSubscriber.addSpotMarket(spotMarketIndex);
         await this.accountSubscriber.addOracle({
             source: oracleSource,
             publicKey: oracle,
         });
         return txSig;
     }
-    async initializeMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioPartial = 625, marginRatioMaintenance = 500) {
+    async initializeSerumFulfillmentConfig(marketIndex, serumMarket, serumProgram) {
+        const serumOpenOrders = (0, pda_1.getSerumOpenOrdersPublicKey)(this.program.programId, serumMarket);
+        const serumFulfillmentConfig = (0, pda_1.getSerumFulfillmentConfigPublicKey)(this.program.programId, serumMarket);
+        return await this.program.rpc.initializeSerumFulfillmentConfig(marketIndex, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                baseSpotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
+                quoteSpotMarket: this.getQuoteSpotMarketAccount().pubkey,
+                clearingHouseSigner: this.getSignerPublicKey(),
+                serumProgram,
+                serumMarket,
+                serumOpenOrders,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                serumFulfillmentConfig,
+            },
+        });
+    }
+    async initializeMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidationFee = numericConstants_1.ZERO, activeStatus = true) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, this.getStateAccount().numberOfMarkets);
-        const initializeMarketTx = await this.program.transaction.initializeMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioPartial, marginRatioMaintenance, {
+        const initializeMarketTx = await this.program.transaction.initializeMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidationFee, activeStatus, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
@@ -98,20 +116,23 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
         const { txSig } = await this.txSender.send(initializeMarketTx, [], this.opts);
-        await this.accountSubscriber.addMarket(this.getStateAccount().numberOfMarkets);
+        await this.accountSubscriber.addPerpMarket(this.getStateAccount().numberOfMarkets);
         await this.accountSubscriber.addOracle({
             source: oracleSource,
             publicKey: priceOracle,
         });
         return txSig;
     }
-    async moveAmmPrice(baseAssetReserve, quoteAssetReserve, marketIndex) {
+    async moveAmmPrice(marketIndex, baseAssetReserve, quoteAssetReserve, sqrtK) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        return await this.program.rpc.moveAmmPrice(baseAssetReserve, quoteAssetReserve, {
+        if (sqrtK == undefined) {
+            sqrtK = (0, utils_1.squareRootBN)(baseAssetReserve.mul(quoteAssetReserve));
+        }
+        return await this.program.rpc.moveAmmPrice(baseAssetReserve, quoteAssetReserve, sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
-                market: marketPublicKey,
+                perpMarket: marketPublicKey,
             },
         });
     }
@@ -121,27 +142,36 @@ class Admin extends clearingHouse_1.ClearingHouse {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-                oracle: this.getMarketAccount(marketIndex).amm.oracle,
+                oracle: this.getPerpMarketAccount(marketIndex).amm.oracle,
+            },
+        });
+    }
+    async updateConcentrationScale(marketIndex, concentrationScale) {
+        return await this.program.rpc.updateConcentrationCoef(concentrationScale, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
             },
         });
     }
-    async moveAmmToPrice(marketIndex, targetPrice) {
-        const market = this.getMarketAccount(marketIndex);
+    async moveAmmToPrice(perpMarketIndex, targetPrice) {
+        const market = this.getPerpMarketAccount(perpMarketIndex);
         const [direction, tradeSize, _] = (0, trade_1.calculateTargetPriceTrade)(market, targetPrice, new anchor_1.BN(1000), 'quote', undefined //todo
         );
         const [newQuoteAssetAmount, newBaseAssetAmount] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'quote', tradeSize, (0, amm_1.getSwapDirection)('quote', direction));
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        return await this.program.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, {
+        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, market.amm.sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
-                market: marketPublicKey,
+                perpMarket: marketPublicKey,
             },
         });
     }
     async repegAmmCurve(newPeg, marketIndex) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const ammData = this.getMarketAccount(marketIndex).amm;
+        const ammData = this.getPerpMarketAccount(marketIndex).amm;
         return await this.program.rpc.repegAmmCurve(newPeg, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -152,7 +182,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
         });
     }
     async updateAmmOracleTwap(marketIndex) {
-        const ammData = this.getMarketAccount(marketIndex).amm;
+        const ammData = this.getPerpMarketAccount(marketIndex).amm;
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
         return await this.program.rpc.updateAmmOracleTwap({
             accounts: {
@@ -164,7 +194,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
         });
     }
     async resetAmmOracleTwap(marketIndex) {
-        const ammData = this.getMarketAccount(marketIndex).amm;
+        const ammData = this.getPerpMarketAccount(marketIndex).amm;
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
         return await this.program.rpc.resetAmmOracleTwap({
             accounts: {
@@ -175,45 +205,17 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async withdrawFromInsuranceVault(amount, recipient) {
-        const state = await this.getStateAccount();
-        return await this.program.rpc.withdrawFromInsuranceVault(amount, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                insuranceVault: state.insuranceVault,
-                insuranceVaultAuthority: state.insuranceVaultAuthority,
-                recipient: recipient,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
-    }
-    async withdrawFees(marketIndex, amount, recipient) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const bank = this.getQuoteAssetBankAccount();
-        return await this.program.rpc.withdrawFees(amount, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: marketPublicKey,
-                bank: bank.pubkey,
-                bankVault: bank.vault,
-                bankVaultAuthority: bank.vaultAuthority,
-                recipient: recipient,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
-    }
-    async withdrawFromInsuranceVaultToMarket(marketIndex, amount) {
-        const state = await this.getStateAccount();
-        return await this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
+    async depositIntoMarketFeePool(marketIndex, amount, sourceVault) {
+        const spotMarket = this.getQuoteSpotMarketAccount();
+        return await this.program.rpc.depositIntoMarketFeePool(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-                insuranceVault: state.insuranceVault,
-                insuranceVaultAuthority: state.insuranceVaultAuthority,
-                bankVault: this.getQuoteAssetBankAccount().vault,
+                sourceVault,
+                clearingHouseSigner: this.getSignerPublicKey(),
+                quoteSpotMarket: spotMarket.pubkey,
+                spotMarketVault: spotMarket.vault,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
@@ -237,8 +239,8 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateMarginRatio(marketIndex, marginRatioInitial, marginRatioPartial, marginRatioMaintenance) {
-        return await this.program.rpc.updateMarginRatio(marginRatioInitial, marginRatioPartial, marginRatioMaintenance, {
+    async updateMarginRatio(marketIndex, marginRatioInitial, marginRatioMaintenance) {
+        return await this.program.rpc.updateMarginRatio(marginRatioInitial, marginRatioMaintenance, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -255,6 +257,15 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateAmmJitIntensity(marketIndex, ammJitIntensity) {
+        return await this.program.rpc.updateAmmJitIntensity(ammJitIntensity, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
     async updateMarketMaxSpread(marketIndex, maxSpread) {
         return await this.program.rpc.updateMarketMaxSpread(maxSpread, {
             accounts: {
@@ -304,16 +315,16 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateOrderFillerRewardStructure(orderFillerRewardStructure) {
-        return await this.program.rpc.updateOrderFillerRewardStructure(orderFillerRewardStructure, {
+    async updatePerpFeeStructure(feeStructure) {
+        return await this.program.rpc.updatePerpFeeStructure(feeStructure, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
     }
-    async updateFee(fees) {
-        return await this.program.rpc.updateFee(fees, {
+    async updateSpotFeeStructure(feeStructure) {
+        return await this.program.rpc.updateSpotFeeStructure(feeStructure, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -328,6 +339,60 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateWithdrawGuardThreshold(marketIndex, withdrawGuardThreshold) {
+        return await this.program.rpc.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateSpotMarketIfFactor(marketIndex, userIfFactor, totalIfFactor) {
+        return await this.program.rpc.updateSpotMarketIfFactor(marketIndex, userIfFactor, totalIfFactor, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateSpotMarketRevenueSettlePeriod(marketIndex, revenueSettlePeriod) {
+        return await this.program.rpc.updateSpotMarketRevenueSettlePeriod(revenueSettlePeriod, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateSpotMarketMaxTokenDeposits(marketIndex, maxTokenDeposits) {
+        return await this.program.rpc.updateSpotMarketMaxTokenDeposits(maxTokenDeposits, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateInsuranceWithdrawEscrowPeriod(marketIndex, insuranceWithdrawEscrowPeriod) {
+        return await this.program.rpc.updateInsuranceWithdrawEscrowPeriod(insuranceWithdrawEscrowPeriod, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateLpCooldownTime(marketIndex, cooldownTime) {
+        return await this.program.rpc.updateLpCooldownTime(cooldownTime, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
     async updateMarketOracle(marketIndex, oracle, oracleSource) {
         return await this.program.rpc.updateMarketOracle(oracle, oracleSource, {
             accounts: {
@@ -355,6 +420,15 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateMarketExpiry(perpMarketIndex, expiryTs) {
+        return await this.program.rpc.updateMarketExpiry(expiryTs, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
     async updateWhitelistMint(whitelistMint) {
         return await this.program.rpc.updateWhitelistMint(whitelistMint, {
             accounts: {
@@ -379,35 +453,108 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateFundingPaused(fundingPaused) {
-        return await this.program.rpc.updateFundingPaused(fundingPaused, {
+    async updateSpotMarketMarginWeights(spotMarketIndex, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0)) {
+        return await this.program.rpc.updateSpotMarketMarginWeights(initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
     }
-    async updateExchangePaused(exchangePaused) {
-        return await this.program.rpc.updateExchangePaused(exchangePaused, {
+    async updateSpotMarketAssetTier(spotMarketIndex, assetTier) {
+        return await this.program.rpc.updateSpotMarketAssetTier(assetTier, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
     }
-    async disableAdminControlsPrices() {
-        return await this.program.rpc.disableAdminControlsPrices({
+    async updateSpotMarketStatus(spotMarketIndex, marketStatus) {
+        return await this.program.rpc.updateSpotMarketStatus(marketStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketStatus(perpMarketIndex, marketStatus) {
+        return await this.program.rpc.updatePerpMarketStatus(marketStatus, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketContractTier(perpMarketIndex, contractTier) {
+        return await this.program.rpc.updatePerpMarketContractTier(contractTier, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateExchangeStatus(exchangeStatus) {
+        return await this.program.rpc.updateExchangeStatus(exchangeStatus, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updatePerpAuctionDuration(minDuration) {
+        return await this.program.rpc.updatePerpAuctionDuration(typeof minDuration === 'number' ? minDuration : minDuration.toNumber(), {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateSpotAuctionDuration(defaultAuctionDuration) {
+        return await this.program.rpc.updateSpotAuctionDuration(defaultAuctionDuration, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateMaxBaseAssetAmountRatio(marketIndex, maxBaseAssetAmountRatio) {
+        return await this.program.rpc.updateMaxBaseAssetAmountRatio(maxBaseAssetAmountRatio, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: this.getPerpMarketAccount(marketIndex).pubkey,
+            },
+        });
+    }
+    async updateMaxSlippageRatio(marketIndex, maxSlippageRatio) {
+        return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: this.getPerpMarketAccount(marketIndex).pubkey,
+            },
+        });
+    }
+    async updateMarketMaxImbalances(marketIndex, unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance) {
+        return await this.program.rpc.updateMarketMaxImbalances(unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
             },
         });
     }
-    async updateOrderAuctionTime(time) {
-        return await this.program.rpc.updateOrderAuctionTime(typeof time === 'number' ? time : time.toNumber, {
+    async updateSerumVault(srmVault) {
+        return await this.program.rpc.updateSerumVault({
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                srmVault: srmVault,
             },
         });
     }