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

package/tests/ci/verifyConstants.ts

@@ -0,0 +1,278 @@
+import {
+	DriftClient,
+	DevnetSpotMarkets,
+	MainnetSpotMarkets,
+	DevnetPerpMarkets,
+	MainnetPerpMarkets,
+	BulkAccountLoader,
+	getVariant,
+	isOneOfVariant,
+} from '../../src';
+import { Connection, Keypair } from '@solana/web3.js';
+import { Wallet } from '@coral-xyz/anchor';
+import dotenv from 'dotenv';
+import { assert } from 'chai';
+
+dotenv.config();
+
+describe('Verify Constants', function () {
+	this.timeout(100_000);
+	const MAINNET_RPC_ENDPOINT = process.env.MAINNET_RPC_ENDPOINT;
+	const DEVNET_RPC_ENDPOINT = process.env.DEVNET_RPC_ENDPOINT;
+
+	// avoid breaking pre-commit
+	if (MAINNET_RPC_ENDPOINT === undefined || DEVNET_RPC_ENDPOINT === undefined) {
+		return;
+	}
+
+	const wallet = new Wallet(Keypair.generate());
+
+	const devnetConnection = new Connection(DEVNET_RPC_ENDPOINT);
+	const mainnetConnection = new Connection(MAINNET_RPC_ENDPOINT);
+
+	const devnetBulkAccountLoader = new BulkAccountLoader(
+		devnetConnection,
+		'processed',
+		1
+	);
+
+	const mainnetBulkAccountLoader = new BulkAccountLoader(
+		mainnetConnection,
+		'processed',
+		1
+	);
+
+	const devnetDriftClient = new DriftClient({
+		connection: devnetConnection,
+		wallet,
+		env: 'devnet',
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: devnetBulkAccountLoader,
+		},
+	});
+
+	const mainnetDriftClient = new DriftClient({
+		connection: mainnetConnection,
+		wallet,
+		env: 'mainnet-beta',
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: mainnetBulkAccountLoader,
+		},
+	});
+
+	let lutAccounts: string[];
+
+	before(async () => {
+		await devnetDriftClient.subscribe();
+		await mainnetDriftClient.subscribe();
+
+		const lookupTable =
+			await mainnetDriftClient.fetchMarketLookupTableAccount();
+		lutAccounts = lookupTable.state.addresses.map((x) => x.toBase58());
+	});
+
+	after(async () => {
+		await devnetDriftClient.unsubscribe();
+		await mainnetDriftClient.unsubscribe();
+	});
+
+	it('has all mainnet markets', async () => {
+		const spotMarkets = mainnetDriftClient.getSpotMarketAccounts();
+		spotMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
+
+		for (const market of spotMarkets) {
+			const correspondingConfigMarket = MainnetSpotMarkets.find(
+				(configMarket) => configMarket.marketIndex === market.marketIndex
+			);
+			assert(
+				correspondingConfigMarket !== undefined,
+				`Market ${
+					market.marketIndex
+				} not found in MainnetSpotMarkets. market: ${market.pubkey.toBase58()}`
+			);
+			assert(
+				correspondingConfigMarket.oracle.toBase58() == market.oracle.toBase58(),
+				`Oracle mismatch for mainnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.oracle.toBase58()}`
+			);
+			assert(
+				getVariant(correspondingConfigMarket.oracleSource) ===
+					getVariant(market.oracleSource),
+				`Oracle source mismatch for mainnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
+					correspondingConfigMarket.oracleSource
+				)}, chain: ${getVariant(market.oracleSource)}`
+			);
+			assert(
+				correspondingConfigMarket.mint.toBase58() === market.mint.toBase58(),
+				`Mint mismatch for mainnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.mint.toBase58()}, chain: ${market.mint.toBase58()}`
+			);
+
+			const lutHasMarket = lutAccounts.includes(market.pubkey.toBase58());
+			assert(
+				lutHasMarket,
+				`Mainnet LUT is missing spot market ${
+					market.marketIndex
+				} pubkey ${market.pubkey.toBase58()}`
+			);
+
+			const lutHasMarketOracle = lutAccounts.includes(market.oracle.toBase58());
+			assert(
+				lutHasMarketOracle,
+				`Mainnet LUT is missing spot market ${
+					market.marketIndex
+				} oracle ${market.oracle.toBase58()}`
+			);
+
+			if (
+				isOneOfVariant(market.oracleSource, [
+					'pythPull',
+					'pyth1KPull',
+					'pyth1MPull',
+					'pythStableCoinPull',
+				])
+			) {
+				if (!correspondingConfigMarket.pythFeedId) {
+					assert(false, `spot market ${market.marketIndex} missing feed id`);
+				}
+			}
+		}
+
+		const perpMarkets = mainnetDriftClient.getPerpMarketAccounts();
+		perpMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
+
+		for (const market of perpMarkets) {
+			const correspondingConfigMarket = MainnetPerpMarkets.find(
+				(configMarket) => configMarket.marketIndex === market.marketIndex
+			);
+			assert(
+				correspondingConfigMarket !== undefined,
+				`Market ${
+					market.marketIndex
+				} not found in MainnetPerpMarkets, market: ${market.pubkey.toBase58()}`
+			);
+			assert(
+				correspondingConfigMarket.oracle.toBase58() ==
+					market.amm.oracle.toBase58(),
+				`Oracle mismatch for mainnet perp market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.amm.oracle.toBase58()}`
+			);
+			assert(
+				getVariant(correspondingConfigMarket.oracleSource) ===
+					getVariant(market.amm.oracleSource),
+				`Oracle source mismatch for mainnet perp market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
+					correspondingConfigMarket.oracleSource
+				)}, chain: ${getVariant(market.amm.oracleSource)}`
+			);
+
+			const lutHasMarket = lutAccounts.includes(market.pubkey.toBase58());
+			assert(
+				lutHasMarket,
+				`Mainnet LUT is missing perp market ${
+					market.marketIndex
+				} pubkey ${market.pubkey.toBase58()}`
+			);
+
+			const lutHasMarketOracle = lutAccounts.includes(
+				market.amm.oracle.toBase58()
+			);
+			assert(
+				lutHasMarketOracle,
+				`Mainnet LUT is missing perp market ${
+					market.marketIndex
+				} oracle ${market.amm.oracle.toBase58()}`
+			);
+
+			if (
+				isOneOfVariant(market.amm.oracleSource, [
+					'pythPull',
+					'pyth1KPull',
+					'pyth1MPull',
+					'pythStableCoinPull',
+				])
+			) {
+				if (!correspondingConfigMarket.pythFeedId) {
+					assert(false, `perp market ${market.marketIndex} missing feed id`);
+				}
+			}
+		}
+	});
+
+	it('has all devnet markets', async () => {
+		const spotMarkets = devnetDriftClient.getSpotMarketAccounts();
+		spotMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
+
+		for (const market of spotMarkets) {
+			const correspondingConfigMarket = DevnetSpotMarkets.find(
+				(configMarket) => configMarket.marketIndex === market.marketIndex
+			);
+			assert(
+				correspondingConfigMarket !== undefined,
+				`Market ${
+					market.marketIndex
+				} not found in DevnetSpotMarkets, market: ${market.pubkey.toBase58()}`
+			);
+			assert(
+				correspondingConfigMarket.oracle.toBase58() == market.oracle.toBase58(),
+				`Oracle mismatch for devnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.oracle.toBase58()}`
+			);
+			assert(
+				getVariant(correspondingConfigMarket.oracleSource) ===
+					getVariant(market.oracleSource),
+				`Oracle source mismatch for devnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
+					correspondingConfigMarket.oracleSource
+				)}, chain: ${getVariant(market.oracleSource)}`
+			);
+			assert(
+				correspondingConfigMarket.mint.toBase58() === market.mint.toBase58(),
+				`Mint mismatch for devnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.mint.toBase58()}, chain: ${market.mint.toBase58()}`
+			);
+		}
+
+		const perpMarkets = devnetDriftClient.getPerpMarketAccounts();
+		perpMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
+
+		for (const market of perpMarkets) {
+			const correspondingConfigMarket = DevnetPerpMarkets.find(
+				(configMarket) => configMarket.marketIndex === market.marketIndex
+			);
+			assert(
+				correspondingConfigMarket !== undefined,
+				`Market ${
+					market.marketIndex
+				} not found in DevnetPerpMarkets, market: ${market.pubkey.toBase58()}`
+			);
+			assert(
+				correspondingConfigMarket.oracle.toBase58() ==
+					market.amm.oracle.toBase58(),
+				`Oracle mismatch for devnet perp market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.amm.oracle.toBase58()}`
+			);
+			assert(
+				getVariant(correspondingConfigMarket.oracleSource) ===
+					getVariant(market.amm.oracleSource),
+				`Oracle source mismatch for devnet perp market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
+					correspondingConfigMarket.oracleSource
+				)}, chain: ${getVariant(market.amm.oracleSource)}`
+			);
+		}
+	});
+});

package/tests/decode/phoenix.ts

@@ -0,0 +1,71 @@
+import { MarketData, deserializeMarketData } from '@ellipsis-labs/phoenix-sdk';
+import { fastDecode } from '../../src/decode/phoenix';
+import { Connection, PublicKey } from '@solana/web3.js';
+import assert from 'assert';
+
+describe('custom phoenix decode', function () {
+	this.timeout(100_000);
+
+	it('decodes quickly', async function () {
+		const connection = new Connection('https://api.mainnet-beta.solana.com');
+
+		const val = await connection.getAccountInfo(
+			new PublicKey('4DoNfFBfF7UokCC2FQzriy7yHK6DY6NVdYpuekQ5pRgg')
+		);
+
+		const numIterations = 100;
+
+		let regularDecoded: MarketData;
+		const regularStart = performance.now();
+		for (let i = 0; i < numIterations; i++) {
+			regularDecoded = deserializeMarketData(val!.data);
+		}
+		const regularEnd = performance.now();
+
+		let fastDecoded: MarketData;
+		const fastStart = performance.now();
+		for (let i = 0; i < numIterations; i++) {
+			fastDecoded = fastDecode(val!.data);
+		}
+		const fastEnd = performance.now();
+
+		console.log(`Regular: ${regularEnd - regularStart} ms`);
+		console.log(
+			`Regular avg: ${(regularEnd - regularStart) / numIterations} ms`
+		);
+
+		console.log(`Fast: ${fastEnd - fastStart} ms`);
+		console.log(`Fast avg: ${(fastEnd - fastStart) / numIterations} ms`);
+
+		// @ts-ignore
+		assert(deepEqual(fastDecoded.bids, regularDecoded.bids));
+		// @ts-ignore
+		assert(deepEqual(regularDecoded.asks, fastDecoded.asks));
+	});
+});
+
+function deepEqual(obj1: any, obj2: any) {
+	if (obj1 === obj2) return true;
+
+	if (
+		obj1 == null ||
+		obj2 == null ||
+		typeof obj1 !== 'object' ||
+		typeof obj2 !== 'object'
+	) {
+		return false;
+	}
+
+	const keys1 = Object.keys(obj1);
+	const keys2 = Object.keys(obj2);
+
+	if (keys1.length !== keys2.length) return false;
+
+	for (const key of keys1) {
+		if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
+			return false;
+		}
+	}
+
+	return true;
+}

package/tests/decode/test.ts

@@ -0,0 +1,266 @@
+import { AnchorProvider, Idl, Program } from '@coral-xyz/anchor';
+import driftIDL from '../../src/idl/drift.json';
+import { Connection, Keypair } from '@solana/web3.js';
+import {
+	decodeUser,
+	Wallet,
+	DRIFT_PROGRAM_ID,
+	isSpotPositionAvailable,
+	isVariant,
+	Order,
+	PerpPosition,
+	positionIsAvailable,
+	SpotPosition,
+} from '../../src';
+import { assert } from 'chai';
+import { userAccountBufferStrings } from './userAccountBufferStrings';
+const sizeof = require('object-sizeof');
+
+describe('Custom user decode', () => {
+	it('test', async () => {
+		const connection = new Connection('http://localhost:8899');
+		const wallet = new Wallet(new Keypair());
+		// @ts-ignore
+		const provider = new AnchorProvider(connection, wallet);
+		const program = new Program(driftIDL as Idl, DRIFT_PROGRAM_ID, provider);
+
+		let totalAnchorSize = 0;
+		let totalCustomSize = 0;
+		let totalAnchorTime = 0;
+		let totalCustomTime = 0;
+		for (const [
+			i,
+			userAccountBufferString,
+		] of userAccountBufferStrings.entries()) {
+			const userAccountBuffer = Buffer.from(userAccountBufferString, 'base64');
+			const [anchorSize, customSize, anchorTime, customTime] =
+				testUserAccountDecode(program, userAccountBuffer, i);
+			totalAnchorSize += anchorSize;
+			totalCustomSize += customSize;
+			totalAnchorTime += anchorTime;
+			totalCustomTime += customTime;
+		}
+
+		console.log(`Total anchor size: ${totalAnchorSize}`);
+		console.log(`Total custom size: ${totalCustomSize}`);
+		console.log(`Total anchor time: ${totalAnchorTime}`);
+		console.log(`Total custom size: ${totalCustomTime}`);
+	});
+});
+
+function testUserAccountDecode(program: Program, buffer: Buffer, i: number) {
+	console.log(`Testing user account decode ${i}`);
+
+	const anchorStartTimestamp = Date.now();
+	const anchorUserAccount = program.coder.accounts.decode('User', buffer);
+	const anchorEndTimestamp = Date.now();
+	const anchorTime = anchorEndTimestamp - anchorStartTimestamp;
+
+	const customStartTimestamp = Date.now();
+	const customUserAccount = decodeUser(buffer);
+	const customEndTimestamp = Date.now();
+	const customTime = customEndTimestamp - customStartTimestamp;
+
+	const anchorSize = sizeof(anchorUserAccount);
+	const customSize = sizeof(customUserAccount);
+
+	assert(anchorUserAccount.authority.equals(customUserAccount.authority));
+	assert(anchorUserAccount.delegate.equals(customUserAccount.delegate));
+	assert(arraysAreEqual(anchorUserAccount.name, customUserAccount.name));
+
+	const anchorSpotPositionGenerator = getSpotPositions(
+		anchorUserAccount.spotPositions
+	);
+	const customSpotPositionGenerator = getSpotPositions(
+		customUserAccount.spotPositions
+	);
+	for (const [anchorSpotPosition, customSpotPosition] of zipGenerator(
+		anchorSpotPositionGenerator,
+		customSpotPositionGenerator
+	)) {
+		testSpotPosition(anchorSpotPosition, customSpotPosition);
+	}
+
+	const anchorPerpPositionGenerator = getPerpPositions(
+		anchorUserAccount.perpPositions
+	);
+	const customPerpPositionGenerator = getPerpPositions(
+		customUserAccount.perpPositions
+	);
+	for (const [anchorPerpPosition, customPerpPosition] of zipGenerator(
+		anchorPerpPositionGenerator,
+		customPerpPositionGenerator
+	)) {
+		testPerpPosition(anchorPerpPosition, customPerpPosition);
+	}
+
+	const anchorOrderGenerator = getOrders(anchorUserAccount.orders);
+	const customOrderGenerator = getOrders(customUserAccount.orders);
+	for (const [anchorOrder, customOrder] of zipGenerator(
+		anchorOrderGenerator,
+		customOrderGenerator
+	)) {
+		testOrder(anchorOrder, customOrder);
+	}
+
+	assert(
+		anchorUserAccount.lastAddPerpLpSharesTs.eq(
+			customUserAccount.lastAddPerpLpSharesTs
+		)
+	);
+	assert(anchorUserAccount.totalDeposits.eq(customUserAccount.totalDeposits));
+	assert(anchorUserAccount.totalWithdraws.eq(customUserAccount.totalWithdraws));
+	assert(
+		anchorUserAccount.totalSocialLoss.eq(customUserAccount.totalSocialLoss)
+	);
+	assert(anchorUserAccount.settledPerpPnl.eq(customUserAccount.settledPerpPnl));
+	assert(
+		anchorUserAccount.cumulativeSpotFees.eq(
+			customUserAccount.cumulativeSpotFees
+		)
+	);
+	assert(
+		anchorUserAccount.cumulativePerpFunding.eq(
+			customUserAccount.cumulativePerpFunding
+		)
+	);
+	assert(
+		anchorUserAccount.liquidationMarginFreed.eq(
+			customUserAccount.liquidationMarginFreed
+		)
+	);
+	assert(anchorUserAccount.lastActiveSlot.eq(customUserAccount.lastActiveSlot));
+	assert(anchorUserAccount.subAccountId === customUserAccount.subAccountId);
+	assert(anchorUserAccount.status === customUserAccount.status);
+	assert(
+		anchorUserAccount.nextLiquidationId === customUserAccount.nextLiquidationId
+	);
+	assert(anchorUserAccount.nextOrderId === customUserAccount.nextOrderId);
+	assert(anchorUserAccount.maxMarginRatio === customUserAccount.maxMarginRatio);
+	assert(
+		anchorUserAccount.isMarginTradingEnabled ===
+			customUserAccount.isMarginTradingEnabled
+	);
+	assert(anchorUserAccount.idle === customUserAccount.idle);
+	assert(anchorUserAccount.openOrders === customUserAccount.openOrders);
+	assert(anchorUserAccount.hasOpenOrder === customUserAccount.hasOpenOrder);
+	assert(anchorUserAccount.openAuctions === customUserAccount.openAuctions);
+	assert(anchorUserAccount.hasOpenAuction === customUserAccount.hasOpenAuction);
+
+	return [anchorSize, customSize, anchorTime, customTime];
+}
+
+function* getSpotPositions(spotPositions: SpotPosition[]) {
+	for (const spotPosition of spotPositions) {
+		if (!isSpotPositionAvailable(spotPosition)) {
+			yield spotPosition;
+		}
+	}
+}
+
+function testSpotPosition(anchor: SpotPosition, custom: SpotPosition) {
+	assert(anchor.marketIndex === custom.marketIndex);
+	assert(enumsAreEqual(anchor.balanceType, custom.balanceType));
+	assert(anchor.openOrders === custom.openOrders);
+	assert(anchor.scaledBalance.eq(custom.scaledBalance));
+	assert(anchor.openBids.eq(custom.openBids));
+	assert(anchor.openAsks.eq(custom.openAsks));
+	assert(anchor.cumulativeDeposits.eq(custom.cumulativeDeposits));
+}
+
+function* getPerpPositions(perpPositions: PerpPosition[]) {
+	for (const perpPosition of perpPositions) {
+		if (!positionIsAvailable(perpPosition)) {
+			yield perpPosition;
+		}
+	}
+}
+
+function testPerpPosition(anchor: PerpPosition, custom: PerpPosition) {
+	assert(anchor.baseAssetAmount.eq(custom.baseAssetAmount));
+	assert(anchor.lastCumulativeFundingRate.eq(custom.lastCumulativeFundingRate));
+	assert(anchor.marketIndex === custom.marketIndex);
+	assert(anchor.quoteAssetAmount.eq(custom.quoteAssetAmount));
+	assert(anchor.quoteEntryAmount.eq(custom.quoteEntryAmount));
+	assert(anchor.quoteBreakEvenAmount.eq(custom.quoteBreakEvenAmount));
+	assert(anchor.openBids.eq(custom.openBids));
+	assert(anchor.openAsks.eq(custom.openAsks));
+	assert(anchor.settledPnl.eq(custom.settledPnl));
+	assert(anchor.lpShares.eq(custom.lpShares));
+	assert(anchor.lastBaseAssetAmountPerLp.eq(custom.lastBaseAssetAmountPerLp));
+	assert(anchor.lastQuoteAssetAmountPerLp.eq(custom.lastQuoteAssetAmountPerLp));
+	assert(anchor.openOrders === custom.openOrders);
+	assert(anchor.perLpBase === custom.perLpBase);
+}
+
+function* getOrders(orders: Order[]) {
+	for (const order of orders) {
+		if (isVariant(order.status, 'open')) {
+			yield order;
+		}
+	}
+}
+
+function testOrder(anchor: Order, custom: Order) {
+	assert(enumsAreEqual(anchor.status, custom.status));
+	assert(enumsAreEqual(anchor.orderType, custom.orderType));
+	assert(enumsAreEqual(anchor.marketType, custom.marketType));
+	assert(anchor.slot.eq(custom.slot));
+	assert(anchor.orderId === custom.orderId);
+	assert(anchor.userOrderId === custom.userOrderId);
+	assert(anchor.marketIndex === custom.marketIndex);
+	assert(anchor.price.eq(custom.price));
+	assert(anchor.baseAssetAmount.eq(custom.baseAssetAmount));
+	assert(anchor.baseAssetAmountFilled.eq(custom.baseAssetAmountFilled));
+	assert(anchor.quoteAssetAmountFilled.eq(custom.quoteAssetAmountFilled));
+	assert(enumsAreEqual(anchor.direction, custom.direction));
+	assert(anchor.reduceOnly === custom.reduceOnly);
+	assert(anchor.triggerPrice.eq(custom.triggerPrice));
+	assert(enumsAreEqual(anchor.triggerCondition, custom.triggerCondition));
+	assert(
+		enumsAreEqual(
+			anchor.existingPositionDirection,
+			custom.existingPositionDirection
+		)
+	);
+	assert(anchor.postOnly === custom.postOnly);
+	assert(anchor.immediateOrCancel === custom.immediateOrCancel);
+	assert(anchor.oraclePriceOffset === custom.oraclePriceOffset);
+	assert(anchor.auctionDuration === custom.auctionDuration);
+	assert(anchor.auctionStartPrice.eq(custom.auctionStartPrice));
+	assert(anchor.auctionEndPrice.eq(custom.auctionEndPrice));
+	assert(anchor.maxTs.eq(custom.maxTs));
+}
+
+function enumsAreEqual(e1: any, e2: any) {
+	return JSON.stringify(e1) === JSON.stringify(e2);
+}
+
+function arraysAreEqual(arr1, arr2) {
+	if (arr1.length !== arr2.length) {
+		return false;
+	}
+
+	for (let i = 0; i < arr1.length; i++) {
+		if (arr1[i] !== arr2[i]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function* zipGenerator(gen1, gen2) {
+	let iter1 = gen1.next();
+	let iter2 = gen2.next();
+
+	while (!iter1.done && !iter2.done) {
+		yield [iter1.value, iter2.value];
+		iter1 = gen1.next();
+		iter2 = gen2.next();
+	}
+
+	if (iter1.done !== iter2.done) {
+		throw new Error('Generators have different lengths');
+	}
+}