@drift-labs/sdk 2.87.0-beta.0 → 2.87.0-beta.10

package/src/index.ts

@@ -73,6 +73,8 @@ export * from './serum/serumFulfillmentConfigMap';
 export * from './phoenix/phoenixSubscriber';
 export * from './priorityFee';
 export * from './phoenix/phoenixFulfillmentConfigMap';
+export * from './openbook/openbookV2Subscriber';
+export * from './openbook/openbookV2FulfillmentConfigMap';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
 export * from './tx/whileValidTxSender';

package/src/math/spotMarket.ts

@@ -5,8 +5,12 @@ import {
 	SpotBalanceType,
 	SpotMarketAccount,
 } from '../types';
-import { calculateAssetWeight, calculateLiabilityWeight } from './spotBalance';
-import { MARGIN_PRECISION } from '../constants/numericConstants';
+import {
+	calculateAssetWeight,
+	calculateLiabilityWeight,
+	getTokenAmount,
+} from './spotBalance';
+import { MARGIN_PRECISION, ZERO } from '../constants/numericConstants';
 import { numberToSafeBN } from './utils';
 
 export function castNumberToSpotPrecision(
@@ -54,3 +58,25 @@ export function calculateSpotMarketMarginRatio(
 
 	return marginRatio;
 }
+
+/**
+ * Returns the maximum remaining deposit that can be made to the spot market. If the maxTokenDeposits on the market is zero then there is no limit and this function will also return zero. (so that needs to be checked)
+ * @param market
+ * @returns
+ */
+export function calculateMaxRemainingDeposit(market: SpotMarketAccount) {
+	const marketMaxTokenDeposits = market.maxTokenDeposits;
+
+	if (marketMaxTokenDeposits.eq(ZERO)) {
+		// If the maxTokenDeposits is set to zero then that means there is no limit. Return the largest number we can to represent infinite available deposit.
+		return ZERO;
+	}
+
+	const totalDepositsTokenAmount = getTokenAmount(
+		market.depositBalance,
+		market,
+		SpotBalanceType.DEPOSIT
+	);
+
+	return marketMaxTokenDeposits.sub(totalDepositsTokenAmount);
+}

package/src/openbook/openbookV2FulfillmentConfigMap.ts

@@ -0,0 +1,29 @@
+import { PublicKey } from '@solana/web3.js';
+import { OpenbookV2FulfillmentConfigAccount } from '../types';
+import { DriftClient } from '../driftClient';
+
+export class OpenbookV2FulfillmentConfigMap {
+	driftClient: DriftClient;
+	map = new Map<number, OpenbookV2FulfillmentConfigAccount>();
+
+	public constructor(driftClient: DriftClient) {
+		this.driftClient = driftClient;
+	}
+
+	public async add(
+		marketIndex: number,
+		openbookV2MarketAddress: PublicKey
+	): Promise<void> {
+		const account = await this.driftClient.getOpenbookV2FulfillmentConfig(
+			openbookV2MarketAddress
+		);
+
+		this.map.set(marketIndex, account);
+	}
+
+	public get(
+		marketIndex: number
+	): OpenbookV2FulfillmentConfigAccount | undefined {
+		return this.map.get(marketIndex);
+	}
+}

package/src/openbook/openbookV2Subscriber.ts

@@ -0,0 +1,165 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { PRICE_PRECISION } from '../constants/numericConstants';
+import { AnchorProvider, BN, Idl, Program, Wallet } from '@coral-xyz/anchor';
+import { L2Level, L2OrderBookGenerator } from '../dlob/orderBookLevels';
+import { Market, OpenBookV2Client } from '@openbook-dex/openbook-v2';
+import openbookV2Idl from '../idl/openbook.json';
+
+export type OpenbookV2SubscriberConfig = {
+	connection: Connection;
+	programId: PublicKey;
+	marketAddress: PublicKey;
+	accountSubscription:
+		| {
+				// enables use to add web sockets in the future
+				type: 'polling';
+				accountLoader: BulkAccountLoader;
+		  }
+		| {
+				type: 'websocket';
+		  };
+};
+
+export class OpenbookV2Subscriber implements L2OrderBookGenerator {
+	connection: Connection;
+	programId: PublicKey;
+	marketAddress: PublicKey;
+	subscriptionType: 'polling' | 'websocket';
+	accountLoader: BulkAccountLoader | undefined;
+	subscribed: boolean;
+	market: Market;
+	marketCallbackId: string | number;
+	client: OpenBookV2Client;
+
+	public constructor(config: OpenbookV2SubscriberConfig) {
+		this.connection = config.connection;
+		this.programId = config.programId;
+		this.marketAddress = config.marketAddress;
+		this.subscribed = false;
+		if (config.accountSubscription.type === 'polling') {
+			this.subscriptionType = 'polling';
+			this.accountLoader = config.accountSubscription.accountLoader;
+		} else {
+			this.subscriptionType = 'websocket';
+		}
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.subscribed === true) {
+			return;
+		}
+
+		const anchorProvider = new AnchorProvider(
+			this.connection,
+			new Wallet(Keypair.generate()),
+			{}
+		);
+		const openbookV2Program = new Program(
+			openbookV2Idl as Idl,
+			this.programId,
+			anchorProvider
+		);
+		this.client = new OpenBookV2Client(anchorProvider);
+		const market = await Market.load(this.client, this.marketAddress);
+		this.market = await market.loadOrderBook();
+
+		if (this.subscriptionType === 'websocket') {
+			this.marketCallbackId = this.connection.onAccountChange(
+				this.marketAddress,
+				async (accountInfo, _) => {
+					const marketRaw = openbookV2Program.coder.accounts.decode(
+						'Market',
+						accountInfo.data
+					);
+					this.market = new Market(this.client, this.marketAddress, marketRaw);
+					await this.market.loadOrderBook();
+				}
+			);
+		} else {
+			this.marketCallbackId = await this.accountLoader.addAccount(
+				this.marketAddress,
+				(buffer, _) => {
+					const marketRaw = openbookV2Program.coder.accounts.decode(
+						'Market',
+						buffer
+					);
+					this.market = new Market(this.client, this.marketAddress, marketRaw);
+					(async () => {
+						await this.market.loadOrderBook();
+					})();
+				}
+			);
+		}
+
+		this.subscribed = true;
+	}
+
+	public getBestBid(): BN | undefined {
+		const bestBid = this.market.bids.best();
+
+		if (bestBid === undefined) {
+			return undefined;
+		}
+
+		return new BN(Math.floor(bestBid.price * PRICE_PRECISION.toNumber()));
+	}
+
+	public getBestAsk(): BN | undefined {
+		const bestAsk = this.market.asks.best();
+
+		if (bestAsk === undefined) {
+			return undefined;
+		}
+
+		return new BN(Math.floor(bestAsk.price * PRICE_PRECISION.toNumber()));
+	}
+
+	public getL2Bids(): Generator<L2Level> {
+		return this.getL2Levels('bids');
+	}
+
+	public getL2Asks(): Generator<L2Level> {
+		return this.getL2Levels('asks');
+	}
+
+	*getL2Levels(side: 'bids' | 'asks'): Generator<L2Level> {
+		const basePrecision = Math.ceil(
+			1 / this.market.baseNativeFactor.toNumber()
+		);
+		const pricePrecision = PRICE_PRECISION.toNumber();
+
+		const levels = side === 'bids' ? this.market.bids : this.market.asks;
+
+		for (const order of levels.items()) {
+			const size = new BN(order.size * basePrecision);
+			const price = new BN(order.price * pricePrecision);
+			yield {
+				price,
+				size,
+				sources: {
+					openbook: size,
+				},
+			};
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscribed) {
+			return;
+		}
+
+		if (this.subscriptionType === 'websocket') {
+			await this.connection.removeAccountChangeListener(
+				this.marketCallbackId as number
+			);
+		} else {
+			this.accountLoader.removeAccount(
+				this.marketAddress,
+				this.marketCallbackId as string
+			);
+		}
+
+		this.subscribed = false;
+	}
+}

