@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/src/admin.ts

@@ -1,58 +1,34 @@
 import {
-	ConfirmOptions,
-	Connection,
 	PublicKey,
 	SYSVAR_RENT_PUBKEY,
 	TransactionSignature,
 } from '@solana/web3.js';
 import {
 	FeeStructure,
-	IWallet,
 	OracleGuardRails,
 	OracleSource,
 	OrderFillerRewardStructure,
 } from './types';
-import { BN, AnchorProvider } from '@project-serum/anchor';
+import { BN } from '@project-serum/anchor';
 import * as anchor from '@project-serum/anchor';
 import {
-	getClearingHouseStateAccountPublicKey,
 	getClearingHouseStateAccountPublicKeyAndNonce,
-	getOrderStateAccountPublicKeyAndNonce,
-	getSettlementStatePublicKey,
-	getUserAccountPublicKey,
-} from './addresses';
+	getBankVaultAuthorityPublicKey,
+	getBankPublicKey,
+	getBankVaultPublicKey,
+	getMarketPublicKey,
+} from './addresses/pda';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { ClearingHouse } from './clearingHouse';
 import { PEG_PRECISION } from './constants/numericConstants';
 import { calculateTargetPriceTrade } from './math/trade';
 import { calculateAmmReservesAfterSwap, getSwapDirection } from './math/amm';
-import {
-	getAdmin,
-	getWebSocketClearingHouseConfig,
-} from './factory/clearingHouse';
 
 export class Admin extends ClearingHouse {
-	public static from(
-		connection: Connection,
-		wallet: IWallet,
-		clearingHouseProgramId: PublicKey,
-		opts: ConfirmOptions = AnchorProvider.defaultOptions()
-	): Admin {
-		const config = getWebSocketClearingHouseConfig(
-			connection,
-			wallet,
-			clearingHouseProgramId,
-			opts
-		);
-		return getAdmin(config);
-	}
-
 	public async initialize(
 		usdcMint: PublicKey,
 		adminControlsPrices: boolean
-	): Promise<
-		[TransactionSignature, TransactionSignature, TransactionSignature]
-	> {
+	): Promise<[TransactionSignature]> {
 		const stateAccountRPCResponse = await this.connection.getParsedAccountInfo(
 			await this.getStatePublicKey()
 		);
@@ -60,160 +36,109 @@ export class Admin extends ClearingHouse {
 			throw new Error('Clearing house already initialized');
 		}
 
-		const [collateralVaultPublicKey, collateralVaultNonce] =
-			await PublicKey.findProgramAddress(
-				[Buffer.from(anchor.utils.bytes.utf8.encode('collateral_vault'))],
-				this.program.programId
-			);
-
-		const [collateralVaultAuthority, _collateralVaultAuthorityNonce] =
-			await PublicKey.findProgramAddress(
-				[collateralVaultPublicKey.toBuffer()],
-				this.program.programId
-			);
-
-		const [insuranceVaultPublicKey, insuranceVaultNonce] =
-			await PublicKey.findProgramAddress(
-				[Buffer.from(anchor.utils.bytes.utf8.encode('insurance_vault'))],
-				this.program.programId
-			);
-
-		const [insuranceVaultAuthority, _insuranceVaultAuthorityNonce] =
-			await PublicKey.findProgramAddress(
-				[insuranceVaultPublicKey.toBuffer()],
-				this.program.programId
-			);
+		const [insuranceVaultPublicKey] = await PublicKey.findProgramAddress(
+			[Buffer.from(anchor.utils.bytes.utf8.encode('insurance_vault'))],
+			this.program.programId
+		);
 
-		const markets = anchor.web3.Keypair.generate();
-		const depositHistory = anchor.web3.Keypair.generate();
-		const fundingRateHistory = anchor.web3.Keypair.generate();
-		const fundingPaymentHistory = anchor.web3.Keypair.generate();
-		const tradeHistory = anchor.web3.Keypair.generate();
-		const liquidationHistory = anchor.web3.Keypair.generate();
-		const curveHistory = anchor.web3.Keypair.generate();
+		const [insuranceVaultAuthority] = await PublicKey.findProgramAddress(
+			[insuranceVaultPublicKey.toBuffer()],
+			this.program.programId
+		);
 
-		const [clearingHouseStatePublicKey, clearingHouseNonce] =
+		const [clearingHouseStatePublicKey] =
 			await getClearingHouseStateAccountPublicKeyAndNonce(
 				this.program.programId
 			);
 		const initializeTx = await this.program.transaction.initialize(
-			clearingHouseNonce,
-			collateralVaultNonce,
-			insuranceVaultNonce,
 			adminControlsPrices,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: clearingHouseStatePublicKey,
-					collateralMint: usdcMint,
-					collateralVault: collateralVaultPublicKey,
-					collateralVaultAuthority: collateralVaultAuthority,
+					quoteAssetMint: usdcMint,
 					insuranceVault: insuranceVaultPublicKey,
 					insuranceVaultAuthority: insuranceVaultAuthority,
-					markets: markets.publicKey,
 					rent: SYSVAR_RENT_PUBKEY,
 					systemProgram: anchor.web3.SystemProgram.programId,
 					tokenProgram: TOKEN_PROGRAM_ID,
 				},
-				instructions: [
-					await this.program.account.markets.createInstruction(markets),
-				],
 			}
 		);
 
