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

package/src/admin.ts

@@ -7,27 +7,33 @@ import {
 	FeeStructure,
 	OracleGuardRails,
 	OracleSource,
-	OrderFillerRewardStructure,
+	ExchangeStatus,
+	MarketStatus,
+	ContractTier,
+	AssetTier,
 } from './types';
 import { BN } from '@project-serum/anchor';
 import * as anchor from '@project-serum/anchor';
 import {
 	getClearingHouseStateAccountPublicKeyAndNonce,
-	getBankVaultAuthorityPublicKey,
-	getBankPublicKey,
-	getBankVaultPublicKey,
+	getSpotMarketPublicKey,
+	getSpotMarketVaultPublicKey,
 	getMarketPublicKey,
+	getInsuranceFundVaultPublicKey,
+	getSerumOpenOrdersPublicKey,
+	getSerumFulfillmentConfigPublicKey,
 } from './addresses/pda';
+import { squareRootBN } from './math/utils';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { ClearingHouse } from './clearingHouse';
-import { PEG_PRECISION } from './constants/numericConstants';
+import { PEG_PRECISION, ZERO } from './constants/numericConstants';
 import { calculateTargetPriceTrade } from './math/trade';
 import { calculateAmmReservesAfterSwap, getSwapDirection } from './math/amm';
 
 export class Admin extends ClearingHouse {
 	public async initialize(
 		usdcMint: PublicKey,
-		adminControlsPrices: boolean
+		_adminControlsPrices: boolean
 	): Promise<[TransactionSignature]> {
 		const stateAccountRPCResponse = await this.connection.getParsedAccountInfo(
 			await this.getStatePublicKey()
@@ -36,35 +42,22 @@ export class Admin extends ClearingHouse {
 			throw new Error('Clearing house already initialized');
 		}
 
-		const [insuranceVaultPublicKey] = await PublicKey.findProgramAddress(
-			[Buffer.from(anchor.utils.bytes.utf8.encode('insurance_vault'))],
-			this.program.programId
-		);
-
-		const [insuranceVaultAuthority] = await PublicKey.findProgramAddress(
-			[insuranceVaultPublicKey.toBuffer()],
-			this.program.programId
-		);
-
 		const [clearingHouseStatePublicKey] =
 			await 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: SYSVAR_RENT_PUBKEY,
-					systemProgram: anchor.web3.SystemProgram.programId,
-					tokenProgram: TOKEN_PROGRAM_ID,
-				},
-			}
-		);
+
+		const initializeTx = await this.program.transaction.initialize({
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: clearingHouseStatePublicKey,
+				quoteAssetMint: usdcMint,
+				rent: SYSVAR_RENT_PUBKEY,
+				clearingHouseSigner: this.getSignerPublicKey(),
+				systemProgram: anchor.web3.SystemProgram.programId,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+		});
 
 		const { txSig: initializeTxSig } = await this.txSender.send(
 			initializeTx,
@@ -75,32 +68,38 @@ export class Admin extends ClearingHouse {
 		return [initializeTxSig];
 	}
 
-	public async initializeBank(
+	public async initializeSpotMarket(
 		mint: PublicKey,
-		optimalUtilization: BN,
-		optimalRate: BN,
-		maxRate: BN,
+		optimalUtilization: number,
+		optimalRate: number,
+		maxRate: number,
 		oracle: PublicKey,
 		oracleSource: OracleSource,
 		initialAssetWeight: BN,
 		maintenanceAssetWeight: BN,
 		initialLiabilityWeight: BN,
-		maintenanceLiabilityWeight: BN
+		maintenanceLiabilityWeight: BN,
+		imfFactor = new BN(0),
+		liquidationFee = ZERO,
+		activeStatus = true
 	): Promise<TransactionSignature> {
-		const bankIndex = this.getStateAccount().numberOfBanks;
-		const bank = await getBankPublicKey(this.program.programId, bankIndex);
+		const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
+		const spotMarket = await getSpotMarketPublicKey(
+			this.program.programId,
+			spotMarketIndex
+		);
 
-		const bankVault = await getBankVaultPublicKey(
+		const spotMarketVault = await getSpotMarketVaultPublicKey(
 			this.program.programId,
-			bankIndex
+			spotMarketIndex
 		);
 
-		const bankVaultAuthority = await getBankVaultAuthorityPublicKey(
+		const insuranceFundVault = await getInsuranceFundVaultPublicKey(
 			this.program.programId,
-			bankIndex
+			spotMarketIndex
 		);
 
-		const initializeTx = await this.program.transaction.initializeBank(
+		const initializeTx = await this.program.transaction.initializeSpotMarket(
 			optimalUtilization,
 			optimalRate,
 			maxRate,
@@ -109,14 +108,18 @@ export class Admin extends ClearingHouse {
 			maintenanceAssetWeight,
 			initialLiabilityWeight,
 			maintenanceLiabilityWeight,
+			imfFactor,
+			liquidationFee,
+			activeStatus,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					bank,
-					bankVault,
-					bankVaultAuthority,
-					bankMint: mint,
+					spotMarket,
+					spotMarketVault,
+					insuranceFundVault,
+					clearingHouseSigner: this.getSignerPublicKey(),
+					spotMarketMint: mint,
 					oracle,
 					rent: SYSVAR_RENT_PUBKEY,
 					systemProgram: anchor.web3.SystemProgram.programId,
@@ -127,7 +130,7 @@ export class Admin extends ClearingHouse {
 
 		const { txSig } = await this.txSender.send(initializeTx, [], this.opts);
 
-		await this.accountSubscriber.addBank(bankIndex);
+		await this.accountSubscriber.addSpotMarket(spotMarketIndex);
 		await this.accountSubscriber.addOracle({
 			source: oracleSource,
 			publicKey: oracle,
@@ -136,6 +139,41 @@ export class Admin extends ClearingHouse {
 		return txSig;
 	}
 
+	public async initializeSerumFulfillmentConfig(
+		marketIndex: number,
+		serumMarket: PublicKey,
+		serumProgram: PublicKey
+	): Promise<TransactionSignature> {
+		const serumOpenOrders = getSerumOpenOrdersPublicKey(
+			this.program.programId,
+			serumMarket
+		);
+
+		const serumFulfillmentConfig = 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,
+					clearingHouseSigner: this.getSignerPublicKey(),
+					serumProgram,
+					serumMarket,
+					serumOpenOrders,
+					rent: SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
+					serumFulfillmentConfig,
+				},
+			}
+		);
+	}
+
 	public async initializeMarket(
 		priceOracle: PublicKey,
 		baseAssetReserve: BN,
@@ -144,8 +182,9 @@ export class Admin extends ClearingHouse {
 		pegMultiplier: BN = PEG_PRECISION,
 		oracleSource: OracleSource = OracleSource.PYTH,
 		marginRatioInitial = 2000,
-		marginRatioPartial = 625,
-		marginRatioMaintenance = 500
+		marginRatioMaintenance = 500,
+		liquidationFee = ZERO,
+		activeStatus = true
 	): Promise<TransactionSignature> {
 		const marketPublicKey = await getMarketPublicKey(
 			this.program.programId,
@@ -159,8 +198,9 @@ export class Admin extends ClearingHouse {
 			pegMultiplier,
 			oracleSource,
 			marginRatioInitial,
-			marginRatioPartial,
 			marginRatioMaintenance,
+			liquidationFee,
+			activeStatus,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
@@ -178,7 +218,7 @@ export class Admin extends ClearingHouse {
 			this.opts
 		);
 
-		await this.accountSubscriber.addMarket(
+		await this.accountSubscriber.addPerpMarket(
 			this.getStateAccount().numberOfMarkets
 		);
 		await this.accountSubscriber.addOracle({
@@ -190,23 +230,29 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async moveAmmPrice(
+		marketIndex: number,
 		baseAssetReserve: BN,
 		quoteAssetReserve: BN,
-		marketIndex: BN
+		sqrtK?: BN
 	): Promise<TransactionSignature> {
 		const marketPublicKey = await getMarketPublicKey(
 			this.program.programId,
 			marketIndex
 		);
 
+		if (sqrtK == undefined) {
+			sqrtK = squareRootBN(baseAssetReserve.mul(quoteAssetReserve));
+		}
+
 		return await this.program.rpc.moveAmmPrice(
 			baseAssetReserve,
 			quoteAssetReserve,
+			sqrtK,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
 					admin: this.wallet.publicKey,
-					market: marketPublicKey,
+					perpMarket: marketPublicKey,
 				},
 			}
 		);
@@ -214,23 +260,36 @@ export class Admin extends ClearingHouse {
 
 	public async updateK(
 		sqrtK: BN,
-		marketIndex: BN
+		marketIndex: number
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateK(sqrtK, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				admin: this.wallet.publicKey,
 				market: await getMarketPublicKey(this.program.programId, marketIndex),
-				oracle: this.getMarketAccount(marketIndex).amm.oracle,
+				oracle: this.getPerpMarketAccount(marketIndex).amm.oracle,
+			},
+		});
+	}
+
+	public async updateConcentrationScale(
+		marketIndex: number,
+		concentrationScale: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateConcentrationCoef(concentrationScale, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				admin: this.wallet.publicKey,
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
 			},
 		});
 	}
 
 	public async moveAmmToPrice(
-		marketIndex: BN,
+		perpMarketIndex: number,
 		targetPrice: BN
 	): Promise<TransactionSignature> {
-		const market = this.getMarketAccount(marketIndex);
+		const market = this.getPerpMarketAccount(perpMarketIndex);
 
 		const [direction, tradeSize, _] = calculateTargetPriceTrade(
 			market,
@@ -250,17 +309,18 @@ export class Admin extends ClearingHouse {
 
 		const marketPublicKey = await getMarketPublicKey(
 			this.program.programId,
-			marketIndex
+			perpMarketIndex
 		);
 
 		return await this.program.rpc.moveAmmPrice(
 			newBaseAssetAmount,
 			newQuoteAssetAmount,
+			market.amm.sqrtK,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
 					admin: this.wallet.publicKey,
-					market: marketPublicKey,
+					perpMarket: marketPublicKey,
 				},
 			}
 		);
@@ -268,13 +328,13 @@ export class Admin extends ClearingHouse {
 
 	public async repegAmmCurve(
 		newPeg: BN,
-		marketIndex: BN
+		marketIndex: number
 	): Promise<TransactionSignature> {
 		const marketPublicKey = await getMarketPublicKey(
 			this.program.programId,
 			marketIndex
 		);
-		const ammData = this.getMarketAccount(marketIndex).amm;
+		const ammData = this.getPerpMarketAccount(marketIndex).amm;
 
 		return await this.program.rpc.repegAmmCurve(newPeg, {
 			accounts: {
@@ -287,9 +347,9 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async updateAmmOracleTwap(
-		marketIndex: BN
+		marketIndex: number
 	): Promise<TransactionSignature> {
-		const ammData = this.getMarketAccount(marketIndex).amm;
+		const ammData = this.getPerpMarketAccount(marketIndex).amm;
 		const marketPublicKey = await getMarketPublicKey(
 			this.program.programId,
 			marketIndex
@@ -306,9 +366,9 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async resetAmmOracleTwap(
-		marketIndex: BN
+		marketIndex: number
 	): Promise<TransactionSignature> {
-		const ammData = this.getMarketAccount(marketIndex).amm;
+		const ammData = this.getPerpMarketAccount(marketIndex).amm;
 		const marketPublicKey = await getMarketPublicKey(
 			this.program.programId,
 			marketIndex
@@ -324,60 +384,22 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async withdrawFromInsuranceVault(
+	public async depositIntoMarketFeePool(
+		marketIndex: number,
 		amount: BN,
-		recipient: PublicKey
+		sourceVault: PublicKey
 	): Promise<TransactionSignature> {
-		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: TOKEN_PROGRAM_ID,
-			},
-		});
-	}
+		const spotMarket = this.getQuoteSpotMarketAccount();
 
-	public async withdrawFees(
-		marketIndex: BN,
-		amount: BN,
-		recipient: PublicKey
-	): Promise<TransactionSignature> {
-		const marketPublicKey = await 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: TOKEN_PROGRAM_ID,
-			},
-		});
-	}
-
-	public async withdrawFromInsuranceVaultToMarket(
-		marketIndex: BN,
-		amount: BN
-	): Promise<TransactionSignature> {
-		const state = await this.getStateAccount();
-		return await this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
+		return await this.program.rpc.depositIntoMarketFeePool(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
 				market: await getMarketPublicKey(this.program.programId, marketIndex),
-				insuranceVault: state.insuranceVault,
-				insuranceVaultAuthority: state.insuranceVaultAuthority,
-				bankVault: this.getQuoteAssetBankAccount().vault,
+				sourceVault,
+				clearingHouseSigner: this.getSignerPublicKey(),
+				quoteSpotMarket: spotMarket.pubkey,
+				spotMarketVault: spotMarket.vault,
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
 		});
@@ -393,7 +415,7 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async updateCurveUpdateIntensity(
-		marketIndex: BN,
+		marketIndex: number,
 		curveUpdateIntensity: number
 	): Promise<TransactionSignature> {
 		// assert(curveUpdateIntensity >= 0 && curveUpdateIntensity <= 100);
@@ -412,14 +434,12 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async updateMarginRatio(
-		marketIndex: BN,
+		marketIndex: number,
 		marginRatioInitial: number,
-		marginRatioPartial: number,
 		marginRatioMaintenance: number
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateMarginRatio(
 			marginRatioInitial,
-			marginRatioPartial,
 			marginRatioMaintenance,
 			{
 				accounts: {
@@ -432,7 +452,7 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async updateMarketBaseSpread(
-		marketIndex: BN,
+		marketIndex: number,
 		baseSpread: number
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateMarketBaseSpread(baseSpread, {
@@ -444,8 +464,21 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
+	public async updateAmmJitIntensity(
+		marketIndex: number,
+		ammJitIntensity: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateAmmJitIntensity(ammJitIntensity, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+			},
+		});
+	}
+
 	public async updateMarketMaxSpread(
-		marketIndex: BN,
+		marketIndex: number,
 		maxSpread: number
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateMarketMaxSpread(maxSpread, {
@@ -533,22 +566,21 @@ export class Admin extends ClearingHouse {
 		);
 	}
 
-	public async updateOrderFillerRewardStructure(
-		orderFillerRewardStructure: OrderFillerRewardStructure
+	public async updatePerpFeeStructure(
+		feeStructure: FeeStructure
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateOrderFillerRewardStructure(
-			orderFillerRewardStructure,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-				},
-			}
-		);
+		return await this.program.rpc.updatePerpFeeStructure(feeStructure, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+			},
+		});
 	}
 
-	public async updateFee(fees: FeeStructure): Promise<TransactionSignature> {
-		return await this.program.rpc.updateFee(fees, {
+	public async updateSpotFeeStructure(
+		feeStructure: FeeStructure
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateSpotFeeStructure(feeStructure, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
@@ -567,8 +599,119 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
+	public async updateWithdrawGuardThreshold(
+		marketIndex: number,
+		withdrawGuardThreshold: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateWithdrawGuardThreshold(
+			withdrawGuardThreshold,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						marketIndex
+					),
+				},
+			}
+		);
+	}
+
+	public async updateSpotMarketIfFactor(
+		marketIndex: number,
+		userIfFactor: BN,
+		totalIfFactor: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateSpotMarketIfFactor(
+			marketIndex,
+			userIfFactor,
+			totalIfFactor,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						marketIndex
+					),
+				},
+			}
+		);
+	}
+
+	public async updateSpotMarketRevenueSettlePeriod(
+		marketIndex: number,
+		revenueSettlePeriod: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateSpotMarketRevenueSettlePeriod(
+			revenueSettlePeriod,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						marketIndex
+					),
+				},
+			}
+		);
+	}
+
+	public async updateSpotMarketMaxTokenDeposits(
+		marketIndex: number,
+		maxTokenDeposits: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateSpotMarketMaxTokenDeposits(
+			maxTokenDeposits,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						marketIndex
+					),
+				},
+			}
+		);
+	}
+
+	public async updateInsuranceWithdrawEscrowPeriod(
+		marketIndex: number,
+		insuranceWithdrawEscrowPeriod: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateInsuranceWithdrawEscrowPeriod(
+			insuranceWithdrawEscrowPeriod,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						marketIndex
+					),
+				},
+			}
+		);
+	}
+
+	public async updateLpCooldownTime(
+		marketIndex: number,
+		cooldownTime: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateLpCooldownTime(cooldownTime, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+			},
+		});
+	}
+
 	public async updateMarketOracle(
-		marketIndex: BN,
+		marketIndex: number,
 		oracle: PublicKey,
 		oracleSource: OracleSource
 	): Promise<TransactionSignature> {
@@ -582,7 +725,7 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async updateMarketMinimumQuoteAssetTradeSize(
-		marketIndex: BN,
+		marketIndex: number,
 		minimumTradeSize: BN
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateMarketMinimumQuoteAssetTradeSize(
@@ -598,7 +741,7 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async updateMarketBaseAssetAmountStepSize(
-		marketIndex: BN,
+		marketIndex: number,
 		stepSize: BN
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateMarketBaseAssetAmountStepSize(
@@ -613,6 +756,22 @@ export class Admin extends ClearingHouse {
 		);
 	}
 
+	public async updateMarketExpiry(
+		perpMarketIndex: number,
+		expiryTs: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMarketExpiry(expiryTs, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				perpMarket: await getMarketPublicKey(
+					this.program.programId,
+					perpMarketIndex
+				),
+			},
+		});
+	}
+
 	public async updateWhitelistMint(
 		whitelistMint?: PublicKey
 	): Promise<TransactionSignature> {
@@ -644,42 +803,113 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async updateFundingPaused(
-		fundingPaused: boolean
+	public async updateSpotMarketMarginWeights(
+		spotMarketIndex: number,
+		initialAssetWeight: BN,
+		maintenanceAssetWeight: BN,
+		initialLiabilityWeight: BN,
+		maintenanceLiabilityWeight: BN,
+		imfFactor = new BN(0)
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateFundingPaused(fundingPaused, {
+		return await this.program.rpc.updateSpotMarketMarginWeights(
+			initialAssetWeight,
+			maintenanceAssetWeight,
+			initialLiabilityWeight,
+			maintenanceLiabilityWeight,
+			imfFactor,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						spotMarketIndex
+					),
+				},
+			}
+		);
+	}
+
+	public async updateSpotMarketAssetTier(
+		spotMarketIndex: number,
+		assetTier: AssetTier
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateSpotMarketAssetTier(assetTier, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
+				spotMarket: await getSpotMarketPublicKey(
+					this.program.programId,
+					spotMarketIndex
+				),
 			},
 		});
 	}
 
-	public async updateExchangePaused(
-		exchangePaused: boolean
+	public async updateSpotMarketStatus(
+		spotMarketIndex: number,
+		marketStatus: MarketStatus
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateExchangePaused(exchangePaused, {
+		return await this.program.rpc.updateSpotMarketStatus(marketStatus, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
+				spotMarket: await getSpotMarketPublicKey(
+					this.program.programId,
+					spotMarketIndex
+				),
 			},
 		});
 	}
 
-	public async disableAdminControlsPrices(): Promise<TransactionSignature> {
-		return await this.program.rpc.disableAdminControlsPrices({
+	public async updatePerpMarketStatus(
+		perpMarketIndex: number,
+		marketStatus: MarketStatus
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updatePerpMarketStatus(marketStatus, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(
+					this.program.programId,
+					perpMarketIndex
+				),
 			},
 		});
 	}
 
-	public async updateOrderAuctionTime(
-		time: BN | number
+	public async updatePerpMarketContractTier(
+		perpMarketIndex: number,
+		contractTier: ContractTier
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateOrderAuctionTime(
-			typeof time === 'number' ? time : time.toNumber,
+		return await this.program.rpc.updatePerpMarketContractTier(contractTier, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(
+					this.program.programId,
+					perpMarketIndex
+				),
+			},
+		});
+	}
+
+	public async updateExchangeStatus(
+		exchangeStatus: ExchangeStatus
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateExchangeStatus(exchangeStatus, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+			},
+		});
+	}
+
+	public async updatePerpAuctionDuration(
+		minDuration: BN | number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updatePerpAuctionDuration(
+			typeof minDuration === 'number' ? minDuration : minDuration.toNumber(),
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
@@ -688,4 +918,79 @@ export class Admin extends ClearingHouse {
 			}
 		);
 	}
+
+	public async updateSpotAuctionDuration(
+		defaultAuctionDuration: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateSpotAuctionDuration(
+			defaultAuctionDuration,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
+	}
+
+	public async updateMaxBaseAssetAmountRatio(
+		marketIndex: number,
+		maxBaseAssetAmountRatio: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMaxBaseAssetAmountRatio(
+			maxBaseAssetAmountRatio,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					market: this.getPerpMarketAccount(marketIndex).pubkey,
+				},
+			}
+		);
+	}
+
+	public async updateMaxSlippageRatio(
+		marketIndex: number,
+		maxSlippageRatio: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: this.getPerpMarketAccount(marketIndex).pubkey,
+			},
+		});
+	}
+
+	public async updateMarketMaxImbalances(
+		marketIndex: number,
+		unrealizedMaxImbalance: BN,
+		maxRevenueWithdrawPerPeriod: BN,
+		quoteMaxInsurance: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMarketMaxImbalances(
+			unrealizedMaxImbalance,
+			maxRevenueWithdrawPerPeriod,
+			quoteMaxInsurance,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					market: await getMarketPublicKey(this.program.programId, marketIndex),
+				},
+			}
+		);
+	}
+
+	public async updateSerumVault(
+		srmVault: PublicKey
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateSerumVault({
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				srmVault: srmVault,
+			},
+		});
+	}
 }