package/src/oracles/switchboardOnDemandClient.ts

@@ -0,0 +1,56 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN } from '@coral-xyz/anchor';
+import switchboardOnDemandIdl from '../idl/switchboard_on_demand_30.json';
+import { PRICE_PRECISION_EXP } from '../constants/numericConstants';
+import {
+	BorshAccountsCoder as BorshAccountsCoder30,
+	Idl as Idl30,
+} from '@coral-xyz/anchor-30';
+
+const SB_PRECISION_EXP = new BN(18);
+const SB_PRECISION = new BN(10).pow(SB_PRECISION_EXP.sub(PRICE_PRECISION_EXP));
+
+type PullFeedAccountData = {
+	result: {
+		value: BN;
+		std_dev: BN;
+		mean: BN;
+		slot: BN;
+		range: BN;
+	};
+	last_update_timestamp: BN;
+	max_variance: BN;
+	min_responses: BN;
+};
+
+export class SwitchboardOnDemandClient implements OracleClient {
+	connection: Connection;
+	coder: BorshAccountsCoder30;
+
+	public constructor(connection: Connection) {
+		this.connection = connection;
+		this.coder = new BorshAccountsCoder30(switchboardOnDemandIdl as Idl30);
+	}
+
+	public async getOraclePriceData(
+		pricePublicKey: PublicKey
+	): Promise<OraclePriceData> {
+		const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+		return this.getOraclePriceDataFromBuffer(accountInfo.data);
+	}
+
+	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
+		const pullFeedAccountData = this.coder.decodeUnchecked(
+			'PullFeedAccountData',
+			buffer
+		) as PullFeedAccountData;
+
+		return {
+			price: pullFeedAccountData.result.value.div(SB_PRECISION),
+			slot: pullFeedAccountData.result.slot,
+			confidence: pullFeedAccountData.result.range.div(SB_PRECISION),
+			hasSufficientNumberOfDataPoints: true,
+		};
+	}
+}

package/src/types.ts

@@ -117,6 +117,7 @@ export class OracleSource {
 	static readonly PYTH_STABLE_COIN = { pythStableCoin: {} };
 	static readonly PYTH_STABLE_COIN_PULL = { pythStableCoinPull: {} };
 	static readonly Prelaunch = { prelaunch: {} };
+	static readonly SWITCHBOARD_ON_DEMAND = { switchboardOnDemand: {} };
 }
 
 export class OrderType {
@@ -575,6 +576,16 @@ export type SwapRecord = {
 	fee: BN;
 };
 
+export type SpotMarketVaultDepositRecord = {
+	ts: BN;
+	marketIndex: number;
+	depositBalance: BN;
+	cumulativeDepositInterestBefore: BN;
+	cumulativeDepositInterestAfter: BN;
+	depositTokenAmountBefore: BN;
+	amount: BN;
+};
+
 export type StateAccount = {
 	admin: PublicKey;
 	exchangeStatus: number;
@@ -745,6 +756,8 @@ export type SpotMarketAccount = {
 	fuelBoostTaker: number;
 	fuelBoostMaker: number;
 	fuelBoostInsurance: number;
+
+	tokenProgram: number;
 };
 
 export type PoolBalance = {

package/tests/ci/verifyConstants.ts

@@ -19,12 +19,9 @@ describe('Verify Constants', function () {
 	const MAINNET_RPC_ENDPOINT = process.env.MAINNET_RPC_ENDPOINT;
 	const DEVNET_RPC_ENDPOINT = process.env.DEVNET_RPC_ENDPOINT;
 
-	if (MAINNET_RPC_ENDPOINT === undefined) {
-		throw new Error('MAINNET_RPC_ENDPOINT not found in .env');
-	}
-
-	if (DEVNET_RPC_ENDPOINT === undefined) {
-		throw new Error('DEVNET_RPC_ENDPOINT not found in .env');
+	// avoid breaking pre-commit
+	if (MAINNET_RPC_ENDPOINT === undefined && DEVNET_RPC_ENDPOINT === undefined) {
+		return;
 	}
 
 	const wallet = new Wallet(Keypair.generate());

package/tests/subscriber/openbook.ts

@@ -0,0 +1,58 @@
+import { OpenbookV2Subscriber, PRICE_PRECISION } from '../../lib';
+import { Connection, PublicKey } from '@solana/web3.js';
+
+describe('openbook v2 subscriber', function () {
+	this.timeout(100_000);
+
+	it('works', async function () {
+		const connection = new Connection(
+			process.env.MAINNET_RPC_ENDPOINT as string
+		);
+		const solUsdc = new PublicKey(
+			'AFgkED1FUVfBe2trPUDqSqK9QKd4stJrfzq5q1RwAFTa'
+		);
+		const openbook = new PublicKey(
+			'opnb2LAfJYbRMAHHvqjCwQxanZn7ReEHp1k81EohpZb'
+		);
+
+		const openbookV2Subscriber = new OpenbookV2Subscriber({
+			connection,
+			programId: openbook,
+			marketAddress: solUsdc,
+			accountSubscription: {
+				type: 'websocket',
+			},
+		});
+
+		await openbookV2Subscriber.subscribe();
+
+		// wait for updates
+		await new Promise((resolve) => setTimeout(resolve, 5_000));
+
+		const basePrecision = Math.ceil(
+			1 / openbookV2Subscriber.market.baseNativeFactor.toNumber()
+		);
+
+		console.log('Bids');
+		for (const bid of openbookV2Subscriber.getL2Bids()) {
+			console.log('Price: ', bid.price.toNumber() / PRICE_PRECISION.toNumber());
+			console.log('Size: ', bid.size.toNumber() / basePrecision);
+			console.log('Source: ', bid.sources);
+		}
+
+		console.log('Asks');
+		for (const ask of openbookV2Subscriber.getL2Asks()) {
+			console.log('Price: ', ask.price.toNumber() / PRICE_PRECISION.toNumber());
+			console.log('Size: ', ask.size.toNumber() / basePrecision);
+			console.log('Source: ', ask.sources);
+		}
+
+		const bestBid = await openbookV2Subscriber.getBestBid();
+		console.log('Best bid:', bestBid.toNumber());
+
+		const bestAsk = await openbookV2Subscriber.getBestAsk();
+		console.log('Best ask:', bestAsk.toNumber());
+
+		await openbookV2Subscriber.unsubscribe();
+	});
+});