@drift-labs/sdk 0.2.0-master.25 → 0.2.0-master.27

package/src/addresses/pda.ts

@@ -85,45 +85,30 @@ export async function getMarketPublicKey(
 	)[0];
 }
 
-export async function getBankPublicKey(
+export async function getSpotMarketPublicKey(
 	programId: PublicKey,
-	bankIndex: BN
-): Promise<PublicKey> {
-	return (
-		await anchor.web3.PublicKey.findProgramAddress(
-			[
-				Buffer.from(anchor.utils.bytes.utf8.encode('bank')),
-				bankIndex.toArrayLike(Buffer, 'le', 8),
-			],
-			programId
-		)
-	)[0];
-}
-
-export async function getBankVaultPublicKey(
-	programId: PublicKey,
-	bankIndex: BN
+	marketIndex: BN
 ): Promise<PublicKey> {
 	return (
 		await anchor.web3.PublicKey.findProgramAddress(
 			[
-				Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault')),
-				bankIndex.toArrayLike(Buffer, 'le', 8),
+				Buffer.from(anchor.utils.bytes.utf8.encode('spot_market')),
+				marketIndex.toArrayLike(Buffer, 'le', 8),
 			],
 			programId
 		)
 	)[0];
 }
 
-export async function getBankVaultAuthorityPublicKey(
+export async function getSpotMarketVaultPublicKey(
 	programId: PublicKey,
-	bankIndex: BN
+	marketIndex: BN
 ): Promise<PublicKey> {
 	return (
 		await anchor.web3.PublicKey.findProgramAddress(
 			[
-				Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault_authority')),
-				bankIndex.toArrayLike(Buffer, 'le', 8),
+				Buffer.from(anchor.utils.bytes.utf8.encode('spot_market_vault')),
+				marketIndex.toArrayLike(Buffer, 'le', 8),
 			],
 			programId
 		)
@@ -132,30 +117,13 @@ export async function getBankVaultAuthorityPublicKey(
 
 export async function getInsuranceFundVaultPublicKey(
 	programId: PublicKey,
-	bankIndex: BN
+	marketIndex: BN
 ): Promise<PublicKey> {
 	return (
 		await anchor.web3.PublicKey.findProgramAddress(
 			[
 				Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault')),
-				bankIndex.toArrayLike(Buffer, 'le', 8),
-			],
-			programId
-		)
-	)[0];
-}
-
-export async function getInsuranceFundVaultAuthorityPublicKey(
-	programId: PublicKey,
-	bankIndex: BN
-): Promise<PublicKey> {
-	return (
-		await anchor.web3.PublicKey.findProgramAddress(
-			[
-				Buffer.from(
-					anchor.utils.bytes.utf8.encode('insurance_fund_vault_authority')
-				),
-				bankIndex.toArrayLike(Buffer, 'le', 8),
+				marketIndex.toArrayLike(Buffer, 'le', 8),
 			],
 			programId
 		)
@@ -165,13 +133,13 @@ export async function getInsuranceFundVaultAuthorityPublicKey(
 export function getInsuranceFundStakeAccountPublicKey(
 	programId: PublicKey,
 	authority: PublicKey,
-	bankIndex: BN
+	marketIndex: BN
 ): PublicKey {
 	return anchor.web3.PublicKey.findProgramAddressSync(
 		[
 			Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_stake')),
 			authority.toBuffer(),
-			bankIndex.toArrayLike(Buffer, 'le', 8),
+			marketIndex.toArrayLike(Buffer, 'le', 8),
 		],
 		programId
 	)[0];
@@ -185,3 +153,40 @@ export function getClearingHouseSignerPublicKey(
 		programId
 	)[0];
 }
+
+export function getSerumOpenOrdersPublicKey(
+	programId: PublicKey,
+	market: PublicKey
+): PublicKey {
+	return anchor.web3.PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('serum_open_orders')),
+			market.toBuffer(),
+		],
+		programId
+	)[0];
+}
+
+export function getSerumSignerPublicKey(
+	programId: PublicKey,
+	market: PublicKey,
+	nonce: BN
+): PublicKey {
+	return anchor.web3.PublicKey.createProgramAddressSync(
+		[market.toBuffer(), nonce.toArrayLike(Buffer, 'le', 8)],
+		programId
+	);
+}
+
+export function getSerumFulfillmentConfigPublicKey(
+	programId: PublicKey,
+	market: PublicKey
+): PublicKey {
+	return anchor.web3.PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('serum_fulfillment_config')),
+			market.toBuffer(),
+		],
+		programId
+	)[0];
+}

package/src/admin.ts

@@ -13,11 +13,14 @@ import { BN } from '@project-serum/anchor';
 import * as anchor from '@project-serum/anchor';
 import {
 	getClearingHouseStateAccountPublicKeyAndNonce,
-	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, ZERO } from './constants/numericConstants';
@@ -71,7 +74,7 @@ export class Admin extends ClearingHouse {
 		return [initializeTxSig];
 	}
 
-	public async initializeBank(
+	public async initializeSpotMarket(
 		mint: PublicKey,
 		optimalUtilization: BN,
 		optimalRate: BN,
@@ -85,20 +88,23 @@ export class Admin extends ClearingHouse {
 		imfFactor = new BN(0),
 		liquidationFee = ZERO
 	): 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 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,
@@ -113,11 +119,11 @@ export class Admin extends ClearingHouse {
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					bank,
-					bankVault,
+					spotMarket,
+					spotMarketVault,
 					insuranceFundVault,
 					clearingHouseSigner: this.getSignerPublicKey(),
-					bankMint: mint,
+					spotMarketMint: mint,
 					oracle,
 					rent: SYSVAR_RENT_PUBKEY,
 					systemProgram: anchor.web3.SystemProgram.programId,
@@ -128,7 +134,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,
@@ -137,6 +143,41 @@ export class Admin extends ClearingHouse {
 		return txSig;
 	}
 
+	public async initializeSerumFulfillmentConfig(
+		marketIndex: BN,
+		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,
@@ -179,7 +220,7 @@ export class Admin extends ClearingHouse {
 			this.opts
 		);
 
-		await this.accountSubscriber.addMarket(
+		await this.accountSubscriber.addPerpMarket(
 			this.getStateAccount().numberOfMarkets
 		);
 		await this.accountSubscriber.addOracle({
@@ -191,23 +232,29 @@ export class Admin extends ClearingHouse {
 	}
 
 	public async moveAmmPrice(
+		marketIndex: BN,
 		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,
 				},
 			}
 		);
@@ -222,16 +269,29 @@ export class Admin extends ClearingHouse {
 				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 moveAmmToPrice(
+	public async updateConcentrationScale(
 		marketIndex: BN,
+		concentrationScale: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateConcentrationScale(concentrationScale, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				admin: this.wallet.publicKey,
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+			},
+		});
+	}
+
+	public async moveAmmToPrice(
+		perpMarketIndex: BN,
 		targetPrice: BN
 	): Promise<TransactionSignature> {
-		const market = this.getMarketAccount(marketIndex);
+		const market = this.getPerpMarketAccount(perpMarketIndex);
 
 		const [direction, tradeSize, _] = calculateTargetPriceTrade(
 			market,
@@ -251,17 +311,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,
 				},
 			}
 		);
@@ -275,7 +336,7 @@ export class Admin extends ClearingHouse {
 			this.program.programId,
 			marketIndex
 		);
-		const ammData = this.getMarketAccount(marketIndex).amm;
+		const ammData = this.getPerpMarketAccount(marketIndex).amm;
 
 		return await this.program.rpc.repegAmmCurve(newPeg, {
 			accounts: {
@@ -290,7 +351,7 @@ export class Admin extends ClearingHouse {
 	public async updateAmmOracleTwap(
 		marketIndex: BN
 	): Promise<TransactionSignature> {
-		const ammData = this.getMarketAccount(marketIndex).amm;
+		const ammData = this.getPerpMarketAccount(marketIndex).amm;
 		const marketPublicKey = await getMarketPublicKey(
 			this.program.programId,
 			marketIndex
@@ -309,7 +370,7 @@ export class Admin extends ClearingHouse {
 	public async resetAmmOracleTwap(
 		marketIndex: BN
 	): Promise<TransactionSignature> {
-		const ammData = this.getMarketAccount(marketIndex).amm;
+		const ammData = this.getPerpMarketAccount(marketIndex).amm;
 		const marketPublicKey = await getMarketPublicKey(
 			this.program.programId,
 			marketIndex
@@ -330,12 +391,12 @@ export class Admin extends ClearingHouse {
 		recipient: PublicKey
 	): Promise<TransactionSignature> {
 		const state = await this.getStateAccount();
-		const bank = this.getQuoteAssetBankAccount();
+		const spotMarket = this.getQuoteSpotMarketAccount();
 		return await this.program.rpc.withdrawFromInsuranceVault(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				bank: bank.pubkey,
+				spotMarket: spotMarket.pubkey,
 				insuranceVault: state.insuranceVault,
 				clearingHouseSigner: this.getSignerPublicKey(),
 				recipient: recipient,
@@ -353,14 +414,14 @@ export class Admin extends ClearingHouse {
 			this.program.programId,
 			marketIndex
 		);
-		const bank = this.getQuoteAssetBankAccount();
+		const spotMarket = this.getQuoteSpotMarketAccount();
 		return await this.program.rpc.withdrawFromMarketToInsuranceVault(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
 				market: marketPublicKey,
-				bank: bank.pubkey,
-				bankVault: bank.vault,
+				spotMarket: spotMarket.pubkey,
+				spotMarketVault: spotMarket.vault,
 				clearingHouseSigner: this.getSignerPublicKey(),
 				recipient: recipient,
 				tokenProgram: TOKEN_PROGRAM_ID,
@@ -373,7 +434,7 @@ export class Admin extends ClearingHouse {
 		amount: BN
 	): Promise<TransactionSignature> {
 		const state = await this.getStateAccount();
-		const bank = this.getQuoteAssetBankAccount();
+		const spotMarket = this.getQuoteSpotMarketAccount();
 
 		return await this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
 			accounts: {
@@ -382,8 +443,8 @@ export class Admin extends ClearingHouse {
 				market: await getMarketPublicKey(this.program.programId, marketIndex),
 				insuranceVault: state.insuranceVault,
 				clearingHouseSigner: this.getSignerPublicKey(),
-				bank: bank.pubkey,
-				bankVault: bank.vault,
+				quoteSpotMarket: spotMarket.pubkey,
+				spotMarketVault: spotMarket.vault,
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
 		});
@@ -584,54 +645,80 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async updateBankWithdrawGuardThreshold(
-		bankIndex: BN,
+	public async updateWithdrawGuardThreshold(
+		marketIndex: BN,
 		withdrawGuardThreshold: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateBankWithdrawGuardThreshold(
+		return await this.program.rpc.updateWithdrawGuardThreshold(
 			withdrawGuardThreshold,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					bank: await getBankPublicKey(this.program.programId, bankIndex),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						marketIndex
+					),
 				},
 			}
 		);
 	}
 
-	public async updateBankIfFactor(
-		bankIndex: BN,
+	public async updateSpotMarketIfFactor(
+		marketIndex: BN,
 		userIfFactor: BN,
-		totalIfFactor: BN,
-		liquidationIfFactor: BN
+		totalIfFactor: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateBankIfFactor(
-			bankIndex,
+		return await this.program.rpc.updateSpotMarketIfFactor(
+			marketIndex,
 			userIfFactor,
 			totalIfFactor,
-			liquidationIfFactor,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					bank: await getBankPublicKey(this.program.programId, bankIndex),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						marketIndex
+					),
 				},
 			}
 		);
 	}
 
-	public async updateBankInsuranceWithdrawEscrowPeriod(
-		bankIndex: BN,
+	public async updateSpotMarketRevenueSettlePeriod(
+		marketIndex: BN,
+		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 updateInsuranceWithdrawEscrowPeriod(
+		marketIndex: BN,
 		insuranceWithdrawEscrowPeriod: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateBankInsuranceWithdrawEscrowPeriod(
+		return await this.program.rpc.updateInsuranceWithdrawEscrowPeriod(
 			insuranceWithdrawEscrowPeriod,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					bank: await getBankPublicKey(this.program.programId, bankIndex),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						marketIndex
+					),
 				},
 			}
 		);
@@ -696,6 +783,22 @@ export class Admin extends ClearingHouse {
 		);
 	}
 
+	public async updateMarketExpiry(
+		perpMarketIndex: BN,
+		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> {
@@ -757,13 +860,25 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async updateAuctionDuration(
-		minDuration: BN | number,
-		maxDuration: BN | number
+	public async updatePerpAuctionDuration(
+		minDuration: BN | number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateAuctionDuration(
+		return await this.program.rpc.updatePerpAuctionDuration(
 			typeof minDuration === 'number' ? minDuration : minDuration.toNumber(),
-			typeof maxDuration === 'number' ? maxDuration : maxDuration.toNumber(),
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
+	}
+
+	public async updateSpotAuctionDuration(
+		defaultAuctionDuration: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateSpotAuctionDuration(
+			defaultAuctionDuration,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
@@ -783,7 +898,7 @@ export class Admin extends ClearingHouse {
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					market: this.getMarketAccount(marketIndex).pubkey,
+					market: this.getPerpMarketAccount(marketIndex).pubkey,
 				},
 			}
 		);
@@ -797,8 +912,28 @@ export class Admin extends ClearingHouse {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
-				market: this.getMarketAccount(marketIndex).pubkey,
+				market: this.getPerpMarketAccount(marketIndex).pubkey,
 			},
 		});
 	}
+
+	public async updateMarketMaxImbalances(
+		marketIndex: BN,
+		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),
+				},
+			}
+		);
+	}
 }