@drift-labs/sdk 0.2.0-master.32 → 0.2.0-master.34

package/lib/admin.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Admin = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const types_1 = require("./types");
+const userName_1 = require("./userName");
 const anchor_1 = require("@project-serum/anchor");
 const anchor = __importStar(require("@project-serum/anchor"));
 const pda_1 = require("./addresses/pda");
@@ -103,14 +104,15 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    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, marginRatioMaintenance, liquidationFee, activeStatus, {
+    async initializePerpMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidationFee = numericConstants_1.ZERO, activeStatus = true, name = userName_1.DEFAULT_MARKET_NAME) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, this.getStateAccount().numberOfMarkets);
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        const initializeMarketTx = await this.program.transaction.initializePerpMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidationFee, activeStatus, nameBuffer, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 oracle: priceOracle,
-                market: marketPublicKey,
+                perpMarket: perpMarketPublicKey,
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
                 systemProgram: anchor.web3.SystemProgram.programId,
             },
@@ -123,8 +125,8 @@ class Admin extends clearingHouse_1.ClearingHouse {
         });
         return txSig;
     }
-    async moveAmmPrice(marketIndex, baseAssetReserve, quoteAssetReserve, sqrtK) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
+    async moveAmmPrice(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));
         }
@@ -136,82 +138,82 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateK(sqrtK, marketIndex) {
+    async updateK(perpMarketIndex, sqrtK) {
         return await this.program.rpc.updateK(sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-                oracle: this.getPerpMarketAccount(marketIndex).amm.oracle,
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                oracle: this.getPerpMarketAccount(perpMarketIndex).amm.oracle,
             },
         });
     }
-    async updateConcentrationScale(marketIndex, concentrationScale) {
-        return await this.program.rpc.updateConcentrationCoef(concentrationScale, {
+    async updatePerpMarketConcentrationScale(perpMarketIndex, concentrationScale) {
+        return await this.program.rpc.updatePerpMarketConcentrationCoef(concentrationScale, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
     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 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)(market.amm, 'quote', tradeSize, (0, amm_1.getSwapDirection)('quote', direction));
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex);
-        return await this.program.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, market.amm.sqrtK, {
+        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.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, perpMarket.amm.sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
-                perpMarket: marketPublicKey,
+                perpMarket: perpMarketPublicKey,
             },
         });
     }
-    async repegAmmCurve(newPeg, marketIndex) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const ammData = this.getPerpMarketAccount(marketIndex).amm;
+    async repegAmmCurve(newPeg, perpMarketIndex) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
         return await this.program.rpc.repegAmmCurve(newPeg, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 oracle: ammData.oracle,
-                market: marketPublicKey,
+                perpMarket: perpMarketPublicKey,
             },
         });
     }
