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

package/lib/accounts/webSocketClearingHouseAccountSubscriber.js

@@ -9,17 +9,17 @@ const web3_js_1 = require("@solana/web3.js");
 const oracleClientCache_1 = require("../oracles/oracleClientCache");
 const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
 class WebSocketClearingHouseAccountSubscriber {
-    constructor(program, marketIndexes, bankIndexes, oracleInfos) {
+    constructor(program, perpMarketIndexes, spotMarketIndexes, oracleInfos) {
         this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
-        this.marketAccountSubscribers = new Map();
-        this.bankAccountSubscribers = new Map();
+        this.perpMarketAccountSubscribers = new Map();
+        this.spotMarketAccountSubscribers = new Map();
         this.oracleSubscribers = new Map();
         this.isSubscribing = false;
         this.isSubscribed = false;
         this.program = program;
         this.eventEmitter = new events_1.EventEmitter();
-        this.marketIndexes = marketIndexes;
-        this.bankIndexes = bankIndexes;
+        this.perpMarketIndexes = perpMarketIndexes;
+        this.spotMarketIndexes = spotMarketIndexes;
         this.oracleInfos = oracleInfos;
     }
     async subscribe() {
@@ -42,8 +42,8 @@ class WebSocketClearingHouseAccountSubscriber {
         });
         // subscribe to market accounts
         await this.subscribeToMarketAccounts();
-        // subscribe to bank accounts
-        await this.subscribeToBankAccounts();
+        // subscribe to spot market accounts
+        await this.subscribeToSpotMarketAccounts();
         // subscribe to oracles
         await this.subscribeToOracles();
         this.eventEmitter.emit('update');
@@ -53,35 +53,35 @@ class WebSocketClearingHouseAccountSubscriber {
         return true;
     }
     async subscribeToMarketAccounts() {
-        for (const marketIndex of this.marketIndexes) {
+        for (const marketIndex of this.perpMarketIndexes) {
             await this.subscribeToMarketAccount(marketIndex);
         }
         return true;
     }
     async subscribeToMarketAccount(marketIndex) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('market', this.program, marketPublicKey);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('perpMarket', this.program, marketPublicKey);
         await accountSubscriber.subscribe((data) => {
-            this.eventEmitter.emit('marketAccountUpdate', data);
+            this.eventEmitter.emit('perpMarketAccountUpdate', data);
             this.eventEmitter.emit('update');
         });
-        this.marketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
+        this.perpMarketAccountSubscribers.set(marketIndex, accountSubscriber);
         return true;
     }
-    async subscribeToBankAccounts() {
-        for (const bankIndex of this.bankIndexes) {
-            await this.subscribeToBankAccount(bankIndex);
+    async subscribeToSpotMarketAccounts() {
+        for (const marketIndex of this.spotMarketIndexes) {
+            await this.subscribeToSpotMarketAccount(marketIndex);
         }
         return true;
     }
-    async subscribeToBankAccount(bankIndex) {
-        const bankPublicKey = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
-        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('bank', this.program, bankPublicKey);
+    async subscribeToSpotMarketAccount(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('spotMarket', this.program, marketPublicKey);
         await accountSubscriber.subscribe((data) => {
-            this.eventEmitter.emit('bankAccountUpdate', data);
+            this.eventEmitter.emit('spotMarketAccountUpdate', data);
             this.eventEmitter.emit('update');
         });
-        this.bankAccountSubscribers.set(bankIndex.toNumber(), accountSubscriber);
+        this.spotMarketAccountSubscribers.set(marketIndex, accountSubscriber);
         return true;
     }
     async subscribeToOracles() {
@@ -105,12 +105,12 @@ class WebSocketClearingHouseAccountSubscriber {
         return true;
     }
     async unsubscribeFromMarketAccounts() {
-        for (const accountSubscriber of this.marketAccountSubscribers.values()) {
+        for (const accountSubscriber of this.perpMarketAccountSubscribers.values()) {
             await accountSubscriber.unsubscribe();
         }
     }
-    async unsubscribeFromBankAccounts() {
-        for (const accountSubscriber of this.bankAccountSubscribers.values()) {
+    async unsubscribeFromSpotMarketAccounts() {
+        for (const accountSubscriber of this.spotMarketAccountSubscribers.values()) {
             await accountSubscriber.unsubscribe();
         }
     }
@@ -124,8 +124,8 @@ class WebSocketClearingHouseAccountSubscriber {
             return;
         }
         const promises = [this.stateAccountSubscriber.fetch()]
-            .concat(Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()))
-            .concat(Array.from(this.bankAccountSubscribers.values()).map((subscriber) => subscriber.fetch()));
+            .concat(Array.from(this.perpMarketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()))
+            .concat(Array.from(this.spotMarketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()));
         await Promise.all(promises);
     }
     async unsubscribe() {
@@ -134,18 +134,18 @@ class WebSocketClearingHouseAccountSubscriber {
         }
         await this.stateAccountSubscriber.unsubscribe();
         await this.unsubscribeFromMarketAccounts();
-        await this.unsubscribeFromBankAccounts();
+        await this.unsubscribeFromSpotMarketAccounts();
         await this.unsubscribeFromOracles();
         this.isSubscribed = false;
     }
-    async addBank(bankIndex) {
-        if (this.bankAccountSubscribers.has(bankIndex.toNumber())) {
+    async addSpotMarket(marketIndex) {
+        if (this.spotMarketAccountSubscribers.has(marketIndex)) {
             return true;
         }
-        return this.subscribeToBankAccount(bankIndex);
+        return this.subscribeToSpotMarketAccount(marketIndex);
     }
-    async addMarket(marketIndex) {
-        if (this.marketAccountSubscribers.has(marketIndex.toNumber())) {
+    async addPerpMarket(marketIndex) {
+        if (this.perpMarketAccountSubscribers.has(marketIndex)) {
             return true;
         }
         return this.subscribeToMarketAccount(marketIndex);
@@ -170,15 +170,17 @@ class WebSocketClearingHouseAccountSubscriber {
     }
     getMarketAccountAndSlot(marketIndex) {
         this.assertIsSubscribed();
-        return this.marketAccountSubscribers.get(marketIndex.toNumber())
-            .dataAndSlot;
+        return this.perpMarketAccountSubscribers.get(marketIndex).dataAndSlot;
     }
     getMarketAccountsAndSlots() {
-        return Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
+        return Array.from(this.perpMarketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
     }
-    getBankAccountAndSlot(bankIndex) {
+    getSpotMarketAccountAndSlot(marketIndex) {
         this.assertIsSubscribed();
-        return this.bankAccountSubscribers.get(bankIndex.toNumber()).dataAndSlot;
+        return this.spotMarketAccountSubscribers.get(marketIndex).dataAndSlot;
+    }
+    getSpotMarketAccountsAndSlots() {
+        return Array.from(this.spotMarketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
     }
     getOraclePriceDataAndSlot(oraclePublicKey) {
         this.assertIsSubscribed();

package/lib/accounts/webSocketUserStatsAccountSubsriber.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { DataAndSlot, AccountSubscriber, UserStatsAccountSubscriber, UserStatsAccountEvents } from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { UserStatsAccount } from '../types';
+export declare class WebSocketUserStatsAccountSubscriber implements UserStatsAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+    userStatsAccountPublicKey: PublicKey;
+    userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
+    constructor(program: Program, userStatsAccountPublicKey: PublicKey);
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}

package/lib/accounts/webSocketUserStatsAccountSubsriber.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketUserStatsAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+class WebSocketUserStatsAccountSubscriber {
+    constructor(program, userStatsAccountPublicKey) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.userStatsAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('userStats', this.program, this.userStatsAccountPublicKey);
+        await this.userStatsAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('userStatsAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+    async fetch() {
+        await Promise.all([this.userStatsAccountSubscriber.fetch()]);
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await Promise.all([this.userStatsAccountSubscriber.unsubscribe()]);
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserStatsAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.userStatsAccountSubscriber.dataAndSlot;
+    }
+}
+exports.WebSocketUserStatsAccountSubscriber = WebSocketUserStatsAccountSubscriber;

package/lib/addresses/marketAddresses.d.ts

@@ -1,4 +1,2 @@
-/// <reference types="bn.js" />
 import { PublicKey } from '@solana/web3.js';
-import { BN } from '@project-serum/anchor';
-export declare function getMarketAddress(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
+export declare function getMarketAddress(programId: PublicKey, marketIndex: number): Promise<PublicKey>;

package/lib/addresses/pda.d.ts

@@ -6,7 +6,13 @@ export declare function getClearingHouseStateAccountPublicKey(programId: PublicK
 export declare function getUserAccountPublicKeyAndNonce(programId: PublicKey, authority: PublicKey, userId?: number): Promise<[PublicKey, number]>;
 export declare function getUserAccountPublicKey(programId: PublicKey, authority: PublicKey, userId?: number): Promise<PublicKey>;
 export declare function getUserAccountPublicKeySync(programId: PublicKey, authority: PublicKey, userId?: number): PublicKey;
-export declare function getMarketPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
-export declare function getBankPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
-export declare function getBankVaultPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
-export declare function getBankVaultAuthorityPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
+export declare function getUserStatsAccountPublicKey(programId: PublicKey, authority: PublicKey): PublicKey;
+export declare function getMarketPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getSpotMarketPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getSpotMarketVaultPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getInsuranceFundVaultPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getInsuranceFundStakeAccountPublicKey(programId: PublicKey, authority: PublicKey, marketIndex: number): PublicKey;
+export declare function getClearingHouseSignerPublicKey(programId: PublicKey): PublicKey;
+export declare function getSerumOpenOrdersPublicKey(programId: PublicKey, market: PublicKey): PublicKey;
+export declare function getSerumSignerPublicKey(programId: PublicKey, market: PublicKey, nonce: BN): PublicKey;
+export declare function getSerumFulfillmentConfigPublicKey(programId: PublicKey, market: PublicKey): PublicKey;

package/lib/addresses/pda.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBankVaultAuthorityPublicKey = exports.getBankVaultPublicKey = exports.getBankPublicKey = exports.getMarketPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
+exports.getSerumFulfillmentConfigPublicKey = exports.getSerumSignerPublicKey = exports.getSerumOpenOrdersPublicKey = exports.getClearingHouseSignerPublicKey = exports.getInsuranceFundStakeAccountPublicKey = exports.getInsuranceFundVaultPublicKey = exports.getSpotMarketVaultPublicKey = exports.getSpotMarketPublicKey = exports.getMarketPublicKey = exports.getUserStatsAccountPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
 const anchor = __importStar(require("@project-serum/anchor"));
 async function getClearingHouseStateAccountPublicKeyAndNonce(programId) {
     return anchor.web3.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house'))], programId);
@@ -53,31 +53,68 @@ function getUserAccountPublicKeySync(programId, authority, userId = 0) {
     ], programId)[0];
 }
 exports.getUserAccountPublicKeySync = getUserAccountPublicKeySync;
+function getUserStatsAccountPublicKey(programId, authority) {
+    return anchor.web3.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('user_stats')),
+        authority.toBuffer(),
+    ], programId)[0];
+}
+exports.getUserStatsAccountPublicKey = getUserStatsAccountPublicKey;
 async function getMarketPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('market')),
-        marketIndex.toArrayLike(Buffer, 'le', 8),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
 exports.getMarketPublicKey = getMarketPublicKey;
-async function getBankPublicKey(programId, bankIndex) {
+async function getSpotMarketPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
-        Buffer.from(anchor.utils.bytes.utf8.encode('bank')),
-        bankIndex.toArrayLike(Buffer, 'le', 8),
+        Buffer.from(anchor.utils.bytes.utf8.encode('spot_market')),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
-exports.getBankPublicKey = getBankPublicKey;
-async function getBankVaultPublicKey(programId, bankIndex) {
+exports.getSpotMarketPublicKey = getSpotMarketPublicKey;
+async function getSpotMarketVaultPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
-        Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault')),
-        bankIndex.toArrayLike(Buffer, 'le', 8),
+        Buffer.from(anchor.utils.bytes.utf8.encode('spot_market_vault')),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
-exports.getBankVaultPublicKey = getBankVaultPublicKey;
-async function getBankVaultAuthorityPublicKey(programId, bankIndex) {
+exports.getSpotMarketVaultPublicKey = getSpotMarketVaultPublicKey;
+async function getInsuranceFundVaultPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
-        Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault_authority')),
-        bankIndex.toArrayLike(Buffer, 'le', 8),
+        Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault')),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
-exports.getBankVaultAuthorityPublicKey = getBankVaultAuthorityPublicKey;
+exports.getInsuranceFundVaultPublicKey = getInsuranceFundVaultPublicKey;
+function getInsuranceFundStakeAccountPublicKey(programId, authority, marketIndex) {
+    return anchor.web3.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_stake')),
+        authority.toBuffer(),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+    ], programId)[0];
+}
+exports.getInsuranceFundStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey;
+function getClearingHouseSignerPublicKey(programId) {
+    return anchor.web3.PublicKey.findProgramAddressSync([Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house_signer'))], programId)[0];
+}
+exports.getClearingHouseSignerPublicKey = getClearingHouseSignerPublicKey;
+function getSerumOpenOrdersPublicKey(programId, market) {
+    return anchor.web3.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('serum_open_orders')),
+        market.toBuffer(),
+    ], programId)[0];
+}
+exports.getSerumOpenOrdersPublicKey = getSerumOpenOrdersPublicKey;
+function getSerumSignerPublicKey(programId, market, nonce) {
+    return anchor.web3.PublicKey.createProgramAddressSync([market.toBuffer(), nonce.toArrayLike(Buffer, 'le', 8)], programId);
+}
+exports.getSerumSignerPublicKey = getSerumSignerPublicKey;
+function getSerumFulfillmentConfigPublicKey(programId, market) {
+    return anchor.web3.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('serum_fulfillment_config')),
+        market.toBuffer(),
+    ], programId)[0];
+}
+exports.getSerumFulfillmentConfigPublicKey = getSerumFulfillmentConfigPublicKey;

package/lib/admin.d.ts

@@ -1,42 +1,58 @@
 /// <reference types="bn.js" />
 import { PublicKey, TransactionSignature } from '@solana/web3.js';
-import { FeeStructure, OracleGuardRails, OracleSource, OrderFillerRewardStructure } from './types';
+import { FeeStructure, OracleGuardRails, OracleSource, ExchangeStatus, MarketStatus, ContractTier, AssetTier } from './types';
 import { BN } from '@project-serum/anchor';
 import { ClearingHouse } from './clearingHouse';
 export declare class Admin extends ClearingHouse {
-    initialize(usdcMint: PublicKey, adminControlsPrices: boolean): Promise<[TransactionSignature]>;
-    initializeBank(mint: PublicKey, optimalUtilization: BN, optimalRate: BN, maxRate: BN, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN): Promise<TransactionSignature>;
-    initializeMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioPartial?: number, marginRatioMaintenance?: number): Promise<TransactionSignature>;
-    moveAmmPrice(baseAssetReserve: BN, quoteAssetReserve: BN, marketIndex: BN): Promise<TransactionSignature>;
-    updateK(sqrtK: BN, marketIndex: BN): Promise<TransactionSignature>;
-    moveAmmToPrice(marketIndex: BN, targetPrice: BN): Promise<TransactionSignature>;
-    repegAmmCurve(newPeg: BN, marketIndex: BN): Promise<TransactionSignature>;
-    updateAmmOracleTwap(marketIndex: BN): Promise<TransactionSignature>;
-    resetAmmOracleTwap(marketIndex: BN): Promise<TransactionSignature>;
-    withdrawFromInsuranceVault(amount: BN, recipient: PublicKey): Promise<TransactionSignature>;
-    withdrawFees(marketIndex: BN, amount: BN, recipient: PublicKey): Promise<TransactionSignature>;
-    withdrawFromInsuranceVaultToMarket(marketIndex: BN, amount: BN): Promise<TransactionSignature>;
+    initialize(usdcMint: PublicKey, _adminControlsPrices: boolean): Promise<[TransactionSignature]>;
+    initializeSpotMarket(mint: PublicKey, optimalUtilization: number, optimalRate: number, maxRate: number, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN, liquidationFee?: BN, activeStatus?: boolean): Promise<TransactionSignature>;
+    initializeSerumFulfillmentConfig(marketIndex: number, serumMarket: PublicKey, serumProgram: PublicKey): Promise<TransactionSignature>;
+    initializeMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidationFee?: BN, activeStatus?: boolean): Promise<TransactionSignature>;
+    moveAmmPrice(marketIndex: number, baseAssetReserve: BN, quoteAssetReserve: BN, sqrtK?: BN): Promise<TransactionSignature>;
+    updateK(sqrtK: BN, marketIndex: number): Promise<TransactionSignature>;
+    updateConcentrationScale(marketIndex: number, concentrationScale: BN): Promise<TransactionSignature>;
+    moveAmmToPrice(perpMarketIndex: number, targetPrice: BN): Promise<TransactionSignature>;
+    repegAmmCurve(newPeg: BN, marketIndex: number): Promise<TransactionSignature>;
+    updateAmmOracleTwap(marketIndex: number): Promise<TransactionSignature>;
+    resetAmmOracleTwap(marketIndex: number): Promise<TransactionSignature>;
+    depositIntoMarketFeePool(marketIndex: number, amount: BN, sourceVault: PublicKey): Promise<TransactionSignature>;
     updateAdmin(admin: PublicKey): Promise<TransactionSignature>;
-    updateCurveUpdateIntensity(marketIndex: BN, curveUpdateIntensity: number): Promise<TransactionSignature>;
-    updateMarginRatio(marketIndex: BN, marginRatioInitial: number, marginRatioPartial: number, marginRatioMaintenance: number): Promise<TransactionSignature>;
-    updateMarketBaseSpread(marketIndex: BN, baseSpread: number): Promise<TransactionSignature>;
-    updateMarketMaxSpread(marketIndex: BN, maxSpread: number): Promise<TransactionSignature>;
+    updateCurveUpdateIntensity(marketIndex: number, curveUpdateIntensity: number): Promise<TransactionSignature>;
+    updateMarginRatio(marketIndex: number, marginRatioInitial: number, marginRatioMaintenance: number): Promise<TransactionSignature>;
+    updateMarketBaseSpread(marketIndex: number, baseSpread: number): Promise<TransactionSignature>;
+    updateAmmJitIntensity(marketIndex: number, ammJitIntensity: number): Promise<TransactionSignature>;
+    updateMarketMaxSpread(marketIndex: number, maxSpread: number): Promise<TransactionSignature>;
     updatePartialLiquidationClosePercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
     updatePartialLiquidationPenaltyPercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
     updateFullLiquidationPenaltyPercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
     updatePartialLiquidationShareDenominator(denominator: BN): Promise<TransactionSignature>;
     updateFullLiquidationShareDenominator(denominator: BN): Promise<TransactionSignature>;
-    updateOrderFillerRewardStructure(orderFillerRewardStructure: OrderFillerRewardStructure): Promise<TransactionSignature>;
-    updateFee(fees: FeeStructure): Promise<TransactionSignature>;
+    updatePerpFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
+    updateSpotFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
     updateOracleGuardRails(oracleGuardRails: OracleGuardRails): Promise<TransactionSignature>;
-    updateMarketOracle(marketIndex: BN, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
-    updateMarketMinimumQuoteAssetTradeSize(marketIndex: BN, minimumTradeSize: BN): Promise<TransactionSignature>;
-    updateMarketBaseAssetAmountStepSize(marketIndex: BN, stepSize: BN): Promise<TransactionSignature>;
+    updateWithdrawGuardThreshold(marketIndex: number, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
+    updateSpotMarketIfFactor(marketIndex: number, userIfFactor: BN, totalIfFactor: BN): Promise<TransactionSignature>;
+    updateSpotMarketRevenueSettlePeriod(marketIndex: number, revenueSettlePeriod: BN): Promise<TransactionSignature>;
+    updateSpotMarketMaxTokenDeposits(marketIndex: number, maxTokenDeposits: BN): Promise<TransactionSignature>;
+    updateInsuranceWithdrawEscrowPeriod(marketIndex: number, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
+    updateLpCooldownTime(marketIndex: number, cooldownTime: BN): Promise<TransactionSignature>;
+    updateMarketOracle(marketIndex: number, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
+    updateMarketMinimumQuoteAssetTradeSize(marketIndex: number, minimumTradeSize: BN): Promise<TransactionSignature>;
+    updateMarketBaseAssetAmountStepSize(marketIndex: number, stepSize: BN): Promise<TransactionSignature>;
+    updateMarketExpiry(perpMarketIndex: number, expiryTs: BN): Promise<TransactionSignature>;
     updateWhitelistMint(whitelistMint?: PublicKey): Promise<TransactionSignature>;
     updateDiscountMint(discountMint: PublicKey): Promise<TransactionSignature>;
     updateMaxDeposit(maxDeposit: BN): Promise<TransactionSignature>;
-    updateFundingPaused(fundingPaused: boolean): Promise<TransactionSignature>;
-    updateExchangePaused(exchangePaused: boolean): Promise<TransactionSignature>;
-    disableAdminControlsPrices(): Promise<TransactionSignature>;
-    updateOrderAuctionTime(time: BN | number): Promise<TransactionSignature>;
+    updateSpotMarketMarginWeights(spotMarketIndex: number, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN): Promise<TransactionSignature>;
+    updateSpotMarketAssetTier(spotMarketIndex: number, assetTier: AssetTier): Promise<TransactionSignature>;
+    updateSpotMarketStatus(spotMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionSignature>;
+    updatePerpMarketStatus(perpMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionSignature>;
+    updatePerpMarketContractTier(perpMarketIndex: number, contractTier: ContractTier): Promise<TransactionSignature>;
+    updateExchangeStatus(exchangeStatus: ExchangeStatus): Promise<TransactionSignature>;
+    updatePerpAuctionDuration(minDuration: BN | number): Promise<TransactionSignature>;
+    updateSpotAuctionDuration(defaultAuctionDuration: number): Promise<TransactionSignature>;
+    updateMaxBaseAssetAmountRatio(marketIndex: number, maxBaseAssetAmountRatio: number): Promise<TransactionSignature>;
+    updateMaxSlippageRatio(marketIndex: number, maxSlippageRatio: number): Promise<TransactionSignature>;
+    updateMarketMaxImbalances(marketIndex: number, unrealizedMaxImbalance: BN, maxRevenueWithdrawPerPeriod: BN, quoteMaxInsurance: BN): Promise<TransactionSignature>;
+    updateSerumVault(srmVault: PublicKey): Promise<TransactionSignature>;
 }