@drift-labs/sdk 0.2.0-temp.0 → 0.2.0-temp.1

package/src/admin.js

@@ -0,0 +1,517 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Admin = void 0;
+const web3_js_1 = require("@solana/web3.js");
+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 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 {
+    initialize(usdcMint, adminControlsPrices) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stateAccountRPCResponse = yield this.connection.getParsedAccountInfo(yield this.getStatePublicKey());
+            if (stateAccountRPCResponse.value !== null) {
+                throw new Error('Clearing house already initialized');
+            }
+            const [insuranceVaultPublicKey] = yield web3_js_1.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('insurance_vault'))], this.program.programId);
+            const [insuranceVaultAuthority] = yield web3_js_1.PublicKey.findProgramAddress([insuranceVaultPublicKey.toBuffer()], this.program.programId);
+            const [clearingHouseStatePublicKey] = yield pda_1.getClearingHouseStateAccountPublicKeyAndNonce(this.program.programId);
+            const initializeTx = yield this.program.transaction.initialize(adminControlsPrices, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: clearingHouseStatePublicKey,
+                    quoteAssetMint: usdcMint,
+                    insuranceVault: insuranceVaultPublicKey,
+                    insuranceVaultAuthority: insuranceVaultAuthority,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: anchor.web3.SystemProgram.programId,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+            const { txSig: initializeTxSig } = yield this.txSender.send(initializeTx, [], this.opts);
+            return [initializeTxSig];
+        });
+    }
+    initializeBank(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0), liquidationFee = numericConstants_1.ZERO) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bankIndex = this.getStateAccount().numberOfBanks;
+            const bank = yield pda_1.getBankPublicKey(this.program.programId, bankIndex);
+            const bankVault = yield pda_1.getBankVaultPublicKey(this.program.programId, bankIndex);
+            const bankVaultAuthority = yield pda_1.getBankVaultAuthorityPublicKey(this.program.programId, bankIndex);
+            const initializeTx = yield this.program.transaction.initializeBank(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidationFee, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    bank,
+                    bankVault,
+                    bankVaultAuthority,
+                    bankMint: mint,
+                    oracle,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: anchor.web3.SystemProgram.programId,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+            const { txSig } = yield this.txSender.send(initializeTx, [], this.opts);
+            yield this.accountSubscriber.addBank(bankIndex);
+            yield this.accountSubscriber.addOracle({
+                source: oracleSource,
+                publicKey: oracle,
+            });
+            return txSig;
+        });
+    }
+    initializeMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidationFee = numericConstants_1.ZERO) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, this.getStateAccount().numberOfMarkets);
+            const initializeMarketTx = yield this.program.transaction.initializeMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidationFee, {
+                accounts: {
+                    state: yield this.getStatePublicKey(),
+                    admin: this.wallet.publicKey,
+                    oracle: priceOracle,
+                    market: marketPublicKey,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: anchor.web3.SystemProgram.programId,
+                },
+            });
+            const { txSig } = yield this.txSender.send(initializeMarketTx, [], this.opts);
+            yield this.accountSubscriber.addMarket(this.getStateAccount().numberOfMarkets);
+            yield this.accountSubscriber.addOracle({
+                source: oracleSource,
+                publicKey: priceOracle,
+            });
+            return txSig;
+        });
+    }
+    moveAmmPrice(baseAssetReserve, quoteAssetReserve, marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, marketIndex);
+            return yield this.program.rpc.moveAmmPrice(baseAssetReserve, quoteAssetReserve, {
+                accounts: {
+                    state: yield this.getStatePublicKey(),
+                    admin: this.wallet.publicKey,
+                    market: marketPublicKey,
+                },
+            });
+        });
+    }
+    updateK(sqrtK, marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateK(sqrtK, {
+                accounts: {
+                    state: yield this.getStatePublicKey(),
+                    admin: this.wallet.publicKey,
+                    market: yield pda_1.getMarketPublicKey(this.program.programId, marketIndex),
+                    oracle: this.getMarketAccount(marketIndex).amm.oracle,
+                },
+            });
+        });
+    }
+    moveAmmToPrice(marketIndex, targetPrice) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const market = this.getMarketAccount(marketIndex);
+            const [direction, tradeSize, _] = trade_1.calculateTargetPriceTrade(market, targetPrice, new anchor_1.BN(1000), 'quote', undefined //todo
+            );
+            const [newQuoteAssetAmount, newBaseAssetAmount] = amm_1.calculateAmmReservesAfterSwap(market.amm, 'quote', tradeSize, amm_1.getSwapDirection('quote', direction));
+            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, marketIndex);
+            return yield this.program.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, {
+                accounts: {
+                    state: yield this.getStatePublicKey(),
+                    admin: this.wallet.publicKey,
+                    market: marketPublicKey,
+                },
+            });
+        });
+    }
+    repegAmmCurve(newPeg, marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, marketIndex);
+            const ammData = this.getMarketAccount(marketIndex).amm;
+            return yield this.program.rpc.repegAmmCurve(newPeg, {
+                accounts: {
+                    state: yield this.getStatePublicKey(),
+                    admin: this.wallet.publicKey,
+                    oracle: ammData.oracle,
+                    market: marketPublicKey,
+                },
+            });
+        });
+    }
+    updateAmmOracleTwap(marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ammData = this.getMarketAccount(marketIndex).amm;
+            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, marketIndex);
+            return yield this.program.rpc.updateAmmOracleTwap({
+                accounts: {
+                    state: yield this.getStatePublicKey(),
+                    admin: this.wallet.publicKey,
+                    oracle: ammData.oracle,
+                    market: marketPublicKey,
+                },
+            });
+        });
+    }
+    resetAmmOracleTwap(marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ammData = this.getMarketAccount(marketIndex).amm;
+            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, marketIndex);
+            return yield this.program.rpc.resetAmmOracleTwap({
+                accounts: {
+                    state: yield this.getStatePublicKey(),
+                    admin: this.wallet.publicKey,
+                    oracle: ammData.oracle,
+                    market: marketPublicKey,
+                },
+            });
+        });
+    }
+    withdrawFromInsuranceVault(amount, recipient) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.getStateAccount();
+            const bank = this.getQuoteAssetBankAccount();
+            return yield this.program.rpc.withdrawFromInsuranceVault(amount, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    bank: bank.pubkey,
+                    insuranceVault: state.insuranceVault,
+                    insuranceVaultAuthority: state.insuranceVaultAuthority,
+                    recipient: recipient,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    withdrawFromMarketToInsuranceVault(marketIndex, amount, recipient) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, marketIndex);
+            const bank = this.getQuoteAssetBankAccount();
+            return yield this.program.rpc.withdrawFromMarketToInsuranceVault(amount, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: marketPublicKey,
+                    bank: bank.pubkey,
+                    bankVault: bank.vault,
+                    bankVaultAuthority: bank.vaultAuthority,
+                    recipient: recipient,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    withdrawFromInsuranceVaultToMarket(marketIndex, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.getStateAccount();
+            const bank = this.getQuoteAssetBankAccount();
+            return yield this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: yield pda_1.getMarketPublicKey(this.program.programId, marketIndex),
+                    insuranceVault: state.insuranceVault,
+                    insuranceVaultAuthority: state.insuranceVaultAuthority,
+                    bank: bank.pubkey,
+                    bankVault: bank.vault,
+                    bankVaultAuthority: bank.vaultAuthority,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    updateAdmin(admin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateAdmin(admin, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateCurveUpdateIntensity(marketIndex, curveUpdateIntensity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // assert(curveUpdateIntensity >= 0 && curveUpdateIntensity <= 100);
+            // assert(Number.isInteger(curveUpdateIntensity));
+            return yield this.program.rpc.updateCurveUpdateIntensity(curveUpdateIntensity, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: yield pda_1.getMarketPublicKey(this.program.programId, marketIndex),
+                },
+            });
+        });
+    }
+    updateMarginRatio(marketIndex, marginRatioInitial, marginRatioMaintenance) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateMarginRatio(marginRatioInitial, marginRatioMaintenance, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: yield pda_1.getMarketPublicKey(this.program.programId, marketIndex),
+                },
+            });
+        });
+    }
+    updateMarketBaseSpread(marketIndex, baseSpread) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateMarketBaseSpread(baseSpread, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: yield pda_1.getMarketPublicKey(this.program.programId, marketIndex),
+                },
+            });
+        });
+    }
+    updateMarketMaxSpread(marketIndex, maxSpread) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateMarketMaxSpread(maxSpread, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: yield pda_1.getMarketPublicKey(this.program.programId, marketIndex),
+                },
+            });
+        });
+    }
+    updatePartialLiquidationClosePercentage(numerator, denominator) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updatePartialLiquidationClosePercentage(numerator, denominator, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updatePartialLiquidationPenaltyPercentage(numerator, denominator) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updatePartialLiquidationPenaltyPercentage(numerator, denominator, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateFullLiquidationPenaltyPercentage(numerator, denominator) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateFullLiquidationPenaltyPercentage(numerator, denominator, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updatePartialLiquidationShareDenominator(denominator) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updatePartialLiquidationLiquidatorShareDenominator(denominator, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateFullLiquidationShareDenominator(denominator) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateFullLiquidationLiquidatorShareDenominator(denominator, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateOrderFillerRewardStructure(orderFillerRewardStructure) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateOrderFillerRewardStructure(orderFillerRewardStructure, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateFee(fees) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateFee(fees, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateOracleGuardRails(oracleGuardRails) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateOracleGuardRails(oracleGuardRails, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateMarketOracle(marketIndex, oracle, oracleSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateMarketOracle(oracle, oracleSource, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: yield pda_1.getMarketPublicKey(this.program.programId, marketIndex),
+                },
+            });
+        });
+    }
+    updateMarketMinimumQuoteAssetTradeSize(marketIndex, minimumTradeSize) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateMarketMinimumQuoteAssetTradeSize(minimumTradeSize, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: yield pda_1.getMarketPublicKey(this.program.programId, marketIndex),
+                },
+            });
+        });
+    }
+    updateMarketBaseAssetAmountStepSize(marketIndex, stepSize) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateMarketBaseAssetAmountStepSize(stepSize, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: yield pda_1.getMarketPublicKey(this.program.programId, marketIndex),
+                },
+            });
+        });
+    }
+    updateWhitelistMint(whitelistMint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateWhitelistMint(whitelistMint, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateDiscountMint(discountMint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateDiscountMint(discountMint, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateMaxDeposit(maxDeposit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateMaxDeposit(maxDeposit, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateFundingPaused(fundingPaused) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateFundingPaused(fundingPaused, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateExchangePaused(exchangePaused) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateExchangePaused(exchangePaused, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    disableAdminControlsPrices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.disableAdminControlsPrices({
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateAuctionDuration(minDuration, maxDuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateAuctionDuration(typeof minDuration === 'number' ? minDuration : minDuration.toNumber(), typeof maxDuration === 'number' ? maxDuration : maxDuration.toNumber(), {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                },
+            });
+        });
+    }
+    updateMaxBaseAssetAmountRatio(marketIndex, maxBaseAssetAmountRatio) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateMaxBaseAssetAmountRatio(maxBaseAssetAmountRatio, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: this.getMarketAccount(marketIndex).pubkey,
+                },
+            });
+        });
+    }
+    updateMaxSlippageRatio(marketIndex, maxSlippageRatio) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
+                accounts: {
+                    admin: this.wallet.publicKey,
+                    state: yield this.getStatePublicKey(),
+                    market: this.getMarketAccount(marketIndex).pubkey,
+                },
+            });
+        });
+    }
+}
+exports.Admin = Admin;

