@drift-labs/sdk 0.1.36-master.5 → 0.2.0-master.0

package/lib/admin.js

@@ -22,508 +22,384 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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 addresses_1 = require("./addresses");
+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");
-const clearingHouse_2 = require("./factory/clearingHouse");
 class Admin extends clearingHouse_1.ClearingHouse {
-    static from(connection, wallet, clearingHouseProgramId, opts = anchor_1.AnchorProvider.defaultOptions()) {
-        const config = (0, clearingHouse_2.getWebSocketClearingHouseConfig)(connection, wallet, clearingHouseProgramId, opts);
-        return (0, clearingHouse_2.getAdmin)(config);
-    }
-    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 [collateralVaultPublicKey, collateralVaultNonce] = yield web3_js_1.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('collateral_vault'))], this.program.programId);
-            const [collateralVaultAuthority, _collateralVaultAuthorityNonce] = yield web3_js_1.PublicKey.findProgramAddress([collateralVaultPublicKey.toBuffer()], this.program.programId);
-            const [insuranceVaultPublicKey, insuranceVaultNonce] = yield web3_js_1.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('insurance_vault'))], this.program.programId);
-            const [insuranceVaultAuthority, _insuranceVaultAuthorityNonce] = yield web3_js_1.PublicKey.findProgramAddress([insuranceVaultPublicKey.toBuffer()], this.program.programId);
-            const markets = anchor.web3.Keypair.generate();
-            const depositHistory = anchor.web3.Keypair.generate();
-            const fundingRateHistory = anchor.web3.Keypair.generate();
-            const fundingPaymentHistory = anchor.web3.Keypair.generate();
-            const tradeHistory = anchor.web3.Keypair.generate();
-            const liquidationHistory = anchor.web3.Keypair.generate();
-            const curveHistory = anchor.web3.Keypair.generate();
-            const [clearingHouseStatePublicKey, clearingHouseNonce] = yield (0, addresses_1.getClearingHouseStateAccountPublicKeyAndNonce)(this.program.programId);
-            const initializeTx = yield this.program.transaction.initialize(clearingHouseNonce, collateralVaultNonce, insuranceVaultNonce, adminControlsPrices, {
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: clearingHouseStatePublicKey,
-                    collateralMint: usdcMint,
-                    collateralVault: collateralVaultPublicKey,
-                    collateralVaultAuthority: collateralVaultAuthority,
-                    insuranceVault: insuranceVaultPublicKey,
-                    insuranceVaultAuthority: insuranceVaultAuthority,
-                    markets: markets.publicKey,
-                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                    systemProgram: anchor.web3.SystemProgram.programId,
-                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                },
-                instructions: [
-                    yield this.program.account.markets.createInstruction(markets),
-                ],
-            });
-            const initializeTxSig = yield this.txSender.send(initializeTx, [markets], this.opts);
-            const initializeHistoryTx = yield this.program.transaction.initializeHistory({
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: clearingHouseStatePublicKey,
-                    depositHistory: depositHistory.publicKey,
-                    fundingRateHistory: fundingRateHistory.publicKey,
-                    fundingPaymentHistory: fundingPaymentHistory.publicKey,
-                    tradeHistory: tradeHistory.publicKey,
-                    liquidationHistory: liquidationHistory.publicKey,
-                    curveHistory: curveHistory.publicKey,
-                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                    systemProgram: anchor.web3.SystemProgram.programId,
-                },
-                instructions: [
-                    yield this.program.account.fundingRateHistory.createInstruction(fundingRateHistory),
-                    yield this.program.account.fundingPaymentHistory.createInstruction(fundingPaymentHistory),
-                    yield this.program.account.tradeHistory.createInstruction(tradeHistory),
-                    yield this.program.account.liquidationHistory.createInstruction(liquidationHistory),
-                    yield this.program.account.depositHistory.createInstruction(depositHistory),
-                    yield this.program.account.extendedCurveHistory.createInstruction(curveHistory),
-                ],
-            });
-            const initializeHistoryTxSig = yield this.txSender.send(initializeHistoryTx, [
-                depositHistory,
-                fundingPaymentHistory,
-                tradeHistory,
-                liquidationHistory,
-                fundingRateHistory,
-                curveHistory,
-            ], this.opts);
-            const initializeOrderStateTxSig = yield this.initializeOrderState();
-            return [initializeTxSig, initializeHistoryTxSig, initializeOrderStateTxSig];
-        });
-    }
-    initializeOrderState() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const orderHistory = anchor.web3.Keypair.generate();
-            const [orderStatePublicKey, orderStateNonce] = yield (0, addresses_1.getOrderStateAccountPublicKeyAndNonce)(this.program.programId);
-            const clearingHouseStatePublicKey = yield (0, addresses_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
-            const initializeOrderStateTx = yield this.program.transaction.initializeOrderState(orderStateNonce, {
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: clearingHouseStatePublicKey,
-                    orderHistory: orderHistory.publicKey,
-                    orderState: orderStatePublicKey,
-                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                    systemProgram: anchor.web3.SystemProgram.programId,
-                },
-                instructions: [
-                    yield this.program.account.orderHistory.createInstruction(orderHistory),
-                ],
-            });
-            return yield this.txSender.send(initializeOrderStateTx, [orderHistory], this.opts);
-        });
-    }
-    initializeMarket(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioPartial = 625, marginRatioMaintenance = 500) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.getMarketsAccount().markets[marketIndex.toNumber()].initialized) {
-                throw Error(`MarketIndex ${marketIndex.toNumber()} already initialized`);
-            }
-            const initializeMarketTx = yield this.program.transaction.initializeMarket(marketIndex, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioPartial, marginRatioMaintenance, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    admin: this.wallet.publicKey,
-                    oracle: priceOracle,
-                    markets: this.getStateAccount().markets,
-                },
-            });
-            return yield this.txSender.send(initializeMarketTx, [], this.opts);
-        });
-    }
-    moveAmmPrice(baseAssetReserve, quoteAssetReserve, marketIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = this.getStateAccount();
-            return yield this.program.rpc.moveAmmPrice(baseAssetReserve, quoteAssetReserve, marketIndex, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    admin: this.wallet.publicKey,
-                    markets: state.markets,
-                },
-            });
-        });
-    }
-    updateK(sqrtK, marketIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = this.getStateAccount();
-            const markets = this.getMarketsAccount();
-            const marketData = markets.markets[marketIndex.toNumber()];
-            const ammData = marketData.amm;
-            return yield this.program.rpc.updateK(sqrtK, marketIndex, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    admin: this.wallet.publicKey,
-                    markets: state.markets,
-                    curveHistory: state.extendedCurveHistory,
-                    oracle: ammData.oracle,
-                },
-            });
-        });
-    }
-    updateCurveHistory() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const extendedCurveHistory = anchor.web3.Keypair.generate();
-            const state = this.getStateAccount();
-            return yield this.program.rpc.updateCurveHistory({
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    admin: this.wallet.publicKey,
-                    curveHistory: state.curveHistory,
-                    extendedCurveHistory: extendedCurveHistory.publicKey,
-                },
-                instructions: [
-                    yield this.program.account.extendedCurveHistory.createInstruction(extendedCurveHistory),
-                ],
-                signers: [extendedCurveHistory],
-            });
-        });
-    }
-    moveAmmToPrice(marketIndex, targetPrice) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const market = this.getMarket(marketIndex);
-            const [direction, tradeSize, _] = (0, trade_1.calculateTargetPriceTrade)(market, targetPrice);
-            const [newQuoteAssetAmount, newBaseAssetAmount] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'quote', tradeSize, (0, amm_1.getSwapDirection)('quote', direction));
-            const state = this.getStateAccount();
-            return yield this.program.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, marketIndex, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    admin: this.wallet.publicKey,
-                    markets: state.markets,
-                },
-            });
-        });
-    }
-    repegAmmCurve(newPeg, marketIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = this.getStateAccount();
-            const markets = this.getMarketsAccount();
-            const marketData = markets.markets[marketIndex.toNumber()];
-            const ammData = marketData.amm;
-            return yield this.program.rpc.repegAmmCurve(newPeg, marketIndex, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    admin: this.wallet.publicKey,
-                    oracle: ammData.oracle,
-                    markets: state.markets,
-                    curveHistory: state.extendedCurveHistory,
-                },
-            });
-        });
-    }
-    updateAmmOracleTwap(marketIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = this.getStateAccount();
-            const markets = this.getMarketsAccount();
-            const marketData = markets.markets[marketIndex.toNumber()];
-            const ammData = marketData.amm;
-            return yield this.program.rpc.updateAmmOracleTwap(marketIndex, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    admin: this.wallet.publicKey,
-                    oracle: ammData.oracle,
-                    markets: state.markets,
-                    curveHistory: state.extendedCurveHistory,
-                },
-            });
-        });
-    }
-    resetAmmOracleTwap(marketIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = this.getStateAccount();
-            const markets = this.getMarketsAccount();
-            const marketData = markets.markets[marketIndex.toNumber()];
-            const ammData = marketData.amm;
-            return yield this.program.rpc.resetAmmOracleTwap(marketIndex, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    admin: this.wallet.publicKey,
-                    oracle: ammData.oracle,
-                    markets: state.markets,
-                    curveHistory: state.extendedCurveHistory,
-                },
-            });
-        });
-    }
-    withdrawFromInsuranceVault(amount, recipient) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = yield this.getStateAccount();
-            return yield this.program.rpc.withdrawFromInsuranceVault(amount, {
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: yield this.getStatePublicKey(),
-                    insuranceVault: state.insuranceVault,
-                    insuranceVaultAuthority: state.insuranceVaultAuthority,
-                    recipient: recipient,
-                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                },
-            });
-        });
-    }
-    withdrawFees(marketIndex, amount, recipient) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = yield this.getStateAccount();
-            return yield this.program.rpc.withdrawFees(marketIndex, amount, {
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: yield this.getStatePublicKey(),
-                    markets: state.markets,
-                    collateralVault: state.collateralVault,
-                    collateralVaultAuthority: state.collateralVaultAuthority,
-                    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();
-            return yield this.program.rpc.withdrawFromInsuranceVaultToMarket(marketIndex, amount, {
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: yield this.getStatePublicKey(),
-                    markets: state.markets,
-                    insuranceVault: state.insuranceVault,
-                    insuranceVaultAuthority: state.insuranceVaultAuthority,
-                    collateralVault: state.collateralVault,
-                    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(),
-                },
-            });
-        });
-    }
-    updateMarginRatio(marketIndex, marginRatioInitial, marginRatioPartial, marginRatioMaintenance) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.program.rpc.updateMarginRatio(marketIndex, marginRatioInitial, marginRatioPartial, marginRatioMaintenance, {
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: yield this.getStatePublicKey(),
-                    markets: this.getStateAccount().markets,
-                },
-            });
-        });
-    }
-    updateMarketBaseSpread(marketIndex, baseSpread) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.program.rpc.updateMarketBaseSpread(marketIndex, baseSpread, {
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: yield this.getStatePublicKey(),
-                    markets: this.getStateAccount().markets,
-                },
-            });
-        });
-    }
-    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(),
-                    orderState: yield this.getOrderStatePublicKey(),
-                },
-            });
-        });
-    }
-    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* () {
-            const state = this.getStateAccount();
-            return yield this.program.rpc.updateMarketOracle(marketIndex, oracle, oracleSource, {
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: yield this.getStatePublicKey(),
-                    markets: state.markets,
-                },
-            });
-        });
-    }
-    updateMarketMinimumQuoteAssetTradeSize(marketIndex, minimumTradeSize) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = this.getStateAccount();
-            return yield this.program.rpc.updateMarketMinimumQuoteAssetTradeSize(marketIndex, minimumTradeSize, {
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: yield this.getStatePublicKey(),
-                    markets: state.markets,
-                },
-            });
-        });
-    }
-    updateMarketMinimumBaseAssetTradeSize(marketIndex, minimumTradeSize) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = this.getStateAccount();
-            return yield this.program.rpc.updateMarketMinimumBaseAssetTradeSize(marketIndex, minimumTradeSize, {
-                accounts: {
-                    admin: this.wallet.publicKey,
-                    state: yield this.getStatePublicKey(),
-                    markets: state.markets,
-                },
-            });
-        });
-    }
-    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(),
-                },
-            });
+    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, {
+            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 } = 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, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await 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 } = await this.txSender.send(initializeTx, [], this.opts);
+        await this.accountSubscriber.addBank(bankIndex);
+        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) {
+        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, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                oracle: priceOracle,
+                market: marketPublicKey,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+        const { txSig } = await this.txSender.send(initializeMarketTx, [], this.opts);
+        await this.accountSubscriber.addMarket(this.getStateAccount().numberOfMarkets);
+        await this.accountSubscriber.addOracle({
+            source: oracleSource,
+            publicKey: priceOracle,
+        });
+        return txSig;
+    }
+    async moveAmmPrice(baseAssetReserve, quoteAssetReserve, marketIndex) {
+        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
+        return await this.program.rpc.moveAmmPrice(baseAssetReserve, quoteAssetReserve, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                market: marketPublicKey,
+            },
+        });
+    }
+    async updateK(sqrtK, marketIndex) {
+        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.getMarketAccount(marketIndex).amm.oracle,
+            },
+        });
+    }
+    async moveAmmToPrice(marketIndex, targetPrice) {
+        const market = this.getMarketAccount(marketIndex);
+        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, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                market: marketPublicKey,
+            },
+        });
+    }
+    async repegAmmCurve(newPeg, marketIndex) {
+        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
+        const ammData = this.getMarketAccount(marketIndex).amm;
+        return await this.program.rpc.repegAmmCurve(newPeg, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                oracle: ammData.oracle,
+                market: marketPublicKey,
+            },
+        });
+    }
+    async updateAmmOracleTwap(marketIndex) {
+        const ammData = this.getMarketAccount(marketIndex).amm;
+        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
+        return await this.program.rpc.updateAmmOracleTwap({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                oracle: ammData.oracle,
+                market: marketPublicKey,
+            },
+        });
+    }
+    async resetAmmOracleTwap(marketIndex) {
+        const ammData = this.getMarketAccount(marketIndex).amm;
+        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
+        return await this.program.rpc.resetAmmOracleTwap({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                oracle: ammData.oracle,
+                market: marketPublicKey,
+            },
+        });
+    }
+    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, {
+            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,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+        });
+    }
+    async updateAdmin(admin) {
+        return await this.program.rpc.updateAdmin(admin, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateCurveUpdateIntensity(marketIndex, curveUpdateIntensity) {
+        // assert(curveUpdateIntensity >= 0 && curveUpdateIntensity <= 100);
+        // assert(Number.isInteger(curveUpdateIntensity));
+        return await this.program.rpc.updateCurveUpdateIntensity(curveUpdateIntensity, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateMarginRatio(marketIndex, marginRatioInitial, marginRatioPartial, marginRatioMaintenance) {
+        return await this.program.rpc.updateMarginRatio(marginRatioInitial, marginRatioPartial, marginRatioMaintenance, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateMarketBaseSpread(marketIndex, baseSpread) {
+        return await this.program.rpc.updateMarketBaseSpread(baseSpread, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updatePartialLiquidationClosePercentage(numerator, denominator) {
+        return await this.program.rpc.updatePartialLiquidationClosePercentage(numerator, denominator, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updatePartialLiquidationPenaltyPercentage(numerator, denominator) {
+        return await this.program.rpc.updatePartialLiquidationPenaltyPercentage(numerator, denominator, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateFullLiquidationPenaltyPercentage(numerator, denominator) {
+        return await this.program.rpc.updateFullLiquidationPenaltyPercentage(numerator, denominator, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updatePartialLiquidationShareDenominator(denominator) {
+        return await this.program.rpc.updatePartialLiquidationLiquidatorShareDenominator(denominator, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateFullLiquidationShareDenominator(denominator) {
+        return await this.program.rpc.updateFullLiquidationLiquidatorShareDenominator(denominator, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateOrderFillerRewardStructure(orderFillerRewardStructure) {
+        return await this.program.rpc.updateOrderFillerRewardStructure(orderFillerRewardStructure, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateFee(fees) {
+        return await this.program.rpc.updateFee(fees, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateOracleGuardRails(oracleGuardRails) {
+        return await this.program.rpc.updateOracleGuardRails(oracleGuardRails, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateMarketOracle(marketIndex, oracle, oracleSource) {
+        return await this.program.rpc.updateMarketOracle(oracle, oracleSource, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateMarketMinimumQuoteAssetTradeSize(marketIndex, minimumTradeSize) {
+        return await this.program.rpc.updateMarketMinimumQuoteAssetTradeSize(minimumTradeSize, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateMarketBaseAssetAmountStepSize(marketIndex, stepSize) {
+        return await this.program.rpc.updateMarketBaseAssetAmountStepSize(stepSize, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
+    async updateWhitelistMint(whitelistMint) {
+        return await this.program.rpc.updateWhitelistMint(whitelistMint, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateDiscountMint(discountMint) {
+        return await this.program.rpc.updateDiscountMint(discountMint, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateMaxDeposit(maxDeposit) {
+        return await this.program.rpc.updateMaxDeposit(maxDeposit, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateFundingPaused(fundingPaused) {
+        return await this.program.rpc.updateFundingPaused(fundingPaused, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateExchangePaused(exchangePaused) {
+        return await this.program.rpc.updateExchangePaused(exchangePaused, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async disableAdminControlsPrices() {
+        return await this.program.rpc.disableAdminControlsPrices({
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateOrderAuctionTime(time) {
+        return await this.program.rpc.updateOrderAuctionTime(typeof time === 'number' ? time : time.toNumber, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
         });
     }
 }