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

package/lib/accounts/bulkAccountLoader.js

@@ -162,7 +162,8 @@ class BulkAccountLoader {
         if (this.intervalId) {
             return;
         }
-        this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
+        if (this.pollingFrequency !== 0)
+            this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
     }
     stopPolling() {
         if (this.intervalId) {

package/lib/accounts/pollingClearingHouseAccountSubscriber.d.ts

@@ -31,8 +31,8 @@ export declare class PollingClearingHouseAccountSubscriber implements ClearingHo
     constructor(program: Program, accountLoader: BulkAccountLoader, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[]);
     subscribe(): Promise<boolean>;
     updateAccountsToPoll(): Promise<void>;
-    updateMarketAccountsToPoll(): Promise<boolean>;
-    addMarketAccountToPoll(marketIndex: number): Promise<boolean>;
+    updatePerpMarketAccountsToPoll(): Promise<boolean>;
+    addPerpMarketAccountToPoll(marketIndex: number): Promise<boolean>;
     updateSpotMarketAccountsToPoll(): Promise<boolean>;
     addSpotMarketAccountToPoll(marketIndex: number): Promise<boolean>;
     updateOraclesToPoll(): boolean;

package/lib/accounts/pollingClearingHouseAccountSubscriber.js

@@ -64,20 +64,20 @@ class PollingClearingHouseAccountSubscriber {
             publicKey: accounts.state,
             eventType: 'stateAccountUpdate',
         });
-        await this.updateMarketAccountsToPoll();
+        await this.updatePerpMarketAccountsToPoll();
         await this.updateSpotMarketAccountsToPoll();
     }
