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

package/src/admin.ts

@@ -12,13 +12,14 @@ import {
 	ContractTier,
 	AssetTier,
 } from './types';
+import { DEFAULT_MARKET_NAME, encodeName } from './userName';
 import { BN } from '@project-serum/anchor';
 import * as anchor from '@project-serum/anchor';
 import {
 	getClearingHouseStateAccountPublicKeyAndNonce,
 	getSpotMarketPublicKey,
 	getSpotMarketVaultPublicKey,
-	getMarketPublicKey,
+	getPerpMarketPublicKey,
 	getInsuranceFundVaultPublicKey,
 	getSerumOpenOrdersPublicKey,
 	getSerumFulfillmentConfigPublicKey,
@@ -174,7 +175,7 @@ export class Admin extends ClearingHouse {
 		);
 	}
 
-	public async initializeMarket(
+	public async initializePerpMarket(
 		priceOracle: PublicKey,
 		baseAssetReserve: BN,
 		quoteAssetReserve: BN,
@@ -184,34 +185,38 @@ export class Admin extends ClearingHouse {
 		marginRatioInitial = 2000,
 		marginRatioMaintenance = 500,
 		liquidationFee = ZERO,
-		activeStatus = true
+		activeStatus = true,
+		name = DEFAULT_MARKET_NAME
 	): Promise<TransactionSignature> {
-		const marketPublicKey = await getMarketPublicKey(
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
 			this.program.programId,
 			this.getStateAccount().numberOfMarkets
 		);
 
-		const initializeMarketTx = await this.program.transaction.initializeMarket(
-			baseAssetReserve,
-			quoteAssetReserve,
-			periodicity,
-			pegMultiplier,
-			oracleSource,
-			marginRatioInitial,
-			marginRatioMaintenance,
-			liquidationFee,
-			activeStatus,
-			{
-				accounts: {
-					state: await this.getStatePublicKey(),
-					admin: this.wallet.publicKey,
-					oracle: priceOracle,
-					market: marketPublicKey,
-					rent: SYSVAR_RENT_PUBKEY,
-					systemProgram: anchor.web3.SystemProgram.programId,
-				},
-			}
-		);
+		const nameBuffer = encodeName(name);
+		const initializeMarketTx =
+			await this.program.transaction.initializePerpMarket(
+				baseAssetReserve,
+				quoteAssetReserve,
+				periodicity,
+				pegMultiplier,
+				oracleSource,
+				marginRatioInitial,
+				marginRatioMaintenance,
+				liquidationFee,
+				activeStatus,
+				nameBuffer,
+				{
+					accounts: {
+						state: await this.getStatePublicKey(),
+						admin: this.wallet.publicKey,
+						oracle: priceOracle,
+						perpMarket: perpMarketPublicKey,
+						rent: SYSVAR_RENT_PUBKEY,
+						systemProgram: anchor.web3.SystemProgram.programId,
+					},
+				}
+			);
 		const { txSig } = await this.txSender.send(
 			initializeMarketTx,
 			[],
@@ -230,14 +235,14 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async moveAmmPrice(
-		marketIndex: number,
+		perpMarketIndex: number,
 		baseAssetReserve: BN,
 		quoteAssetReserve: BN,
 		sqrtK?: BN
 	): Promise<TransactionSignature> {
-		const marketPublicKey = await getMarketPublicKey(
+		const marketPublicKey = await getPerpMarketPublicKey(
 			this.program.programId,
-			marketIndex
+			perpMarketIndex
 		);
 
 		if (sqrtK == undefined) {
@@ -259,40 +264,49 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async updateK(
-		sqrtK: BN,
-		marketIndex: number
+		perpMarketIndex: number,
+		sqrtK: BN
 	): 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.getPerpMarketAccount(marketIndex).amm.oracle,
+				perpMarket: await getPerpMarketPublicKey(
+					this.program.programId,
+					perpMarketIndex
+				),
+				oracle: this.getPerpMarketAccount(perpMarketIndex).amm.oracle,
 			},
 		});
 	}
 
-	public async updateConcentrationScale(
-		marketIndex: number,
+	public async updatePerpMarketConcentrationScale(
+		perpMarketIndex: 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),
-			},
-		});
+		return await this.program.rpc.updatePerpMarketConcentrationCoef(
+			concentrationScale,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					admin: this.wallet.publicKey,
+					perpMarket: await getPerpMarketPublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
+				},
+			}
+		);
 	}
 
 	public async moveAmmToPrice(
 		perpMarketIndex: number,
 		targetPrice: BN
 	): Promise<TransactionSignature> {
-		const market = this.getPerpMarketAccount(perpMarketIndex);
+		const perpMarket = this.getPerpMarketAccount(perpMarketIndex);
 
 		const [direction, tradeSize, _] = calculateTargetPriceTrade(
-			market,
+			perpMarket,
 			targetPrice,
 			new BN(1000),
 			'quote',
@@ -301,13 +315,13 @@ export class Admin extends ClearingHouse {
 
 		const [newQuoteAssetAmount, newBaseAssetAmount] =
 			calculateAmmReservesAfterSwap(
-				market.amm,
+				perpMarket.amm,
 				'quote',
 				tradeSize,
 				getSwapDirection('quote', direction)
 			);
 
-		const marketPublicKey = await getMarketPublicKey(
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
 			this.program.programId,
 			perpMarketIndex
 		);
@@ -315,12 +329,12 @@ export class Admin extends ClearingHouse {
 		return await this.program.rpc.moveAmmPrice(
 			newBaseAssetAmount,
 			newQuoteAssetAmount,
-			market.amm.sqrtK,
+			perpMarket.amm.sqrtK,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
 					admin: this.wallet.publicKey,
-					perpMarket: marketPublicKey,
+					perpMarket: perpMarketPublicKey,
 				},
 			}
 		);
@@ -328,74 +342,77 @@ export class Admin extends ClearingHouse {
 
 	public async repegAmmCurve(
 		newPeg: BN,
-		marketIndex: number
+		perpMarketIndex: number
 	): Promise<TransactionSignature> {
-		const marketPublicKey = await getMarketPublicKey(
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
 			this.program.programId,
-			marketIndex
+			perpMarketIndex
 		);
-		const ammData = this.getPerpMarketAccount(marketIndex).amm;
+		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,
-				market: marketPublicKey,
+				perpMarket: perpMarketPublicKey,
 			},
 		});
 	}
 