package/src/admin.ts

@@ -20,7 +20,7 @@ import {
 } from './addresses/pda';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { ClearingHouse } from './clearingHouse';
-import { PEG_PRECISION } from './constants/numericConstants';
+import { PEG_PRECISION, ZERO } from './constants/numericConstants';
 import { calculateTargetPriceTrade } from './math/trade';
 import { calculateAmmReservesAfterSwap, getSwapDirection } from './math/amm';
 
@@ -85,7 +85,9 @@ export class Admin extends ClearingHouse {
 		initialAssetWeight: BN,
 		maintenanceAssetWeight: BN,
 		initialLiabilityWeight: BN,
-		maintenanceLiabilityWeight: BN
+		maintenanceLiabilityWeight: BN,
+		imfFactor = new BN(0),
+		liquidationFee = ZERO
 	): Promise<TransactionSignature> {
 		const bankIndex = this.getStateAccount().numberOfBanks;
 		const bank = await getBankPublicKey(this.program.programId, bankIndex);
@@ -109,6 +111,8 @@ export class Admin extends ClearingHouse {
 			maintenanceAssetWeight,
 			initialLiabilityWeight,
 			maintenanceLiabilityWeight,
+			imfFactor,
+			liquidationFee,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
@@ -144,8 +148,8 @@ export class Admin extends ClearingHouse {
 		pegMultiplier: BN = PEG_PRECISION,
 		oracleSource: OracleSource = OracleSource.PYTH,
 		marginRatioInitial = 2000,
-		marginRatioPartial = 625,
-		marginRatioMaintenance = 500
+		marginRatioMaintenance = 500,
+		liquidationFee = ZERO
 	): Promise<TransactionSignature> {
 		const marketPublicKey = await getMarketPublicKey(
 			this.program.programId,
@@ -159,8 +163,8 @@ export class Admin extends ClearingHouse {
 			pegMultiplier,
 			oracleSource,
 			marginRatioInitial,
-			marginRatioPartial,
 			marginRatioMaintenance,
+			liquidationFee,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
@@ -329,10 +333,12 @@ export class Admin extends ClearingHouse {
 		recipient: PublicKey
 	): Promise<TransactionSignature> {
 		const state = await this.getStateAccount();
+		const bank = this.getQuoteAssetBankAccount();
 		return await this.program.rpc.withdrawFromInsuranceVault(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
+				bank: bank.pubkey,
 				insuranceVault: state.insuranceVault,
 				insuranceVaultAuthority: state.insuranceVaultAuthority,
 				recipient: recipient,
@@ -341,7 +347,7 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async withdrawFees(
+	public async withdrawFromMarketToInsuranceVault(
 		marketIndex: BN,
 		amount: BN,
 		recipient: PublicKey
@@ -351,7 +357,7 @@ export class Admin extends ClearingHouse {
 			marketIndex
 		);
 		const bank = this.getQuoteAssetBankAccount();
-		return await this.program.rpc.withdrawFees(amount, {
+		return await this.program.rpc.withdrawFromMarketToInsuranceVault(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
@@ -370,6 +376,8 @@ export class Admin extends ClearingHouse {
 		amount: BN
 	): Promise<TransactionSignature> {
 		const state = await this.getStateAccount();
+		const bank = this.getQuoteAssetBankAccount();
+
 		return await this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
@@ -377,7 +385,9 @@ export class Admin extends ClearingHouse {
 				market: await getMarketPublicKey(this.program.programId, marketIndex),
 				insuranceVault: state.insuranceVault,
 				insuranceVaultAuthority: state.insuranceVaultAuthority,
-				bankVault: this.getQuoteAssetBankAccount().vault,
+				bank: bank.pubkey,
+				bankVault: bank.vault,
+				bankVaultAuthority: bank.vaultAuthority,
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
 		});
@@ -414,12 +424,10 @@ export class Admin extends ClearingHouse {
 	public async updateMarginRatio(
 		marketIndex: BN,
 		marginRatioInitial: number,
-		marginRatioPartial: number,
 		marginRatioMaintenance: number
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateMarginRatio(
 			marginRatioInitial,
-			marginRatioPartial,
 			marginRatioMaintenance,
 			{
 				accounts: {
@@ -675,11 +683,13 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async updateOrderAuctionTime(
-		time: BN | number
+	public async updateAuctionDuration(
+		minDuration: BN | number,
+		maxDuration: BN | number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateOrderAuctionTime(
-			typeof time === 'number' ? time : time.toNumber,
+		return await this.program.rpc.updateAuctionDuration(
+			typeof minDuration === 'number' ? minDuration : minDuration.toNumber(),
+			typeof maxDuration === 'number' ? maxDuration : maxDuration.toNumber(),
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
@@ -688,4 +698,33 @@ export class Admin extends ClearingHouse {
 			}
 		);
 	}
+
+	public async updateMaxBaseAssetAmountRatio(
+		marketIndex: BN,
+		maxBaseAssetAmountRatio: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMaxBaseAssetAmountRatio(
+			maxBaseAssetAmountRatio,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					market: this.getMarketAccount(marketIndex).pubkey,
+				},
+			}
+		);
+	}
+
+	public async updateMaxSlippageRatio(
+		marketIndex: BN,
+		maxSlippageRatio: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: this.getMarketAccount(marketIndex).pubkey,
+			},
+		});
+	}
 }

package/src/assert/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+function assert(condition, error) {
+    if (!condition) {
+        throw new Error(error || 'Unspecified AssertionError');
+    }
+}
+exports.assert = assert;