-    async updateMarketAccountsToPoll() {
+    async updatePerpMarketAccountsToPoll() {
         for (const marketIndex of this.perpMarketIndexes) {
-            await this.addMarketAccountToPoll(marketIndex);
+            await this.addPerpMarketAccountToPoll(marketIndex);
         }
         return true;
     }
-    async addMarketAccountToPoll(marketIndex) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        this.accountsToPoll.set(marketPublicKey.toString(), {
+    async addPerpMarketAccountToPoll(marketIndex) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        this.accountsToPoll.set(perpMarketPublicKey.toString(), {
             key: 'perpMarket',
-            publicKey: marketPublicKey,
+            publicKey: perpMarketPublicKey,
             eventType: 'perpMarketAccountUpdate',
             mapKey: marketIndex,
         });
@@ -230,7 +230,7 @@ class PollingClearingHouseAccountSubscriber {
         return true;
     }
     async addPerpMarket(marketIndex) {
-        await this.addMarketAccountToPoll(marketIndex);
+        await this.addPerpMarketAccountToPoll(marketIndex);
         const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
         this.addAccountToAccountLoader(accountToPoll);
         return true;

package/lib/accounts/types.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { SpotMarketAccount, PerpMarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';

package/lib/accounts/webSocketClearingHouseAccountSubscriber.d.ts

@@ -25,8 +25,8 @@ export declare class WebSocketClearingHouseAccountSubscriber implements Clearing
     private subscriptionPromiseResolver;
     constructor(program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[]);
     subscribe(): Promise<boolean>;
-    subscribeToMarketAccounts(): Promise<boolean>;
-    subscribeToMarketAccount(marketIndex: number): Promise<boolean>;
+    subscribeToPerpMarketAccounts(): Promise<boolean>;
+    subscribeToPerpMarketAccount(marketIndex: number): Promise<boolean>;
     subscribeToSpotMarketAccounts(): Promise<boolean>;
     subscribeToSpotMarketAccount(marketIndex: number): Promise<boolean>;
     subscribeToOracles(): Promise<boolean>;

package/lib/accounts/webSocketClearingHouseAccountSubscriber.js

@@ -41,7 +41,7 @@ class WebSocketClearingHouseAccountSubscriber {
             this.eventEmitter.emit('update');
         });
         // subscribe to market accounts
-        await this.subscribeToMarketAccounts();
+        await this.subscribeToPerpMarketAccounts();
         // subscribe to spot market accounts
         await this.subscribeToSpotMarketAccounts();
         // subscribe to oracles
@@ -52,15 +52,15 @@ class WebSocketClearingHouseAccountSubscriber {
         this.subscriptionPromiseResolver(true);
         return true;
     }
-    async subscribeToMarketAccounts() {
+    async subscribeToPerpMarketAccounts() {
         for (const marketIndex of this.perpMarketIndexes) {
-            await this.subscribeToMarketAccount(marketIndex);
+            await this.subscribeToPerpMarketAccount(marketIndex);
         }
         return true;
     }
-    async subscribeToMarketAccount(marketIndex) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('perpMarket', this.program, marketPublicKey);
+    async subscribeToPerpMarketAccount(marketIndex) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('perpMarket', this.program, perpMarketPublicKey);
         await accountSubscriber.subscribe((data) => {
             this.eventEmitter.emit('perpMarketAccountUpdate', data);
             this.eventEmitter.emit('update');
@@ -148,7 +148,7 @@ class WebSocketClearingHouseAccountSubscriber {
         if (this.perpMarketAccountSubscribers.has(marketIndex)) {
             return true;
         }
-        return this.subscribeToMarketAccount(marketIndex);
+        return this.subscribeToPerpMarketAccount(marketIndex);
     }
     async addOracle(oracleInfo) {
         if (this.oracleSubscribers.has(oracleInfo.publicKey.toString())) {

package/lib/addresses/marketAddresses.js

@@ -8,7 +8,7 @@ async function getMarketAddress(programId, marketIndex) {
     if (CACHE.has(cacheKey)) {
         return CACHE.get(cacheKey);
     }
-    const publicKey = await (0, pda_1.getMarketPublicKey)(programId, marketIndex);
+    const publicKey = await (0, pda_1.getPerpMarketPublicKey)(programId, marketIndex);
     CACHE.set(cacheKey, publicKey);
     return publicKey;
 }

package/lib/addresses/pda.d.ts

@@ -3,11 +3,11 @@ import { PublicKey } from '@solana/web3.js';
 import { BN } from '@project-serum/anchor';
 export declare function getClearingHouseStateAccountPublicKeyAndNonce(programId: PublicKey): Promise<[PublicKey, number]>;
 export declare function getClearingHouseStateAccountPublicKey(programId: PublicKey): Promise<PublicKey>;
-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 getUserAccountPublicKeyAndNonce(programId: PublicKey, authority: PublicKey, subAccountId?: number): Promise<[PublicKey, number]>;
+export declare function getUserAccountPublicKey(programId: PublicKey, authority: PublicKey, subAccountId?: number): Promise<PublicKey>;
+export declare function getUserAccountPublicKeySync(programId: PublicKey, authority: PublicKey, subAccountId?: number): PublicKey;
 export declare function getUserStatsAccountPublicKey(programId: PublicKey, authority: PublicKey): PublicKey;
-export declare function getMarketPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getPerpMarketPublicKey(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>;

package/lib/addresses/pda.js

@@ -23,73 +23,74 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.getSerumFulfillmentConfigPublicKey = exports.getSerumSignerPublicKey = exports.getSerumOpenOrdersPublicKey = exports.getClearingHouseSignerPublicKey = exports.getInsuranceFundStakeAccountPublicKey = exports.getInsuranceFundVaultPublicKey = exports.getSpotMarketVaultPublicKey = exports.getSpotMarketPublicKey = exports.getPerpMarketPublicKey = exports.getUserStatsAccountPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
+const web3_js_1 = require("@solana/web3.js");
 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);
+    return web3_js_1.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house'))], programId);
 }
 exports.getClearingHouseStateAccountPublicKeyAndNonce = getClearingHouseStateAccountPublicKeyAndNonce;
 async function getClearingHouseStateAccountPublicKey(programId) {
     return (await getClearingHouseStateAccountPublicKeyAndNonce(programId))[0];
 }
 exports.getClearingHouseStateAccountPublicKey = getClearingHouseStateAccountPublicKey;
-async function getUserAccountPublicKeyAndNonce(programId, authority, userId = 0) {
-    return anchor.web3.PublicKey.findProgramAddress([
+async function getUserAccountPublicKeyAndNonce(programId, authority, subAccountId = 0) {
+    return web3_js_1.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('user')),
         authority.toBuffer(),
-        Uint8Array.from([userId]),
+        Uint8Array.from([subAccountId]),
     ], programId);
 }
 exports.getUserAccountPublicKeyAndNonce = getUserAccountPublicKeyAndNonce;
-async function getUserAccountPublicKey(programId, authority, userId = 0) {
-    return (await getUserAccountPublicKeyAndNonce(programId, authority, userId))[0];
+async function getUserAccountPublicKey(programId, authority, subAccountId = 0) {
+    return (await getUserAccountPublicKeyAndNonce(programId, authority, subAccountId))[0];
 }
 exports.getUserAccountPublicKey = getUserAccountPublicKey;
-function getUserAccountPublicKeySync(programId, authority, userId = 0) {
-    return anchor.web3.PublicKey.findProgramAddressSync([
+function getUserAccountPublicKeySync(programId, authority, subAccountId = 0) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
         Buffer.from(anchor.utils.bytes.utf8.encode('user')),
         authority.toBuffer(),
-        Uint8Array.from([userId]),
+        Uint8Array.from([subAccountId]),
     ], programId)[0];
 }
 exports.getUserAccountPublicKeySync = getUserAccountPublicKeySync;
 function getUserStatsAccountPublicKey(programId, authority) {
-    return anchor.web3.PublicKey.findProgramAddressSync([
+    return web3_js_1.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')),
+async function getPerpMarketPublicKey(programId, marketIndex) {
+    return (await web3_js_1.PublicKey.findProgramAddress([
+        Buffer.from(anchor.utils.bytes.utf8.encode('perp_market')),
         new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
-exports.getMarketPublicKey = getMarketPublicKey;
+exports.getPerpMarketPublicKey = getPerpMarketPublicKey;
 async function getSpotMarketPublicKey(programId, marketIndex) {
-    return (await anchor.web3.PublicKey.findProgramAddress([
+    return (await web3_js_1.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('spot_market')),
         new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
 exports.getSpotMarketPublicKey = getSpotMarketPublicKey;
 async function getSpotMarketVaultPublicKey(programId, marketIndex) {
-    return (await anchor.web3.PublicKey.findProgramAddress([
+    return (await web3_js_1.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('spot_market_vault')),
         new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
 exports.getSpotMarketVaultPublicKey = getSpotMarketVaultPublicKey;
 async function getInsuranceFundVaultPublicKey(programId, marketIndex) {
-    return (await anchor.web3.PublicKey.findProgramAddress([
+    return (await web3_js_1.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault')),
         new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
 exports.getInsuranceFundVaultPublicKey = getInsuranceFundVaultPublicKey;
 function getInsuranceFundStakeAccountPublicKey(programId, authority, marketIndex) {
-    return anchor.web3.PublicKey.findProgramAddressSync([
+    return web3_js_1.PublicKey.findProgramAddressSync([
         Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_stake')),
         authority.toBuffer(),
         new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
@@ -97,11 +98,11 @@ function getInsuranceFundStakeAccountPublicKey(programId, authority, marketIndex
 }
 exports.getInsuranceFundStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey;
 function getClearingHouseSignerPublicKey(programId) {
-    return anchor.web3.PublicKey.findProgramAddressSync([Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house_signer'))], programId)[0];
+    return web3_js_1.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([
+    return web3_js_1.PublicKey.findProgramAddressSync([
         Buffer.from(anchor.utils.bytes.utf8.encode('serum_open_orders')),
         market.toBuffer(),
     ], programId)[0];
@@ -112,7 +113,7 @@ function getSerumSignerPublicKey(programId, market, nonce) {
 }
 exports.getSerumSignerPublicKey = getSerumSignerPublicKey;
 function getSerumFulfillmentConfigPublicKey(programId, market) {
-    return anchor.web3.PublicKey.findProgramAddressSync([
+    return web3_js_1.PublicKey.findProgramAddressSync([
         Buffer.from(anchor.utils.bytes.utf8.encode('serum_fulfillment_config')),
         market.toBuffer(),
     ], programId)[0];

package/lib/admin.d.ts

@@ -7,42 +7,40 @@ export declare class Admin extends ClearingHouse {
     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>;
+    initializePerpMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidationFee?: BN, activeStatus?: boolean, name?: string): Promise<TransactionSignature>;
+    moveAmmPrice(perpMarketIndex: number, baseAssetReserve: BN, quoteAssetReserve: BN, sqrtK?: BN): Promise<TransactionSignature>;
+    updateK(perpMarketIndex: number, sqrtK: BN): Promise<TransactionSignature>;
+    updatePerpMarketConcentrationScale(perpMarketIndex: 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>;
+    repegAmmCurve(newPeg: BN, perpMarketIndex: number): Promise<TransactionSignature>;
+    updatePerpMarketAmmOracleTwap(perpMarketIndex: number): Promise<TransactionSignature>;
+    resetPerpMarketAmmOracleTwap(perpMarketIndex: number): Promise<TransactionSignature>;
+    depositIntoPerpMarketFeePool(perpMarketIndex: number, amount: BN, sourceVault: PublicKey): Promise<TransactionSignature>;
     updateAdmin(admin: PublicKey): 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>;
+    updatePerpMarketCurveUpdateIntensity(perpMarketIndex: number, curveUpdateIntensity: number): Promise<TransactionSignature>;
+    updatePerpMarketMarginRatio(perpMarketIndex: number, marginRatioInitial: number, marginRatioMaintenance: number): Promise<TransactionSignature>;
+    updatePerpMarketBaseSpread(perpMarketIndex: number, baseSpread: number): Promise<TransactionSignature>;
+    updateAmmJitIntensity(perpMarketIndex: number, ammJitIntensity: number): Promise<TransactionSignature>;
+    updatePerpMarketName(perpMarketIndex: number, name: string): Promise<TransactionSignature>;
+    updatePerpMarketMaxSpread(perpMarketIndex: number, maxSpread: number): Promise<TransactionSignature>;
     updatePerpFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
     updateSpotFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
     updateOracleGuardRails(oracleGuardRails: OracleGuardRails): 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>;
+    updateStateSettlementDuration(settlementDuration: number): Promise<TransactionSignature>;
+    updateWithdrawGuardThreshold(spotMarketIndex: number, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
+    updateSpotMarketIfFactor(spotMarketIndex: number, userIfFactor: BN, totalIfFactor: BN): Promise<TransactionSignature>;
+    updateSpotMarketRevenueSettlePeriod(spotMarketIndex: number, revenueSettlePeriod: BN): Promise<TransactionSignature>;
+    updateSpotMarketMaxTokenDeposits(spotMarketIndex: number, maxTokenDeposits: BN): Promise<TransactionSignature>;
+    updateInsuranceFundUnstakingPeriod(spotMarketIndex: number, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
+    updateLpCooldownTime(cooldownTime: BN): Promise<TransactionSignature>;
+    updatePerpMarketOracle(perpMarketIndex: number, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
+    updatePerpMarketStepSizeAndTickSize(perpMarketIndex: number, stepSize: BN, tickSize: BN): Promise<TransactionSignature>;
+    updatePerpMarketMinOrderSize(perpMarketIndex: number, orderSize: BN): Promise<TransactionSignature>;
+    updatePerpMarketExpiry(perpMarketIndex: number, expiryTs: BN): Promise<TransactionSignature>;
+    updateSpotMarketOracle(spotMarketIndex: number, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
+    updateSpotMarketExpiry(spotMarketIndex: number, expiryTs: BN): Promise<TransactionSignature>;
     updateWhitelistMint(whitelistMint?: PublicKey): Promise<TransactionSignature>;
     updateDiscountMint(discountMint: PublicKey): Promise<TransactionSignature>;
-    updateMaxDeposit(maxDeposit: BN): 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>;
@@ -51,8 +49,8 @@ export declare class Admin extends ClearingHouse {
     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>;
+    updatePerpMarketMaxFillReserveFraction(perpMarketIndex: number, maxBaseAssetAmountRatio: number): Promise<TransactionSignature>;
+    updateMaxSlippageRatio(perpMarketIndex: number, maxSlippageRatio: number): Promise<TransactionSignature>;
+    updatePerpMarketMaxImbalances(perpMarketIndex: number, unrealizedMaxImbalance: BN, maxRevenueWithdrawPerPeriod: BN, quoteMaxInsurance: BN): Promise<TransactionSignature>;
     updateSerumVault(srmVault: PublicKey): Promise<TransactionSignature>;
 }