-	public async updateAmmOracleTwap(
-		marketIndex: number
+	public async updatePerpMarketAmmOracleTwap(
+		perpMarketIndex: number
 	): Promise<TransactionSignature> {
-		const ammData = this.getPerpMarketAccount(marketIndex).amm;
-		const marketPublicKey = await getMarketPublicKey(
+		const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
 			this.program.programId,
-			marketIndex
+			perpMarketIndex
 		);
 
-		return await this.program.rpc.updateAmmOracleTwap({
+		return await this.program.rpc.updatePerpMarketAmmOracleTwap({
 			accounts: {
 				state: await this.getStatePublicKey(),
 				admin: this.wallet.publicKey,
 				oracle: ammData.oracle,
-				market: marketPublicKey,
+				perpMarket: perpMarketPublicKey,
 			},
 		});
 	}
 
-	public async resetAmmOracleTwap(
-		marketIndex: number
+	public async resetPerpMarketAmmOracleTwap(
+		perpMarketIndex: number
 	): Promise<TransactionSignature> {
-		const ammData = this.getPerpMarketAccount(marketIndex).amm;
-		const marketPublicKey = await getMarketPublicKey(
+		const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
 			this.program.programId,
-			marketIndex
+			perpMarketIndex
 		);
 
-		return await this.program.rpc.resetAmmOracleTwap({
+		return await this.program.rpc.resetPerpMarketAmmOracleTwap({
 			accounts: {
 				state: await this.getStatePublicKey(),
 				admin: this.wallet.publicKey,
 				oracle: ammData.oracle,
-				market: marketPublicKey,
+				perpMarket: perpMarketPublicKey,
 			},
 		});
 	}
 
-	public async depositIntoMarketFeePool(
-		marketIndex: number,
+	public async depositIntoPerpMarketFeePool(
+		perpMarketIndex: number,
 		amount: BN,
 		sourceVault: PublicKey
 	): Promise<TransactionSignature> {
 		const spotMarket = this.getQuoteSpotMarketAccount();
 
-		return await this.program.rpc.depositIntoMarketFeePool(amount, {
+		return await this.program.rpc.depositIntoPerpMarketFeePool(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				market: await getMarketPublicKey(this.program.programId, marketIndex),
+				perpMarket: await getPerpMarketPublicKey(
+					this.program.programId,
+					perpMarketIndex
+				),
 				sourceVault,
 				clearingHouseSigner: this.getSignerPublicKey(),
 				quoteSpotMarket: spotMarket.pubkey,
@@ -414,156 +431,115 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async updateCurveUpdateIntensity(
-		marketIndex: number,
+	public async updatePerpMarketCurveUpdateIntensity(
+		perpMarketIndex: number,
 		curveUpdateIntensity: number
 	): Promise<TransactionSignature> {
 		// assert(curveUpdateIntensity >= 0 && curveUpdateIntensity <= 100);
 		// assert(Number.isInteger(curveUpdateIntensity));
 
-		return await this.program.rpc.updateCurveUpdateIntensity(
+		return await this.program.rpc.updatePerpMarketCurveUpdateIntensity(
 			curveUpdateIntensity,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					market: await getMarketPublicKey(this.program.programId, marketIndex),
+					perpMarket: await getPerpMarketPublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
 				},
 			}
 		);
 	}
 
-	public async updateMarginRatio(
-		marketIndex: number,
+	public async updatePerpMarketMarginRatio(
+		perpMarketIndex: number,
 		marginRatioInitial: number,
 		marginRatioMaintenance: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMarginRatio(
+		return await this.program.rpc.updatePerpMarketMarginRatio(
 			marginRatioInitial,
 			marginRatioMaintenance,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					market: await getMarketPublicKey(this.program.programId, marketIndex),
+					perpMarket: await getPerpMarketPublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
 				},
 			}
 		);
 	}
 
-	public async updateMarketBaseSpread(
-		marketIndex: number,
+	public async updatePerpMarketBaseSpread(
+		perpMarketIndex: number,
 		baseSpread: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMarketBaseSpread(baseSpread, {
+		return await this.program.rpc.updatePerpMarketBaseSpread(baseSpread, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				market: await getMarketPublicKey(this.program.programId, marketIndex),
+				perpMarket: await getPerpMarketPublicKey(
+					this.program.programId,
+					perpMarketIndex
+				),
 			},
 		});
 	}
 
 	public async updateAmmJitIntensity(
-		marketIndex: number,
+		perpMarketIndex: 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),
+				perpMarket: await getPerpMarketPublicKey(
+					this.program.programId,
+					perpMarketIndex
+				),
 			},
 		});
 	}
 
-	public async updateMarketMaxSpread(
-		marketIndex: number,
-		maxSpread: number
+	public async updatePerpMarketName(
+		perpMarketIndex: number,
+		name: string
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMarketMaxSpread(maxSpread, {
+		const nameBuffer = encodeName(name);
+
+		return await this.program.rpc.updatePerpMarketName(nameBuffer, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				market: await getMarketPublicKey(this.program.programId, marketIndex),
+				perpMarket: await getPerpMarketPublicKey(
+					this.program.programId,
+					perpMarketIndex
+				),
 			},
 		});
 	}
 
-	public async updatePartialLiquidationClosePercentage(
-		numerator: BN,
-		denominator: BN
-	): Promise<TransactionSignature> {
-		return await this.program.rpc.updatePartialLiquidationClosePercentage(
-			numerator,
-			denominator,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-				},
-			}
-		);
-	}
-
-	public async updatePartialLiquidationPenaltyPercentage(
-		numerator: BN,
-		denominator: BN
-	): Promise<TransactionSignature> {
-		return await this.program.rpc.updatePartialLiquidationPenaltyPercentage(
-			numerator,
-			denominator,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-				},
-			}
-		);
-	}
-
-	public async updateFullLiquidationPenaltyPercentage(
-		numerator: BN,
-		denominator: BN
-	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateFullLiquidationPenaltyPercentage(
-			numerator,
-			denominator,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-				},
-			}
-		);
-	}
-
-	public async updatePartialLiquidationShareDenominator(
-		denominator: BN
+	public async updatePerpMarketMaxSpread(
+		perpMarketIndex: number,
+		maxSpread: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updatePartialLiquidationLiquidatorShareDenominator(
-			denominator,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-				},
-			}
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
+			this.program.programId,
+			perpMarketIndex
 		);
-	}
 
-	public async updateFullLiquidationShareDenominator(
-		denominator: BN
-	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateFullLiquidationLiquidatorShareDenominator(
-			denominator,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-				},
-			}
-		);
+		return await this.program.rpc.updatePerpMarketMaxSpread(maxSpread, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				perpMarket: perpMarketPublicKey,
+			},
+		});
 	}
 
 	public async updatePerpFeeStructure(
@@ -599,8 +575,22 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
+	public async updateStateSettlementDuration(
+		settlementDuration: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateStateSettlementDuration(
+			settlementDuration,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
+	}
+
 	public async updateWithdrawGuardThreshold(
-		marketIndex: number,
+		spotMarketIndex: number,
 		withdrawGuardThreshold: BN
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateWithdrawGuardThreshold(
@@ -611,7 +601,7 @@ export class Admin extends ClearingHouse {
 					state: await this.getStatePublicKey(),
 					spotMarket: await getSpotMarketPublicKey(
 						this.program.programId,
-						marketIndex
+						spotMarketIndex
 					),
 				},
 			}
@@ -619,12 +609,12 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async updateSpotMarketIfFactor(
-		marketIndex: number,
+		spotMarketIndex: number,
 		userIfFactor: BN,
 		totalIfFactor: BN
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateSpotMarketIfFactor(
-			marketIndex,
+			spotMarketIndex,
 			userIfFactor,
 			totalIfFactor,
 			{
@@ -633,7 +623,7 @@ export class Admin extends ClearingHouse {
 					state: await this.getStatePublicKey(),
 					spotMarket: await getSpotMarketPublicKey(
 						this.program.programId,
-						marketIndex
+						spotMarketIndex
 					),
 				},
 			}
@@ -641,7 +631,7 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async updateSpotMarketRevenueSettlePeriod(
-		marketIndex: number,
+		spotMarketIndex: number,
 		revenueSettlePeriod: BN
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateSpotMarketRevenueSettlePeriod(
@@ -652,7 +642,7 @@ export class Admin extends ClearingHouse {
 					state: await this.getStatePublicKey(),
 					spotMarket: await getSpotMarketPublicKey(
 						this.program.programId,
-						marketIndex
+						spotMarketIndex
 					),
 				},
 			}
@@ -660,7 +650,7 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async updateSpotMarketMaxTokenDeposits(
-		marketIndex: number,
+		spotMarketIndex: number,
 		maxTokenDeposits: BN
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateSpotMarketMaxTokenDeposits(
@@ -671,18 +661,18 @@ export class Admin extends ClearingHouse {
 					state: await this.getStatePublicKey(),
 					spotMarket: await getSpotMarketPublicKey(
 						this.program.programId,
-						marketIndex
+						spotMarketIndex
 					),
 				},
 			}
 		);
 	}
 
-	public async updateInsuranceWithdrawEscrowPeriod(
-		marketIndex: number,
+	public async updateInsuranceFundUnstakingPeriod(
+		spotMarketIndex: number,
 		insuranceWithdrawEscrowPeriod: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateInsuranceWithdrawEscrowPeriod(
+		return await this.program.rpc.updateInsuranceFundUnstakingPeriod(
 			insuranceWithdrawEscrowPeriod,
 			{
 				accounts: {
@@ -690,7 +680,7 @@ export class Admin extends ClearingHouse {
 					state: await this.getStatePublicKey(),
 					spotMarket: await getSpotMarketPublicKey(
 						this.program.programId,
-						marketIndex
+						spotMarketIndex
 					),
 				},
 			}
@@ -698,73 +688,80 @@ export class Admin extends ClearingHouse {
 	}
 
 	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: number,
+	public async updatePerpMarketOracle(
+		perpMarketIndex: number,
 		oracle: PublicKey,
 		oracleSource: OracleSource
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMarketOracle(oracle, oracleSource, {
+		return await this.program.rpc.updatePerpMarketOracle(oracle, oracleSource, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				market: await getMarketPublicKey(this.program.programId, marketIndex),
+				perpMarket: await getPerpMarketPublicKey(
+					this.program.programId,
+					perpMarketIndex
+				),
+				oracle: oracle,
 			},
 		});
 	}
 
-	public async updateMarketMinimumQuoteAssetTradeSize(
-		marketIndex: number,
-		minimumTradeSize: BN
+	public async updatePerpMarketStepSizeAndTickSize(
+		perpMarketIndex: number,
+		stepSize: BN,
+		tickSize: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMarketMinimumQuoteAssetTradeSize(
-			minimumTradeSize,
+		return await this.program.rpc.updatePerpMarketStepSizeAndTickSize(
+			stepSize,
+			tickSize,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					market: await getMarketPublicKey(this.program.programId, marketIndex),
+					perpMarket: await getPerpMarketPublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
 				},
 			}
 		);
 	}
 
-	public async updateMarketBaseAssetAmountStepSize(
-		marketIndex: number,
-		stepSize: BN
+	public async updatePerpMarketMinOrderSize(
+		perpMarketIndex: number,
+		orderSize: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMarketBaseAssetAmountStepSize(
-			stepSize,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-					market: await getMarketPublicKey(this.program.programId, marketIndex),
-				},
-			}
-		);
+		return await this.program.rpc.updatePerpMarketMinOrderSize(orderSize, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				perpMarket: await getPerpMarketPublicKey(
+					this.program.programId,
+					perpMarketIndex
+				),
+			},
+		});
 	}
 
-	public async updateMarketExpiry(
+	public async updatePerpMarketExpiry(
 		perpMarketIndex: number,
 		expiryTs: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMarketExpiry(expiryTs, {
+		return await this.program.rpc.updatePerpMarketExpiry(expiryTs, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				perpMarket: await getMarketPublicKey(
+				perpMarket: await getPerpMarketPublicKey(
 					this.program.programId,
 					perpMarketIndex
 				),
@@ -772,21 +769,44 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async updateWhitelistMint(
-		whitelistMint?: PublicKey
+	public async updateSpotMarketOracle(
+		spotMarketIndex: number,
+		oracle: PublicKey,
+		oracleSource: OracleSource
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateWhitelistMint(whitelistMint, {
+		return await this.program.rpc.updatePerpMarketOracle(oracle, oracleSource, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
+				spotMarket: await getSpotMarketPublicKey(
+					this.program.programId,
+					spotMarketIndex
+				),
+				oracle: oracle,
 			},
 		});
 	}
 
-	public async updateDiscountMint(
-		discountMint: PublicKey
+	public async updateSpotMarketExpiry(
+		spotMarketIndex: number,
+		expiryTs: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateDiscountMint(discountMint, {
+		return await this.program.rpc.updateSpotMarketExpiry(expiryTs, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				spotMarket: await getSpotMarketPublicKey(
+					this.program.programId,
+					spotMarketIndex
+				),
+			},
+		});
+	}
+
+	public async updateWhitelistMint(
+		whitelistMint?: PublicKey
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateWhitelistMint(whitelistMint, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
@@ -794,8 +814,10 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async updateMaxDeposit(maxDeposit: BN): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMaxDeposit(maxDeposit, {
+	public async updateDiscountMint(
+		discountMint: PublicKey
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateDiscountMint(discountMint, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
@@ -870,7 +892,7 @@ export class Admin extends ClearingHouse {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				market: await getMarketPublicKey(
+				perpMarket: await getPerpMarketPublicKey(
 					this.program.programId,
 					perpMarketIndex
 				),
@@ -886,7 +908,7 @@ export class Admin extends ClearingHouse {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				market: await getMarketPublicKey(
+				perpMarket: await getPerpMarketPublicKey(
 					this.program.programId,
 					perpMarketIndex
 				),
@@ -933,42 +955,42 @@ export class Admin extends ClearingHouse {
 		);
 	}
 
-	public async updateMaxBaseAssetAmountRatio(
-		marketIndex: number,
+	public async updatePerpMarketMaxFillReserveFraction(
+		perpMarketIndex: number,
 		maxBaseAssetAmountRatio: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMaxBaseAssetAmountRatio(
+		return await this.program.rpc.updatePerpMarketMaxFillReserveFraction(
 			maxBaseAssetAmountRatio,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					market: this.getPerpMarketAccount(marketIndex).pubkey,
+					perpMarket: this.getPerpMarketAccount(perpMarketIndex).pubkey,
 				},
 			}
 		);
 	}
 
 	public async updateMaxSlippageRatio(
-		marketIndex: number,
+		perpMarketIndex: 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,
+				perpMarket: this.getPerpMarketAccount(perpMarketIndex).pubkey,
 			},
 		});
 	}
 
-	public async updateMarketMaxImbalances(
-		marketIndex: number,
+	public async updatePerpMarketMaxImbalances(
+		perpMarketIndex: number,
 		unrealizedMaxImbalance: BN,
 		maxRevenueWithdrawPerPeriod: BN,
 		quoteMaxInsurance: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMarketMaxImbalances(
+		return await this.program.rpc.updatePerpMarketMaxImbalances(
 			unrealizedMaxImbalance,
 			maxRevenueWithdrawPerPeriod,
 			quoteMaxInsurance,
@@ -976,7 +998,10 @@ export class Admin extends ClearingHouse {
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					market: await getMarketPublicKey(this.program.programId, marketIndex),
+					perpMarket: await getPerpMarketPublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
 				},
 			}
 		);