-		const initializeTxSig = await this.txSender.send(
+		const { txSig: initializeTxSig } = await this.txSender.send(
 			initializeTx,
-			[markets],
+			[],
 			this.opts
 		);
 
-		const initializeHistoryTx =
-			await this.program.transaction.initializeHistory({
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: clearingHouseStatePublicKey,
-					depositHistory: depositHistory.publicKey,
-					fundingRateHistory: fundingRateHistory.publicKey,
-					fundingPaymentHistory: fundingPaymentHistory.publicKey,
-					tradeHistory: tradeHistory.publicKey,
-					liquidationHistory: liquidationHistory.publicKey,
-					curveHistory: curveHistory.publicKey,
-					rent: SYSVAR_RENT_PUBKEY,
-					systemProgram: anchor.web3.SystemProgram.programId,
-				},
-				instructions: [
-					await this.program.account.fundingRateHistory.createInstruction(
-						fundingRateHistory
-					),
-					await this.program.account.fundingPaymentHistory.createInstruction(
-						fundingPaymentHistory
-					),
-					await this.program.account.tradeHistory.createInstruction(
-						tradeHistory
-					),
-					await this.program.account.liquidationHistory.createInstruction(
-						liquidationHistory
-					),
-					await this.program.account.depositHistory.createInstruction(
-						depositHistory
-					),
-					await this.program.account.extendedCurveHistory.createInstruction(
-						curveHistory
-					),
-				],
-			});
-
-		const initializeHistoryTxSig = await this.txSender.send(
-			initializeHistoryTx,
-			[
-				depositHistory,
-				fundingPaymentHistory,
-				tradeHistory,
-				liquidationHistory,
-				fundingRateHistory,
-				curveHistory,
-			],
-			this.opts
-		);
+		return [initializeTxSig];
+	}
 
-		const initializeOrderStateTxSig = await this.initializeOrderState();
+	public async initializeBank(
+		mint: PublicKey,
+		optimalUtilization: BN,
+		optimalRate: BN,
+		maxRate: BN,
+		oracle: PublicKey,
+		oracleSource: OracleSource,
+		initialAssetWeight: BN,
+		maintenanceAssetWeight: BN,
+		initialLiabilityWeight: BN,
+		maintenanceLiabilityWeight: BN,
+		imfFactor = new BN(0)
+	): Promise<TransactionSignature> {
+		const bankIndex = this.getStateAccount().numberOfBanks;
+		const bank = await getBankPublicKey(this.program.programId, bankIndex);
 
-		return [initializeTxSig, initializeHistoryTxSig, initializeOrderStateTxSig];
-	}
+		const bankVault = await getBankVaultPublicKey(
+			this.program.programId,
+			bankIndex
+		);
 
