@drift-labs/sdk-browser 2.104.0-beta.21

package/src/math/userStatus.ts

@@ -0,0 +1,5 @@
+import { UserAccount, UserStatus } from '..';
+
+export function isUserProtectedMaker(userAccount: UserAccount): boolean {
+	return (userAccount.status & UserStatus.PROTECTED_MAKER) > 0;
+}

package/src/math/utils.ts

@@ -0,0 +1,120 @@
+import { BN, ONE, ZERO } from '../';
+
+export function clampBN(x: BN, min: BN, max: BN): BN {
+	return BN.max(min, BN.min(x, max));
+}
+
+export const squareRootBN = (n: BN): BN => {
+	if (n.lt(new BN(0))) {
+		throw new Error('Sqrt only works on non-negtiave inputs');
+	}
+	if (n.lt(new BN(2))) {
+		return n;
+	}
+
+	const smallCand = squareRootBN(n.shrn(2)).shln(1);
+	const largeCand = smallCand.add(new BN(1));
+
+	if (largeCand.mul(largeCand).gt(n)) {
+		return smallCand;
+	} else {
+		return largeCand;
+	}
+};
+
+export const divCeil = (a: BN, b: BN): BN => {
+	const quotient = a.div(b);
+
+	const remainder = a.mod(b);
+
+	if (remainder.gt(ZERO)) {
+		return quotient.add(ONE);
+	} else {
+		return quotient;
+	}
+};
+
+export const sigNum = (x: BN): BN => {
+	return x.isNeg() ? new BN(-1) : new BN(1);
+};
+
+/**
+ * calculates the time remaining until the next update based on a rounded, "on-the-hour" update schedule
+ * this schedule is used for Perpetual Funding Rate and Revenue -> Insurance Updates
+ * @param now: current blockchain unix timestamp
+ * @param lastUpdateTs: the unix timestamp of the last update
+ * @param updatePeriod: desired interval between updates (in seconds)
+ * @returns: timeRemainingUntilUpdate (in seconds)
+ */
+export function timeRemainingUntilUpdate(
+	now: BN,
+	lastUpdateTs: BN,
+	updatePeriod: BN
+): BN {
+	const timeSinceLastUpdate = now.sub(lastUpdateTs);
+
+	// round next update time to be available on the hour
+	let nextUpdateWait = updatePeriod;
+	if (updatePeriod.gt(new BN(1))) {
+		const lastUpdateDelay = lastUpdateTs.umod(updatePeriod);
+		if (!lastUpdateDelay.isZero()) {
+			const maxDelayForNextPeriod = updatePeriod.div(new BN(3));
+
+			const twoFundingPeriods = updatePeriod.mul(new BN(2));
+
+			if (lastUpdateDelay.gt(maxDelayForNextPeriod)) {
+				// too late for on the hour next period, delay to following period
+				nextUpdateWait = twoFundingPeriods.sub(lastUpdateDelay);
+			} else {
+				// allow update on the hour
+				nextUpdateWait = updatePeriod.sub(lastUpdateDelay);
+			}
+
+			if (nextUpdateWait.gt(twoFundingPeriods)) {
+				nextUpdateWait = nextUpdateWait.sub(updatePeriod);
+			}
+		}
+	}
+	const timeRemainingUntilUpdate = nextUpdateWait
+		.sub(timeSinceLastUpdate)
+		.isNeg()
+		? ZERO
+		: nextUpdateWait.sub(timeSinceLastUpdate);
+
+	return timeRemainingUntilUpdate;
+}
+
+export const checkSameDate = (dateString1: string, dateString2: string) => {
+	const date1 = new Date(dateString1);
+	const date2 = new Date(dateString2);
+
+	const isSameDate =
+		date1.getDate() === date2.getDate() &&
+		date1.getMonth() === date2.getMonth() &&
+		date1.getFullYear() === date2.getFullYear();
+
+	return isSameDate;
+};
+
+export function isBNSafe(number: number): boolean {
+	return number <= 0x1fffffffffffff;
+}
+
+/**
+ * Converts a number to BN makes sure the number is safe to convert to BN (that it does not overflow number after multiplying by precision)
+ * @param number the number to convert to BN
+ * @param precision the BN precision to use (i.e. QUOTE_PRECISION and BASE_PRECISION from drift sdk)
+ */
+export function numberToSafeBN(number: number, precision: BN): BN {
+	// check if number has decimals
+	const candidate = number * precision.toNumber();
+	if (isBNSafe(candidate)) {
+		return new BN(candidate);
+	} else {
+		if (number % 1 === 0) {
+			return new BN(number.toString()).mul(precision);
+		} else {
+			return new BN(number).mul(precision);
+		}
+	}
+}

package/src/memcmp.ts

@@ -0,0 +1,94 @@
+import { MemcmpFilter } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { BorshAccountsCoder } from '@coral-xyz/anchor';
+import { encodeName } from './userName';
+
+export function getUserFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 0,
+			bytes: bs58.encode(BorshAccountsCoder.accountDiscriminator('User')),
+		},
+	};
+}
+
+export function getNonIdleUserFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 4350,
+			bytes: bs58.encode(Uint8Array.from([0])),
+		},
+	};
+}
+
+export function getUserWithOrderFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 4352,
+			bytes: bs58.encode(Uint8Array.from([1])),
+		},
+	};
+}
+
+export function getUserWithoutOrderFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 4352,
+			bytes: bs58.encode(Uint8Array.from([0])),
+		},
+	};
+}
+
+export function getUserWithAuctionFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 4354,
+			bytes: bs58.encode(Uint8Array.from([1])),
+		},
+	};
+}
+
+export function getUserThatHasBeenLP(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 4267,
+			bytes: bs58.encode(Uint8Array.from([99])),
+		},
+	};
+}
+
+export function getUserWithName(name: string): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 72,
+			bytes: bs58.encode(Uint8Array.from(encodeName(name))),
+		},
+	};
+}
+
+export function getUserStatsFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 0,
+			bytes: bs58.encode(BorshAccountsCoder.accountDiscriminator('UserStats')),
+		},
+	};
+}
+
+export function getUserStatsIsReferredFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 188,
+			bytes: bs58.encode(Buffer.from(Uint8Array.from([2]))),
+		},
+	};
+}
+
+export function getUserStatsIsReferredOrReferrerFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 188,
+			bytes: bs58.encode(Buffer.from(Uint8Array.from([3]))),
+		},
+	};
+}

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
+					);
+					const market = new Market(this.client, this.marketAddress, marketRaw);
+					await market.loadOrderBook();
+					this.market = market;
+				}
+			);
+		} else {
+			this.marketCallbackId = await this.accountLoader.addAccount(
+				this.marketAddress,
+				async (buffer, _) => {
+					const marketRaw = openbookV2Program.coder.accounts.decode(
+						'Market',
+						buffer
+					);
+					const market = new Market(this.client, this.marketAddress, marketRaw);
+					await market.loadOrderBook();
+					this.market = market;
+				}
+			);
+		}
+
+		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/oracleClientCache.ts

@@ -0,0 +1,25 @@
+import { OracleClient } from './types';
+import { OracleSource } from '../types';
+import { getOracleClient } from '../factory/oracleClient';
+import { Connection } from '@solana/web3.js';
+import { Program } from '@coral-xyz/anchor';
+
+export class OracleClientCache {
+	cache = new Map<string, OracleClient>();
+	public constructor() {}
+
+	public get(
+		oracleSource: OracleSource,
+		connection: Connection,
+		program: Program
+	) {
+		const key = Object.keys(oracleSource)[0];
+		if (this.cache.has(key)) {
+			return this.cache.get(key);
+		}
+
+		const client = getOracleClient(oracleSource, connection, program);
+		this.cache.set(key, client);
+		return client;
+	}
+}

package/src/oracles/oracleId.ts

@@ -0,0 +1,28 @@
+import { PublicKey } from '@solana/web3.js';
+import { OracleSource, OracleSourceNum } from '../types';
+
+export function getOracleSourceNum(source: OracleSource): number {
+	if ('pyth' in source) return OracleSourceNum.PYTH;
+	if ('pyth1K' in source) return OracleSourceNum.PYTH_1K;
+	if ('pyth1M' in source) return OracleSourceNum.PYTH_1M;
+	if ('pythPull' in source) return OracleSourceNum.PYTH_PULL;
+	if ('pyth1KPull' in source) return OracleSourceNum.PYTH_1K_PULL;
+	if ('pyth1MPull' in source) return OracleSourceNum.PYTH_1M_PULL;
+	if ('switchboard' in source) return OracleSourceNum.SWITCHBOARD;
+	if ('quoteAsset' in source) return OracleSourceNum.QUOTE_ASSET;
+	if ('pythStableCoin' in source) return OracleSourceNum.PYTH_STABLE_COIN;
+	if ('pythStableCoinPull' in source)
+		return OracleSourceNum.PYTH_STABLE_COIN_PULL;
+	if ('prelaunch' in source) return OracleSourceNum.PRELAUNCH;
+	if ('switchboardOnDemand' in source)
+		return OracleSourceNum.SWITCHBOARD_ON_DEMAND;
+	if ('pythLazer' in source) return OracleSourceNum.PYTH_LAZER;
+	throw new Error('Invalid oracle source');
+}
+
+export function getOracleId(
+	publicKey: PublicKey,
+	source: OracleSource
+): string {
+	return `${publicKey.toBase58()}-${getOracleSourceNum(source)}`;
+}

package/src/oracles/prelaunchOracleClient.ts

@@ -0,0 +1,37 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { PrelaunchOracle } from '../types';
+
+export class PrelaunchOracleClient implements OracleClient {
+	private connection: Connection;
+	private program: Program;
+
+	public constructor(connection: Connection, program: Program) {
+		this.connection = connection;
+		this.program = program;
+	}
+
+	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 prelaunchOracle =
+			this.program.account.prelaunchOracle.coder.accounts.decodeUnchecked(
+				'PrelaunchOracle',
+				buffer
+			) as PrelaunchOracle;
+
+		return {
+			price: prelaunchOracle.price,
+			slot: prelaunchOracle.ammLastUpdateSlot,
+			confidence: prelaunchOracle.confidence,
+			hasSufficientNumberOfDataPoints: true,
+			maxPrice: prelaunchOracle.maxPrice,
+		};
+	}
+}

package/src/oracles/pythClient.ts

@@ -0,0 +1,85 @@
+import { parsePriceData } from '@pythnetwork/client';
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN } from '@coral-xyz/anchor';
+import {
+	ONE,
+	PRICE_PRECISION,
+	QUOTE_PRECISION,
+	TEN,
+} from '../constants/numericConstants';
+
+export class PythClient implements OracleClient {
+	private connection: Connection;
+	private multiple: BN;
+	private stableCoin: boolean;
+
+	public constructor(
+		connection: Connection,
+		multiple = ONE,
+		stableCoin = false
+	) {
+		this.connection = connection;
+		this.multiple = multiple;
+		this.stableCoin = stableCoin;
+	}
+
+	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 priceData = parsePriceData(buffer);
+		const confidence = convertPythPrice(
+			priceData.confidence,
+			priceData.exponent,
+			this.multiple
+		);
+		const minPublishers = Math.min(priceData.numComponentPrices, 3);
+		let price = convertPythPrice(
+			priceData.aggregate.price,
+			priceData.exponent,
+			this.multiple
+		);
+		if (this.stableCoin) {
+			price = getStableCoinPrice(price, confidence);
+		}
+
+		return {
+			price,
+			slot: new BN(priceData.lastSlot.toString()),
+			confidence,
+			twap: convertPythPrice(
+				priceData.twap.value,
+				priceData.exponent,
+				this.multiple
+			),
+			twapConfidence: convertPythPrice(
+				priceData.twac.value,
+				priceData.exponent,
+				this.multiple
+			),
+			hasSufficientNumberOfDataPoints: priceData.numQuoters >= minPublishers,
+		};
+	}
+}
+
+function convertPythPrice(price: number, exponent: number, multiple: BN): BN {
+	exponent = Math.abs(exponent);
+	const pythPrecision = TEN.pow(new BN(exponent).abs()).div(multiple);
+	return new BN(price * Math.pow(10, exponent))
+		.mul(PRICE_PRECISION)
+		.div(pythPrecision);
+}
+
+const fiveBPS = new BN(500);
+function getStableCoinPrice(price: BN, confidence: BN): BN {
+	if (price.sub(QUOTE_PRECISION).abs().lt(BN.min(confidence, fiveBPS))) {
+		return QUOTE_PRECISION;
+	} else {
+		return price;
+	}
+}