-    async updateAmmOracleTwap(marketIndex) {
-        const ammData = this.getPerpMarketAccount(marketIndex).amm;
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        return await this.program.rpc.updateAmmOracleTwap({
+    async updatePerpMarketAmmOracleTwap(perpMarketIndex) {
+        const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.rpc.updatePerpMarketAmmOracleTwap({
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 oracle: ammData.oracle,
-                market: marketPublicKey,
+                perpMarket: perpMarketPublicKey,
             },
         });
     }
-    async resetAmmOracleTwap(marketIndex) {
-        const ammData = this.getPerpMarketAccount(marketIndex).amm;
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        return await this.program.rpc.resetAmmOracleTwap({
+    async resetPerpMarketAmmOracleTwap(perpMarketIndex) {
+        const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.rpc.resetPerpMarketAmmOracleTwap({
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 oracle: ammData.oracle,
-                market: marketPublicKey,
+                perpMarket: perpMarketPublicKey,
             },
         });
     }
-    async depositIntoMarketFeePool(marketIndex, amount, sourceVault) {
+    async depositIntoPerpMarketFeePool(perpMarketIndex, amount, sourceVault) {
         const spotMarket = this.getQuoteSpotMarketAccount();
-        return await this.program.rpc.depositIntoMarketFeePool(amount, {
+        return await this.program.rpc.depositIntoPerpMarketFeePool(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
                 sourceVault,
                 clearingHouseSigner: this.getSignerPublicKey(),
                 quoteSpotMarket: spotMarket.pubkey,
@@ -228,204 +230,202 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateCurveUpdateIntensity(marketIndex, curveUpdateIntensity) {
+    async updatePerpMarketCurveUpdateIntensity(perpMarketIndex, curveUpdateIntensity) {
         // assert(curveUpdateIntensity >= 0 && curveUpdateIntensity <= 100);
         // assert(Number.isInteger(curveUpdateIntensity));
-        return await this.program.rpc.updateCurveUpdateIntensity(curveUpdateIntensity, {
+        return await this.program.rpc.updatePerpMarketCurveUpdateIntensity(curveUpdateIntensity, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
-    async updateMarginRatio(marketIndex, marginRatioInitial, marginRatioMaintenance) {
-        return await this.program.rpc.updateMarginRatio(marginRatioInitial, marginRatioMaintenance, {
+    async updatePerpMarketMarginRatio(perpMarketIndex, marginRatioInitial, marginRatioMaintenance) {
+        return await this.program.rpc.updatePerpMarketMarginRatio(marginRatioInitial, marginRatioMaintenance, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
-    async updateMarketBaseSpread(marketIndex, baseSpread) {
-        return await this.program.rpc.updateMarketBaseSpread(baseSpread, {
+    async updatePerpMarketBaseSpread(perpMarketIndex, baseSpread) {
+        return await this.program.rpc.updatePerpMarketBaseSpread(baseSpread, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
-    async updateAmmJitIntensity(marketIndex, ammJitIntensity) {
+    async updateAmmJitIntensity(perpMarketIndex, 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: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
-    async updatePartialLiquidationClosePercentage(numerator, denominator) {
-        return await this.program.rpc.updatePartialLiquidationClosePercentage(numerator, denominator, {
+    async updatePerpMarketName(perpMarketIndex, name) {
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        return await this.program.rpc.updatePerpMarketName(nameBuffer, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
-    async updatePartialLiquidationPenaltyPercentage(numerator, denominator) {
-        return await this.program.rpc.updatePartialLiquidationPenaltyPercentage(numerator, denominator, {
+    async updatePerpMarketMaxSpread(perpMarketIndex, maxSpread) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.rpc.updatePerpMarketMaxSpread(maxSpread, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                perpMarket: perpMarketPublicKey,
             },
         });
     }
-    async updateFullLiquidationPenaltyPercentage(numerator, denominator) {
-        return await this.program.rpc.updateFullLiquidationPenaltyPercentage(numerator, denominator, {
+    async updatePerpFeeStructure(feeStructure) {
+        return await this.program.rpc.updatePerpFeeStructure(feeStructure, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
     }
-    async updatePartialLiquidationShareDenominator(denominator) {
-        return await this.program.rpc.updatePartialLiquidationLiquidatorShareDenominator(denominator, {
+    async updateSpotFeeStructure(feeStructure) {
+        return await this.program.rpc.updateSpotFeeStructure(feeStructure, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
     }
-    async updateFullLiquidationShareDenominator(denominator) {
-        return await this.program.rpc.updateFullLiquidationLiquidatorShareDenominator(denominator, {
+    async updateOracleGuardRails(oracleGuardRails) {
+        return await this.program.rpc.updateOracleGuardRails(oracleGuardRails, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
     }
-    async updatePerpFeeStructure(feeStructure) {
-        return await this.program.rpc.updatePerpFeeStructure(feeStructure, {
+    async updateStateSettlementDuration(settlementDuration) {
+        return await this.program.rpc.updateStateSettlementDuration(settlementDuration, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
     }
-    async updateSpotFeeStructure(feeStructure) {
-        return await this.program.rpc.updateSpotFeeStructure(feeStructure, {
+    async updateWithdrawGuardThreshold(spotMarketIndex, 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, spotMarketIndex),
             },
         });
     }
-    async updateOracleGuardRails(oracleGuardRails) {
-        return await this.program.rpc.updateOracleGuardRails(oracleGuardRails, {
+    async updateSpotMarketIfFactor(spotMarketIndex, userIfFactor, totalIfFactor) {
+        return await this.program.rpc.updateSpotMarketIfFactor(spotMarketIndex, userIfFactor, totalIfFactor, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
     }
-    async updateWithdrawGuardThreshold(marketIndex, withdrawGuardThreshold) {
-        return await this.program.rpc.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
+    async updateSpotMarketRevenueSettlePeriod(spotMarketIndex, 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),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
     }
-    async updateSpotMarketIfFactor(marketIndex, userIfFactor, totalIfFactor) {
-        return await this.program.rpc.updateSpotMarketIfFactor(marketIndex, userIfFactor, totalIfFactor, {
+    async updateSpotMarketMaxTokenDeposits(spotMarketIndex, 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),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
     }
-    async updateSpotMarketRevenueSettlePeriod(marketIndex, revenueSettlePeriod) {
-        return await this.program.rpc.updateSpotMarketRevenueSettlePeriod(revenueSettlePeriod, {
+    async updateInsuranceFundUnstakingPeriod(spotMarketIndex, insuranceWithdrawEscrowPeriod) {
+        return await this.program.rpc.updateInsuranceFundUnstakingPeriod(insuranceWithdrawEscrowPeriod, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
     }
-    async updateSpotMarketMaxTokenDeposits(marketIndex, maxTokenDeposits) {
-        return await this.program.rpc.updateSpotMarketMaxTokenDeposits(maxTokenDeposits, {
+    async updateLpCooldownTime(cooldownTime) {
+        return await this.program.rpc.updateLpCooldownTime(cooldownTime, {
             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, {
+    async updatePerpMarketOracle(perpMarketIndex, oracle, oracleSource) {
+        return await this.program.rpc.updatePerpMarketOracle(oracle, oracleSource, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                oracle: oracle,
             },
         });
     }
-    async updateLpCooldownTime(marketIndex, cooldownTime) {
-        return await this.program.rpc.updateLpCooldownTime(cooldownTime, {
+    async updatePerpMarketStepSizeAndTickSize(perpMarketIndex, stepSize, tickSize) {
+        return await this.program.rpc.updatePerpMarketStepSizeAndTickSize(stepSize, tickSize, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
-    async updateMarketOracle(marketIndex, oracle, oracleSource) {
-        return await this.program.rpc.updateMarketOracle(oracle, oracleSource, {
+    async updatePerpMarketMinOrderSize(perpMarketIndex, orderSize) {
+        return await this.program.rpc.updatePerpMarketMinOrderSize(orderSize, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
-    async updateMarketMinimumQuoteAssetTradeSize(marketIndex, minimumTradeSize) {
-        return await this.program.rpc.updateMarketMinimumQuoteAssetTradeSize(minimumTradeSize, {
+    async updatePerpMarketExpiry(perpMarketIndex, expiryTs) {
+        return await this.program.rpc.updatePerpMarketExpiry(expiryTs, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
-    async updateMarketBaseAssetAmountStepSize(marketIndex, stepSize) {
-        return await this.program.rpc.updateMarketBaseAssetAmountStepSize(stepSize, {
+    async updateSpotMarketOracle(spotMarketIndex, oracle, oracleSource) {
+        return await this.program.rpc.updatePerpMarketOracle(oracle, oracleSource, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+                oracle: oracle,
             },
         });
     }
-    async updateMarketExpiry(perpMarketIndex, expiryTs) {
-        return await this.program.rpc.updateMarketExpiry(expiryTs, {
+    async updateSpotMarketExpiry(spotMarketIndex, expiryTs) {
+        return await this.program.rpc.updateSpotMarketExpiry(expiryTs, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                perpMarket: await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
     }
@@ -445,14 +445,6 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateMaxDeposit(maxDeposit) {
-        return await this.program.rpc.updateMaxDeposit(maxDeposit, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
     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: {
@@ -485,7 +477,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
@@ -494,7 +486,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
@@ -522,30 +514,30 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateMaxBaseAssetAmountRatio(marketIndex, maxBaseAssetAmountRatio) {
-        return await this.program.rpc.updateMaxBaseAssetAmountRatio(maxBaseAssetAmountRatio, {
+    async updatePerpMarketMaxFillReserveFraction(perpMarketIndex, maxBaseAssetAmountRatio) {
+        return await this.program.rpc.updatePerpMarketMaxFillReserveFraction(maxBaseAssetAmountRatio, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: this.getPerpMarketAccount(marketIndex).pubkey,
+                perpMarket: this.getPerpMarketAccount(perpMarketIndex).pubkey,
             },
         });
     }
-    async updateMaxSlippageRatio(marketIndex, maxSlippageRatio) {
+    async updateMaxSlippageRatio(perpMarketIndex, maxSlippageRatio) {
         return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: this.getPerpMarketAccount(marketIndex).pubkey,
+                perpMarket: this.getPerpMarketAccount(perpMarketIndex).pubkey,
             },
         });
     }
-    async updateMarketMaxImbalances(marketIndex, unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance) {
-        return await this.program.rpc.updateMarketMaxImbalances(unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, {
+    async updatePerpMarketMaxImbalances(perpMarketIndex, unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance) {
+        return await this.program.rpc.updatePerpMarketMaxImbalances(unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }