@velocity-exchange/sdk 0.4.0 → 0.6.0

package/tests/ci/verifyConstants.ts

@@ -1,393 +0,0 @@
-import {
-	VelocityClient,
-	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 isPullOracleSource = (oracleSource: unknown) =>
-		isOneOfVariant(oracleSource, [
-			'pythPull',
-			'pyth1KPull',
-			'pyth1MPull',
-			'pythStableCoinPull',
-		]);
-
-	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 devnetVelocityClient = new VelocityClient({
-		connection: devnetConnection,
-		wallet,
-		env: 'devnet',
-		accountSubscription: {
-			type: 'polling',
-			accountLoader: devnetBulkAccountLoader,
-		},
-	});
-
-	const mainnetVelocityClient = new VelocityClient({
-		connection: mainnetConnection,
-		wallet,
-		env: 'mainnet-beta',
-		accountSubscription: {
-			type: 'polling',
-			accountLoader: mainnetBulkAccountLoader,
-		},
-	});
-
-	let lutAccounts: string[];
-
-	before(async () => {
-		await devnetVelocityClient.subscribe();
-		await mainnetVelocityClient.subscribe();
-
-		const lookupTables =
-			await mainnetVelocityClient.fetchAllLookupTableAccounts();
-		lutAccounts = lookupTables
-			.map((lut) => lut.state.addresses.map((x) => x.toBase58()))
-			.flat();
-	});
-
-	after(async () => {
-		await devnetVelocityClient.unsubscribe();
-		await mainnetVelocityClient.unsubscribe();
-	});
-
-	it('has all mainnet markets', async () => {
-		const errors: string[] = [];
-		const missingLutAddresses: {
-			type: string;
-			marketIndex: number;
-			address: string;
-			description: string;
-		}[] = [];
-
-		const spotMarkets = mainnetVelocityClient.getSpotMarketAccounts();
-		spotMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
-
-		for (const market of spotMarkets) {
-			if (isPullOracleSource(market.oracleSource)) {
-				continue;
-			}
-
-			const correspondingConfigMarket = MainnetSpotMarkets.find(
-				(configMarket) => configMarket.marketIndex === market.marketIndex
-			);
-
-			if (correspondingConfigMarket === undefined) {
-				errors.push(
-					`Market ${
-						market.marketIndex
-					} not found in MainnetSpotMarkets. market: ${market.pubkey.toBase58()}`
-				);
-				continue;
-			}
-
-			if (
-				correspondingConfigMarket.oracle.toBase58() !== market.oracle.toBase58()
-			) {
-				errors.push(
-					`Oracle mismatch for mainnet spot market ${
-						market.marketIndex
-					}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.oracle.toBase58()}`
-				);
-			}
-
-			if (
-				getVariant(correspondingConfigMarket.oracleSource) !==
-				getVariant(market.oracleSource)
-			) {
-				errors.push(
-					`Oracle source mismatch for mainnet spot market ${
-						market.marketIndex
-					}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
-						correspondingConfigMarket.oracleSource
-					)}, chain: ${getVariant(market.oracleSource)}`
-				);
-			}
-
-			if (
-				correspondingConfigMarket.mint.toBase58() !== market.mint.toBase58()
-			) {
-				errors.push(
-					`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());
-			if (!lutHasMarket) {
-				missingLutAddresses.push({
-					type: 'spot',
-					marketIndex: market.marketIndex,
-					address: market.pubkey.toBase58(),
-					description: 'market',
-				});
-			}
-
-			const lutHasMarketOracle = lutAccounts.includes(market.oracle.toBase58());
-			if (!lutHasMarketOracle) {
-				missingLutAddresses.push({
-					type: 'spot',
-					marketIndex: market.marketIndex,
-					address: market.oracle.toBase58(),
-					description: 'oracle',
-				});
-			}
-		}
-
-		const perpMarkets = mainnetVelocityClient.getPerpMarketAccounts();
-		perpMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
-
-		for (const market of perpMarkets) {
-			if (isPullOracleSource(market.oracleSource)) {
-				continue;
-			}
-
-			const correspondingConfigMarket = MainnetPerpMarkets.find(
-				(configMarket) => configMarket.marketIndex === market.marketIndex
-			);
-
-			if (correspondingConfigMarket === undefined) {
-				errors.push(
-					`Market ${
-						market.marketIndex
-					} not found in MainnetPerpMarkets, market: ${market.pubkey.toBase58()}`
-				);
-				continue;
-			}
-
-			if (
-				correspondingConfigMarket.oracle.toBase58() !== market.oracle.toBase58()
-			) {
-				errors.push(
-					`Oracle mismatch for mainnet perp market ${
-						market.marketIndex
-					}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.oracle.toBase58()}`
-				);
-			}
-
-			if (
-				getVariant(correspondingConfigMarket.oracleSource) !==
-				getVariant(market.oracleSource)
-			) {
-				errors.push(
-					`Oracle source mismatch for mainnet perp market ${
-						market.marketIndex
-					}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
-						correspondingConfigMarket.oracleSource
-					)}, chain: ${getVariant(market.oracleSource)}`
-				);
-			}
-
-			const lutHasMarket = lutAccounts.includes(market.pubkey.toBase58());
-			if (!lutHasMarket) {
-				missingLutAddresses.push({
-					type: 'perp',
-					marketIndex: market.marketIndex,
-					address: market.pubkey.toBase58(),
-					description: 'market',
-				});
-			}
-
-			const lutHasMarketOracle = lutAccounts.includes(market.oracle.toBase58());
-			if (!lutHasMarketOracle) {
-				missingLutAddresses.push({
-					type: 'perp',
-					marketIndex: market.marketIndex,
-					address: market.oracle.toBase58(),
-					description: 'oracle',
-				});
-			}
-		}
-
-		// Print all missing LUT addresses
-		if (missingLutAddresses.length > 0) {
-			console.log('\n=== MISSING LUT ADDRESSES ===');
-			missingLutAddresses.forEach(
-				({ type, marketIndex, address, description }) => {
-					console.log(
-						`${type.toUpperCase()} Market ${marketIndex} ${description}: ${address}`
-					);
-				}
-			);
-			console.log(
-				`\nTotal missing LUT addresses: ${missingLutAddresses.length}`
-			);
-		}
-
-		// Print all errors
-		if (errors.length > 0) {
-			console.log('\n=== VALIDATION ERRORS ===');
-			errors.forEach((error, index) => {
-				console.log(`${index + 1}. ${error}`);
-			});
-			console.log(`\nTotal errors: ${errors.length}`);
-		}
-
-		// Fail if there are any issues
-		const totalIssues = errors.length + missingLutAddresses.length;
-		if (totalIssues > 0) {
-			assert(
-				false,
-				`Found ${totalIssues} issues (${errors.length} validation errors, ${missingLutAddresses.length} missing LUT addresses). See details above.`
-			);
-		}
-	});
-
-	it('has all devnet markets', async () => {
-		const errors: string[] = [];
-
-		const spotMarkets = devnetVelocityClient.getSpotMarketAccounts();
-		spotMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
-
-		for (const market of spotMarkets) {
-			if (isPullOracleSource(market.oracleSource)) {
-				continue;
-			}
-
-			const correspondingConfigMarket = DevnetSpotMarkets.find(
-				(configMarket) => configMarket.marketIndex === market.marketIndex
-			);
-
-			if (correspondingConfigMarket === undefined) {
-				errors.push(
-					`Market ${
-						market.marketIndex
-					} not found in DevnetSpotMarkets, market: ${market.pubkey.toBase58()}`
-				);
-				continue;
-			}
-
-			if (
-				correspondingConfigMarket.oracle.toBase58() !== market.oracle.toBase58()
-			) {
-				errors.push(
-					`Oracle mismatch for devnet spot market ${
-						market.marketIndex
-					}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.oracle.toBase58()}`
-				);
-			}
-
-			if (
-				getVariant(correspondingConfigMarket.oracleSource) !==
-				getVariant(market.oracleSource)
-			) {
-				errors.push(
-					`Oracle source mismatch for devnet spot market ${
-						market.marketIndex
-					}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
-						correspondingConfigMarket.oracleSource
-					)}, chain: ${getVariant(market.oracleSource)}`
-				);
-			}
-
-			if (
-				correspondingConfigMarket.mint.toBase58() !== market.mint.toBase58()
-			) {
-				errors.push(
-					`Mint mismatch for devnet spot market ${
-						market.marketIndex
-					}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.mint.toBase58()}, chain: ${market.mint.toBase58()}`
-				);
-			}
-		}
-
-		const perpMarkets = devnetVelocityClient.getPerpMarketAccounts();
-		perpMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
-
-		for (const market of perpMarkets) {
-			if (isPullOracleSource(market.oracleSource)) {
-				continue;
-			}
-
-			const correspondingConfigMarket = DevnetPerpMarkets.find(
-				(configMarket) => configMarket.marketIndex === market.marketIndex
-			);
-
-			if (correspondingConfigMarket === undefined) {
-				errors.push(
-					`Market ${
-						market.marketIndex
-					} not found in DevnetPerpMarkets, market: ${market.pubkey.toBase58()}`
-				);
-				continue;
-			}
-
-			if (
-				correspondingConfigMarket.oracle.toBase58() !== market.oracle.toBase58()
-			) {
-				errors.push(
-					`Oracle mismatch for devnet perp market ${
-						market.marketIndex
-					}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.oracle.toBase58()}`
-				);
-			}
-
-			if (
-				getVariant(correspondingConfigMarket.oracleSource) !==
-				getVariant(market.oracleSource)
-			) {
-				errors.push(
-					`Oracle source mismatch for devnet perp market ${
-						market.marketIndex
-					}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
-						correspondingConfigMarket.oracleSource
-					)}, chain: ${getVariant(market.oracleSource)}`
-				);
-			}
-		}
-
-		// Print all errors
-		if (errors.length > 0) {
-			console.log('\n=== DEVNET VALIDATION ERRORS ===');
-			errors.forEach((error, index) => {
-				console.log(`${index + 1}. ${error}`);
-			});
-			console.log(`\nTotal devnet errors: ${errors.length}`);
-		}
-
-		// Fail if there are any issues
-		if (errors.length > 0) {
-			assert(
-				false,
-				`Found ${errors.length} devnet validation errors. See details above.`
-			);
-		}
-	});
-});

package/tests/decode/test.ts

@@ -1,262 +0,0 @@
-import { AnchorProvider, Idl, Program } from '@coral-xyz/anchor';
-import velocityIDL from '../../src/idl/velocity.json';
-import { Connection, Keypair } from '@solana/web3.js';
-import {
-	decodeUser,
-	Wallet,
-	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(velocityIDL as Idl, 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.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.openOrders === custom.openOrders);
-	assert(
-		anchor.isolatedPositionScaledBalance.eq(
-			custom.isolatedPositionScaledBalance
-		)
-	);
-	assert(anchor.positionFlag === custom.positionFlag);
-}
-
-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.eq(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');
-	}
-}