package/src/oracles/pythLazerClient.ts

@@ -0,0 +1,102 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { AnchorProvider, BN, Idl, Program } from '@coral-xyz/anchor';
+import {
+	ONE,
+	PRICE_PRECISION,
+	QUOTE_PRECISION,
+	TEN,
+} from '../constants/numericConstants';
+import { DRIFT_PROGRAM_ID, Wallet } from '..';
+import driftIDL from '../idl/drift.json';
+
+export class PythLazerClient implements OracleClient {
+	private connection: Connection;
+	private multiple: BN;
+	private stableCoin: boolean;
+	private program: Program;
+	readonly decodeFunc: (name: string, data: Buffer) => any;
+
+	public constructor(
+		connection: Connection,
+		multiple = ONE,
+		stableCoin = false
+	) {
+		this.connection = connection;
+		this.multiple = multiple;
+		this.stableCoin = stableCoin;
+		const provider = new AnchorProvider(
+			this.connection,
+			//@ts-ignore
+			new Wallet(new Keypair()),
+			{
+				commitment: connection.commitment,
+			}
+		);
+		this.program = new Program(
+			driftIDL as Idl,
+			new PublicKey(DRIFT_PROGRAM_ID),
+			provider
+		);
+		this.decodeFunc =
+			this.program.account.pythLazerOracle.coder.accounts.decodeUnchecked.bind(
+				this.program.account.pythLazerOracle.coder.accounts
+			);
+	}
+
+	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 priceData = this.decodeFunc('PythLazerOracle', buffer);
+		const confidence = convertPythPrice(
+			priceData.conf,
+			priceData.exponent,
+			this.multiple
+		);
+		let price = convertPythPrice(
+			priceData.price,
+			priceData.exponent,
+			this.multiple
+		);
+		if (this.stableCoin) {
+			price = getStableCoinPrice(price, confidence);
+		}
+
+		return {
+			price,
+			slot: priceData.postedSlot,
+			confidence,
+			twap: convertPythPrice(
+				priceData.price,
+				priceData.exponent,
+				this.multiple
+			),
+			twapConfidence: convertPythPrice(
+				priceData.price,
+				priceData.exponent,
+				this.multiple
+			),
+			hasSufficientNumberOfDataPoints: true,
+		};
+	}
+}
+
+function convertPythPrice(price: BN, exponent: number, multiple: BN): BN {
+	exponent = Math.abs(exponent);
+	const pythPrecision = TEN.pow(new BN(exponent).abs()).div(multiple);
+	return price.mul(PRICE_PRECISION).div(pythPrecision);
+}
+
+const fiveBPS = new BN(500);
+function getStableCoinPrice(price: BN, confidence: BN): BN {
+	if (price.sub(QUOTE_PRECISION).abs().lt(BN.min(confidence, fiveBPS))) {
+		return QUOTE_PRECISION;
+	} else {
+		return price;
+	}
+}