-	public async initializeOrderState(): Promise<TransactionSignature> {
-		const orderHistory = anchor.web3.Keypair.generate();
-		const [orderStatePublicKey, orderStateNonce] =
-			await getOrderStateAccountPublicKeyAndNonce(this.program.programId);
-		const clearingHouseStatePublicKey =
-			await getClearingHouseStateAccountPublicKey(this.program.programId);
+		const bankVaultAuthority = await getBankVaultAuthorityPublicKey(
+			this.program.programId,
+			bankIndex
+		);
 
-		const initializeOrderStateTx =
-			await this.program.transaction.initializeOrderState(orderStateNonce, {
+		const initializeTx = await this.program.transaction.initializeBank(
+			optimalUtilization,
+			optimalRate,
+			maxRate,
+			oracleSource,
+			initialAssetWeight,
+			maintenanceAssetWeight,
+			initialLiabilityWeight,
+			maintenanceLiabilityWeight,
+			imfFactor,
+			{
 				accounts: {
 					admin: this.wallet.publicKey,
-					state: clearingHouseStatePublicKey,
-					orderHistory: orderHistory.publicKey,
-					orderState: orderStatePublicKey,
+					state: await this.getStatePublicKey(),
+					bank,
+					bankVault,
+					bankVaultAuthority,
+					bankMint: mint,
+					oracle,
 					rent: SYSVAR_RENT_PUBKEY,
 					systemProgram: anchor.web3.SystemProgram.programId,
+					tokenProgram: TOKEN_PROGRAM_ID,
 				},
-				instructions: [
-					await this.program.account.orderHistory.createInstruction(
-						orderHistory
-					),
-				],
-			});
-
-		return await this.txSender.send(
-			initializeOrderStateTx,
-			[orderHistory],
-			this.opts
+			}
 		);
+
+		const { txSig } = await this.txSender.send(initializeTx, [], this.opts);
+
+		await this.accountSubscriber.addBank(bankIndex);
+		await this.accountSubscriber.addOracle({
+			source: oracleSource,
+			publicKey: oracle,
+		});
+
+		return txSig;
 	}
 
 	public async initializeMarket(
-		marketIndex: BN,
 		priceOracle: PublicKey,
 		baseAssetReserve: BN,
 		quoteAssetReserve: BN,
@@ -224,12 +149,12 @@ export class Admin extends ClearingHouse {
 		marginRatioPartial = 625,
 		marginRatioMaintenance = 500
 	): Promise<TransactionSignature> {
-		if (this.getMarketsAccount().markets[marketIndex.toNumber()].initialized) {
-			throw Error(`MarketIndex ${marketIndex.toNumber()} already initialized`);
-		}
+		const marketPublicKey = await getMarketPublicKey(
+			this.program.programId,
+			this.getStateAccount().numberOfMarkets
+		);
 
 		const initializeMarketTx = await this.program.transaction.initializeMarket(
-			marketIndex,
 			baseAssetReserve,
 			quoteAssetReserve,
 			periodicity,
@@ -243,11 +168,27 @@ export class Admin extends ClearingHouse {
 					state: await this.getStatePublicKey(),
 					admin: this.wallet.publicKey,
 					oracle: priceOracle,
-					markets: this.getStateAccount().markets,
+					market: marketPublicKey,
+					rent: SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
 				},
 			}
 		);
-		return await this.txSender.send(initializeMarketTx, [], this.opts);
+		const { txSig } = await this.txSender.send(
+			initializeMarketTx,
+			[],
+			this.opts
+		);
+
+		await this.accountSubscriber.addMarket(
+			this.getStateAccount().numberOfMarkets
+		);
+		await this.accountSubscriber.addOracle({
+			source: oracleSource,
+			publicKey: priceOracle,
+		});
+
+		return txSig;
 	}
 
 	public async moveAmmPrice(
@@ -255,16 +196,19 @@ export class Admin extends ClearingHouse {
 		quoteAssetReserve: BN,
 		marketIndex: BN
 	): Promise<TransactionSignature> {
-		const state = this.getStateAccount();
+		const marketPublicKey = await getMarketPublicKey(
+			this.program.programId,
+			marketIndex
+		);
+
 		return await this.program.rpc.moveAmmPrice(
 			baseAssetReserve,
 			quoteAssetReserve,
-			marketIndex,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
 					admin: this.wallet.publicKey,
-					markets: state.markets,
+					market: marketPublicKey,
 				},
 			}
 		);
@@ -274,51 +218,28 @@ export class Admin extends ClearingHouse {
 		sqrtK: BN,
 		marketIndex: BN
 	): Promise<TransactionSignature> {
-		const state = this.getStateAccount();
-		const markets = this.getMarketsAccount();
-		const marketData = markets.markets[marketIndex.toNumber()];
-		const ammData = marketData.amm;
-
-		return await this.program.rpc.updateK(sqrtK, marketIndex, {
+		return await this.program.rpc.updateK(sqrtK, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				admin: this.wallet.publicKey,
-				markets: state.markets,
-				curveHistory: state.extendedCurveHistory,
-				oracle: ammData.oracle,
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+				oracle: this.getMarketAccount(marketIndex).amm.oracle,
 			},
 		});
 	}
 
-	public async updateCurveHistory(): Promise<TransactionSignature> {
-		const extendedCurveHistory = anchor.web3.Keypair.generate();
-
-		const state = this.getStateAccount();
-		return await this.program.rpc.updateCurveHistory({
-			accounts: {
-				state: await this.getStatePublicKey(),
-				admin: this.wallet.publicKey,
-				curveHistory: state.curveHistory,
-				extendedCurveHistory: extendedCurveHistory.publicKey,
-			},
-			instructions: [
-				await this.program.account.extendedCurveHistory.createInstruction(
-					extendedCurveHistory
-				),
-			],
-			signers: [extendedCurveHistory],
-		});
-	}
-
 	public async moveAmmToPrice(
 		marketIndex: BN,
 		targetPrice: BN
 	): Promise<TransactionSignature> {
-		const market = this.getMarket(marketIndex);
+		const market = this.getMarketAccount(marketIndex);
 
 		const [direction, tradeSize, _] = calculateTargetPriceTrade(
 			market,
-			targetPrice
+			targetPrice,
+			new BN(1000),
+			'quote',
+			undefined //todo
 		);
 
 		const [newQuoteAssetAmount, newBaseAssetAmount] =
@@ -329,16 +250,19 @@ export class Admin extends ClearingHouse {
 				getSwapDirection('quote', direction)
 			);
 
-		const state = this.getStateAccount();
+		const marketPublicKey = await getMarketPublicKey(
+			this.program.programId,
+			marketIndex
+		);
+
 		return await this.program.rpc.moveAmmPrice(
 			newBaseAssetAmount,
 			newQuoteAssetAmount,
-			marketIndex,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
 					admin: this.wallet.publicKey,
-					markets: state.markets,
+					market: marketPublicKey,
 				},
 			}
 		);
