@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/lib/adminClient.js

@@ -0,0 +1,637 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminClient = 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");
+const utils_1 = require("./math/utils");
+const spl_token_1 = require("@solana/spl-token");
+const driftClient_1 = require("./driftClient");
+const numericConstants_1 = require("./constants/numericConstants");
+const trade_1 = require("./math/trade");
+const amm_1 = require("./math/amm");
+class AdminClient extends driftClient_1.DriftClient {
+    async initialize(usdcMint, _adminControlsPrices) {
+        const stateAccountRPCResponse = await this.connection.getParsedAccountInfo(await this.getStatePublicKey());
+        if (stateAccountRPCResponse.value !== null) {
+            throw new Error('Clearing house already initialized');
+        }
+        const [driftStatePublicKey] = await (0, pda_1.getDriftStateAccountPublicKeyAndNonce)(this.program.programId);
+        const initializeTx = await this.program.transaction.initialize({
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: driftStatePublicKey,
+                quoteAssetMint: usdcMint,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                driftSigner: this.getSignerPublicKey(),
+                systemProgram: anchor.web3.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+        });
+        const { txSig: initializeTxSig } = await this.txSender.send(initializeTx, [], this.opts);
+        return [initializeTxSig];
+    }
+    async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0, liquidatorFee = 0, activeStatus = true, name = userName_1.DEFAULT_MARKET_NAME) {
+        const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
+        const spotMarket = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex);
+        const spotMarketVault = await (0, pda_1.getSpotMarketVaultPublicKey)(this.program.programId, spotMarketIndex);
+        const insuranceFundVault = await (0, pda_1.getInsuranceFundVaultPublicKey)(this.program.programId, spotMarketIndex);
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        const initializeTx = await this.program.transaction.initializeSpotMarket(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidatorFee, activeStatus, nameBuffer, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket,
+                spotMarketVault,
+                insuranceFundVault,
+                driftSigner: this.getSignerPublicKey(),
+                spotMarketMint: mint,
+                oracle,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+        });
+        const { txSig } = await this.txSender.send(initializeTx, [], this.opts);
+        await this.accountSubscriber.addSpotMarket(spotMarketIndex);
+        await this.accountSubscriber.addOracle({
+            source: oracleSource,
+            publicKey: oracle,
+        });
+        return txSig;
+    }
+    async initializeSerumFulfillmentConfig(marketIndex, serumMarket, serumProgram) {
+        const serumOpenOrders = (0, pda_1.getSerumOpenOrdersPublicKey)(this.program.programId, serumMarket);
+        const serumFulfillmentConfig = (0, pda_1.getSerumFulfillmentConfigPublicKey)(this.program.programId, serumMarket);
+        return await this.program.rpc.initializeSerumFulfillmentConfig(marketIndex, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                baseSpotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
+                quoteSpotMarket: this.getQuoteSpotMarketAccount().pubkey,
+                driftSigner: this.getSignerPublicKey(),
+                serumProgram,
+                serumMarket,
+                serumOpenOrders,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                serumFulfillmentConfig,
+            },
+        });
+    }
+    async initializePerpMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidatorFee = 0, 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, liquidatorFee, activeStatus, nameBuffer, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                oracle: priceOracle,
+                perpMarket: perpMarketPublicKey,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+        const { txSig } = await this.txSender.send(initializeMarketTx, [], this.opts);
+        await this.accountSubscriber.addPerpMarket(this.getStateAccount().numberOfMarkets);
+        await this.accountSubscriber.addOracle({
+            source: oracleSource,
+            publicKey: priceOracle,
+        });
+        return txSig;
+    }
+    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));
+        }
+        return await this.program.rpc.moveAmmPrice(baseAssetReserve, quoteAssetReserve, sqrtK, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                perpMarket: marketPublicKey,
+            },
+        });
+    }
+    async updateK(perpMarketIndex, sqrtK) {
+        return await this.program.rpc.updateK(sqrtK, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                oracle: this.getPerpMarketAccount(perpMarketIndex).amm.oracle,
+            },
+        });
+    }
+    async updatePerpMarketConcentrationScale(perpMarketIndex, concentrationScale) {
+        return await this.program.rpc.updatePerpMarketConcentrationCoef(concentrationScale, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async moveAmmToPrice(perpMarketIndex, targetPrice) {
+        const perpMarket = this.getPerpMarketAccount(perpMarketIndex);
+        const [direction, tradeSize, _] = (0, trade_1.calculateTargetPriceTrade)(perpMarket, targetPrice, new anchor_1.BN(1000), 'quote', undefined //todo
+        );
+        const [newQuoteAssetAmount, newBaseAssetAmount] = (0, amm_1.calculateAmmReservesAfterSwap)(perpMarket.amm, 'quote', tradeSize, (0, amm_1.getSwapDirection)('quote', direction));
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, perpMarket.amm.sqrtK, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                admin: this.wallet.publicKey,
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    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,
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    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,
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    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,
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
+    async depositIntoPerpMarketFeePool(perpMarketIndex, amount, sourceVault) {
+        const spotMarket = this.getQuoteSpotMarketAccount();
+        return await this.program.rpc.depositIntoPerpMarketFeePool(amount, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                sourceVault,
+                driftSigner: this.getSignerPublicKey(),
+                quoteSpotMarket: spotMarket.pubkey,
+                spotMarketVault: spotMarket.vault,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+        });
+    }
+    async updateAdmin(admin) {
+        return await this.program.rpc.updateAdmin(admin, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updatePerpMarketCurveUpdateIntensity(perpMarketIndex, curveUpdateIntensity) {
+        // assert(curveUpdateIntensity >= 0 && curveUpdateIntensity <= 100);
+        // assert(Number.isInteger(curveUpdateIntensity));
+        return await this.program.rpc.updatePerpMarketCurveUpdateIntensity(curveUpdateIntensity, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketMarginRatio(perpMarketIndex, marginRatioInitial, marginRatioMaintenance) {
+        return await this.program.rpc.updatePerpMarketMarginRatio(marginRatioInitial, marginRatioMaintenance, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketImfFactor(perpMarketIndex, imfFactor, unrealizedPnlImfFactor) {
+        return await this.program.rpc.updatePerpMarketImfFactor(imfFactor, unrealizedPnlImfFactor, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketBaseSpread(perpMarketIndex, baseSpread) {
+        return await this.program.rpc.updatePerpMarketBaseSpread(baseSpread, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateAmmJitIntensity(perpMarketIndex, ammJitIntensity) {
+        return await this.program.rpc.updateAmmJitIntensity(ammJitIntensity, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    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 updateSpotMarketName(spotMarketIndex, name) {
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        return await this.program.rpc.updateSpotMarketName(nameBuffer, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    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 updatePerpFeeStructure(feeStructure) {
+        return await this.program.rpc.updatePerpFeeStructure(feeStructure, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateSpotFeeStructure(feeStructure) {
+        return await this.program.rpc.updateSpotFeeStructure(feeStructure, {
+            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 updateStateSettlementDuration(settlementDuration) {
+        return await this.program.rpc.updateStateSettlementDuration(settlementDuration, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    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 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 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, spotMarketIndex),
+            },
+        });
+    }
+    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, spotMarketIndex),
+            },
+        });
+    }
+    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, spotMarketIndex),
+            },
+        });
+    }
+    async updateLpCooldownTime(cooldownTime) {
+        return await this.program.rpc.updateLpCooldownTime(cooldownTime, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updatePerpMarketOracle(perpMarketIndex, oracle, oracleSource) {
+        return await this.program.rpc.updatePerpMarketOracle(oracle, oracleSource, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+                oracle: oracle,
+            },
+        });
+    }
+    async updatePerpMarketStepSizeAndTickSize(perpMarketIndex, stepSize, tickSize) {
+        return await this.program.rpc.updatePerpMarketStepSizeAndTickSize(stepSize, tickSize, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketMinOrderSize(perpMarketIndex, orderSize) {
+        return await this.program.rpc.updatePerpMarketMinOrderSize(orderSize, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketStepSizeAndTickSize(spotMarketIndex, stepSize, tickSize) {
+        return await this.program.rpc.updateSpotMarketStepSizeAndTickSize(stepSize, tickSize, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketMinOrderSize(spotMarketIndex, orderSize) {
+        return await this.program.rpc.updateSpotMarketMinOrderSize(orderSize, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketExpiry(perpMarketIndex, expiryTs) {
+        return await this.program.rpc.updatePerpMarketExpiry(expiryTs, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketOracle(spotMarketIndex, 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, spotMarketIndex),
+                oracle: oracle,
+            },
+        });
+    }
+    async updateSpotMarketExpiry(spotMarketIndex, expiryTs) {
+        return await this.program.rpc.updateSpotMarketExpiry(expiryTs, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    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 updateSpotMarketMarginWeights(spotMarketIndex, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0) {
+        return await this.program.rpc.updateSpotMarketMarginWeights(initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketBorrowRate(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate) {
+        return await this.program.rpc.updateSpotMarketBorrowRate(optimalUtilization, optimalBorrowRate, optimalMaxRate, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketAssetTier(spotMarketIndex, assetTier) {
+        return await this.program.rpc.updateSpotMarketAssetTier(assetTier, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketStatus(spotMarketIndex, marketStatus) {
+        return await this.program.rpc.updateSpotMarketStatus(marketStatus, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketStatus(perpMarketIndex, marketStatus) {
+        return await this.program.rpc.updatePerpMarketStatus(marketStatus, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketContractTier(perpMarketIndex, contractTier) {
+        return await this.program.rpc.updatePerpMarketContractTier(contractTier, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateExchangeStatus(exchangeStatus) {
+        return await this.program.rpc.updateExchangeStatus(exchangeStatus, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updatePerpAuctionDuration(minDuration) {
+        return await this.program.rpc.updatePerpAuctionDuration(typeof minDuration === 'number' ? minDuration : minDuration.toNumber(), {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateSpotAuctionDuration(defaultAuctionDuration) {
+        return await this.program.rpc.updateSpotAuctionDuration(defaultAuctionDuration, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updatePerpMarketMaxFillReserveFraction(perpMarketIndex, maxBaseAssetAmountRatio) {
+        return await this.program.rpc.updatePerpMarketMaxFillReserveFraction(maxBaseAssetAmountRatio, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateMaxSlippageRatio(perpMarketIndex, maxSlippageRatio) {
+        return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: this.getPerpMarketAccount(perpMarketIndex).pubkey,
+            },
+        });
+    }
+    async updatePerpMarketUnrealizedAssetWeight(perpMarketIndex, unrealizedInitialAssetWeight, unrealizedMaintenanceAssetWeight) {
+        return await this.program.rpc.updatePerpMarketUnrealizedAssetWeight(unrealizedInitialAssetWeight, unrealizedMaintenanceAssetWeight, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketMaxImbalances(perpMarketIndex, unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance) {
+        return await this.program.rpc.updatePerpMarketMaxImbalances(unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketMaxOpenInterest(perpMarketIndex, maxOpenInterest) {
+        return await this.program.rpc.updatePerpMarketMaxOpenInterest(maxOpenInterest, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateSerumVault(srmVault) {
+        return await this.program.rpc.updateSerumVault({
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                srmVault: srmVault,
+            },
+        });
+    }
+    async updatePerpMarketLiquidationFee(perpMarketIndex, liquidatorFee, ifLiquidationFee) {
+        return await this.program.rpc.updatePerpMarketLiquidationFee(liquidatorFee, ifLiquidationFee, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketLiquidationFee(spotMarketIndex, liquidatorFee, ifLiquidationFee) {
+        return await this.program.rpc.updateSpotMarketLiquidationFee(liquidatorFee, ifLiquidationFee, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+}
+exports.AdminClient = AdminClient;

package/lib/config.d.ts

@@ -1,15 +1,15 @@
-/// <reference types="bn.js" />
-import { MarketConfig } from './constants/markets';
-import { BankConfig } from './constants/banks';
-import { BN } from '@project-serum/anchor';
+import { PerpMarketConfig } from './constants/perpMarkets';
+import { SpotMarketConfig } from './constants/spotMarkets';
 import { OracleInfo } from './oracles/types';
 declare type DriftConfig = {
     ENV: DriftEnv;
     PYTH_ORACLE_MAPPING_ADDRESS: string;
-    CLEARING_HOUSE_PROGRAM_ID: string;
+    DRIFT_PROGRAM_ID: string;
     USDC_MINT_ADDRESS: string;
-    MARKETS: MarketConfig[];
-    BANKS: BankConfig[];
+    SERUM_V3: string;
+    V2_ALPHA_TICKET_MINT_ADDRESS: string;
+    PERP_MARKETS: PerpMarketConfig[];
+    SPOT_MARKETS: SpotMarketConfig[];
 };
 export declare type DriftEnv = 'devnet' | 'mainnet-beta';
 export declare const configs: {
@@ -27,9 +27,9 @@ export declare const initialize: (props: {
     env: DriftEnv;
     overrideEnv?: Partial<DriftConfig>;
 }) => DriftConfig;
-export declare function getMarketsBanksAndOraclesForSubscription(env: DriftEnv): {
-    marketIndexes: BN[];
-    bankIndexes: BN[];
+export declare function getMarketsAndOraclesForSubscription(env: DriftEnv): {
+    perpMarketIndexes: number[];
+    spotMarketIndexes: number[];
     oracleInfos: OracleInfo[];
 };
 export {};