@@ -348,18 +272,18 @@ export class Admin extends ClearingHouse {
 		newPeg: BN,
 		marketIndex: BN
 	): Promise<TransactionSignature> {
-		const state = this.getStateAccount();
-		const markets = this.getMarketsAccount();
-		const marketData = markets.markets[marketIndex.toNumber()];
-		const ammData = marketData.amm;
+		const marketPublicKey = await getMarketPublicKey(
+			this.program.programId,
+			marketIndex
+		);
+		const ammData = this.getMarketAccount(marketIndex).amm;
 
-		return await this.program.rpc.repegAmmCurve(newPeg, marketIndex, {
+		return await this.program.rpc.repegAmmCurve(newPeg, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				admin: this.wallet.publicKey,
 				oracle: ammData.oracle,
-				markets: state.markets,
-				curveHistory: state.extendedCurveHistory,
+				market: marketPublicKey,
 			},
 		});
 	}
@@ -367,18 +291,18 @@ export class Admin extends ClearingHouse {
 	public async updateAmmOracleTwap(
 		marketIndex: BN
 	): Promise<TransactionSignature> {
-		const state = this.getStateAccount();
-		const markets = this.getMarketsAccount();
-		const marketData = markets.markets[marketIndex.toNumber()];
-		const ammData = marketData.amm;
+		const ammData = this.getMarketAccount(marketIndex).amm;
+		const marketPublicKey = await getMarketPublicKey(
+			this.program.programId,
+			marketIndex
+		);
 
-		return await this.program.rpc.updateAmmOracleTwap(marketIndex, {
+		return await this.program.rpc.updateAmmOracleTwap({
 			accounts: {
 				state: await this.getStatePublicKey(),
 				admin: this.wallet.publicKey,
 				oracle: ammData.oracle,
-				markets: state.markets,
-				curveHistory: state.extendedCurveHistory,
+				market: marketPublicKey,
 			},
 		});
 	}
@@ -386,18 +310,18 @@ export class Admin extends ClearingHouse {
 	public async resetAmmOracleTwap(
 		marketIndex: BN
 	): Promise<TransactionSignature> {
-		const state = this.getStateAccount();
-		const markets = this.getMarketsAccount();
-		const marketData = markets.markets[marketIndex.toNumber()];
-		const ammData = marketData.amm;
+		const ammData = this.getMarketAccount(marketIndex).amm;
+		const marketPublicKey = await getMarketPublicKey(
+			this.program.programId,
+			marketIndex
+		);
 
-		return await this.program.rpc.resetAmmOracleTwap(marketIndex, {
+		return await this.program.rpc.resetAmmOracleTwap({
 			accounts: {
 				state: await this.getStatePublicKey(),
 				admin: this.wallet.publicKey,
 				oracle: ammData.oracle,
-				markets: state.markets,
-				curveHistory: state.extendedCurveHistory,
+				market: marketPublicKey,
 			},
 		});
 	}
@@ -407,10 +331,12 @@ export class Admin extends ClearingHouse {
 		recipient: PublicKey
 	): Promise<TransactionSignature> {
 		const state = await this.getStateAccount();
+		const bank = this.getQuoteAssetBankAccount();
 		return await this.program.rpc.withdrawFromInsuranceVault(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
+				bank: bank.pubkey,
 				insuranceVault: state.insuranceVault,
 				insuranceVaultAuthority: state.insuranceVaultAuthority,
 				recipient: recipient,
@@ -419,19 +345,24 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async withdrawFees(
+	public async withdrawFromMarketToInsuranceVault(
 		marketIndex: BN,
 		amount: BN,
 		recipient: PublicKey
 	): Promise<TransactionSignature> {
-		const state = await this.getStateAccount();
-		return await this.program.rpc.withdrawFees(marketIndex, amount, {
+		const marketPublicKey = await getMarketPublicKey(
+			this.program.programId,
+			marketIndex
+		);
+		const bank = this.getQuoteAssetBankAccount();
+		return await this.program.rpc.withdrawFromMarketToInsuranceVault(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				markets: state.markets,
-				collateralVault: state.collateralVault,
-				collateralVaultAuthority: state.collateralVaultAuthority,
+				market: marketPublicKey,
+				bank: bank.pubkey,
+				bankVault: bank.vault,
+				bankVaultAuthority: bank.vaultAuthority,
 				recipient: recipient,
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
@@ -443,21 +374,21 @@ export class Admin extends ClearingHouse {
 		amount: BN
 	): Promise<TransactionSignature> {
 		const state = await this.getStateAccount();
-		return await this.program.rpc.withdrawFromInsuranceVaultToMarket(
-			marketIndex,
-			amount,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-					markets: state.markets,
-					insuranceVault: state.insuranceVault,
-					insuranceVaultAuthority: state.insuranceVaultAuthority,
-					collateralVault: state.collateralVault,
-					tokenProgram: TOKEN_PROGRAM_ID,
-				},
-			}
-		);
+		const bank = this.getQuoteAssetBankAccount();
+
+		return await this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+				insuranceVault: state.insuranceVault,
+				insuranceVaultAuthority: state.insuranceVaultAuthority,
+				bank: bank.pubkey,
+				bankVault: bank.vault,
+				bankVaultAuthority: bank.vaultAuthority,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+		});
 	}
 
 	public async updateAdmin(admin: PublicKey): Promise<TransactionSignature> {
@@ -469,6 +400,25 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
+	public async updateCurveUpdateIntensity(
+		marketIndex: BN,
+		curveUpdateIntensity: number
+	): Promise<TransactionSignature> {
+		// assert(curveUpdateIntensity >= 0 && curveUpdateIntensity <= 100);
+		// assert(Number.isInteger(curveUpdateIntensity));
+
+		return await this.program.rpc.updateCurveUpdateIntensity(
+			curveUpdateIntensity,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					market: await getMarketPublicKey(this.program.programId, marketIndex),
+				},
+			}
+		);
+	}
+
 	public async updateMarginRatio(
 		marketIndex: BN,
 		marginRatioInitial: number,
@@ -476,7 +426,6 @@ export class Admin extends ClearingHouse {
 		marginRatioMaintenance: number
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateMarginRatio(
-			marketIndex,
 			marginRatioInitial,
 			marginRatioPartial,
 			marginRatioMaintenance,
@@ -484,7 +433,7 @@ export class Admin extends ClearingHouse {
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					markets: this.getStateAccount().markets,
+					market: await getMarketPublicKey(this.program.programId, marketIndex),
 				},
 			}
 		);
@@ -494,17 +443,26 @@ export class Admin extends ClearingHouse {
 		marketIndex: BN,
 		baseSpread: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMarketBaseSpread(
-			marketIndex,
-			baseSpread,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-					markets: this.getStateAccount().markets,
-				},
-			}
-		);
+		return await this.program.rpc.updateMarketBaseSpread(baseSpread, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+			},
+		});
+	}
+
+	public async updateMarketMaxSpread(
+		marketIndex: BN,
+		maxSpread: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMarketMaxSpread(maxSpread, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+			},
+		});
 	}
 
 	public async updatePartialLiquidationClosePercentage(
@@ -592,7 +550,6 @@ export class Admin extends ClearingHouse {
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					orderState: await this.getOrderStatePublicKey(),
 				},
 			}
 		);
@@ -623,52 +580,42 @@ export class Admin extends ClearingHouse {
 		oracle: PublicKey,
 		oracleSource: OracleSource
 	): Promise<TransactionSignature> {
-		const state = this.getStateAccount();
-		return await this.program.rpc.updateMarketOracle(
-			marketIndex,
-			oracle,
-			oracleSource,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-					markets: state.markets,
-				},
-			}
-		);
+		return await this.program.rpc.updateMarketOracle(oracle, oracleSource, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+			},
+		});
 	}
 
 	public async updateMarketMinimumQuoteAssetTradeSize(
 		marketIndex: BN,
 		minimumTradeSize: BN
 	): Promise<TransactionSignature> {
-		const state = this.getStateAccount();
 		return await this.program.rpc.updateMarketMinimumQuoteAssetTradeSize(
-			marketIndex,
 			minimumTradeSize,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					markets: state.markets,
+					market: await getMarketPublicKey(this.program.programId, marketIndex),
 				},
 			}
 		);
 	}
 
-	public async updateMarketMinimumBaseAssetTradeSize(
+	public async updateMarketBaseAssetAmountStepSize(
 		marketIndex: BN,
-		minimumTradeSize: BN
+		stepSize: BN
 	): Promise<TransactionSignature> {
-		const state = this.getStateAccount();
-		return await this.program.rpc.updateMarketMinimumBaseAssetTradeSize(
-			marketIndex,
-			minimumTradeSize,
+		return await this.program.rpc.updateMarketBaseAssetAmountStepSize(
+			stepSize,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					markets: state.markets,
+					market: await getMarketPublicKey(this.program.programId, marketIndex),
 				},
 			}
 		);
@@ -736,83 +683,47 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async transferFromInsuranceVaultToCollateralVault(): Promise<TransactionSignature> {
-		const state = await this.getStateAccount();
-		return await this.program.rpc.transferFromInsuranceVaultToCollateralVault({
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				insuranceVault: state.insuranceVault,
-				insuranceVaultAuthority: state.insuranceVaultAuthority,
-				collateralVault: state.collateralVault,
-				tokenProgram: TOKEN_PROGRAM_ID,
-			},
-		});
-	}
-
-	public async adminUpdateUserForgoSettlement(
-		authority: PublicKey
+	public async updateAuctionDuration(
+		minDuration: BN | number,
+		maxDuration: BN | number
 	): Promise<TransactionSignature> {
-		const user = await getUserAccountPublicKey(
-			this.program.programId,
-			authority
-		);
-
-		return await this.program.rpc.adminUpdateUserForgoSettlement({
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				user: user,
-			},
-		});
-	}
-
-	public async initializeSettlementState(): Promise<TransactionSignature> {
-		const settlementState = await getSettlementStatePublicKey(
-			this.program.programId
+		return await this.program.rpc.updateAuctionDuration(
+			typeof minDuration === 'number' ? minDuration : minDuration.toNumber(),
+			typeof maxDuration === 'number' ? maxDuration : maxDuration.toNumber(),
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
 		);
-
-		const settlementSize = await this.getTotalSettlementSize();
-
-		return await this.program.rpc.initializeSettlementState(settlementSize, {
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				settlementState: settlementState,
-				rent: SYSVAR_RENT_PUBKEY,
-				systemProgram: anchor.web3.SystemProgram.programId,
-				collateralVault: (await this.getStateAccount()).collateralVault,
-			},
-		});
 	}
 
-	public async updateSettlementState(): Promise<TransactionSignature> {
-		const settlementState = await getSettlementStatePublicKey(
-			this.program.programId
+	public async updateMaxBaseAssetAmountRatio(
+		marketIndex: BN,
+		maxBaseAssetAmountRatio: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMaxBaseAssetAmountRatio(
+			maxBaseAssetAmountRatio,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					market: this.getMarketAccount(marketIndex).pubkey,
+				},
+			}
 		);
-
-		return await this.program.rpc.updateSettlementState({
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				settlementState: settlementState,
-				collateralVault: (await this.getStateAccount()).collateralVault,
-			},
-		});
 	}
 
-	public async updateSettlementStateEnabled(
-		enabled: boolean
+	public async updateMaxSlippageRatio(
+		marketIndex: BN,
+		maxSlippageRatio: number
 	): Promise<TransactionSignature> {
-		const settlementState = await getSettlementStatePublicKey(
-			this.program.programId
-		);
-
-		return await this.program.rpc.updateSettlementStateEnabled(enabled, {
+		return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				settlementState: settlementState,
+				market: this.getMarketAccount(marketIndex).pubkey,
 			},
 		});
 	}