@drift-labs/sdk-browser 2.163.0-beta.11 → 2.163.0-beta.13

package/tests/DriftCore/fill_trigger.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from 'bun:test';
+import { Keypair } from '@solana/web3.js';
+import { DriftCore } from '../../src/core/DriftCore';
+
+describe('DriftCore fill/trigger builders', () => {
+	test('buildFillPerpOrderInstruction wires accounts + args', async () => {
+		const called: any[] = [];
+		const fakeIx = {
+			keys: [],
+			programId: Keypair.generate().publicKey,
+			data: Buffer.alloc(0),
+		};
+
+		const program = {
+			instruction: {
+				fillPerpOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const pk = () => Keypair.generate().publicKey;
+
+		const ix = await DriftCore.buildFillPerpOrderInstruction({
+			program,
+			orderId: 7,
+			state: pk(),
+			filler: pk(),
+			fillerStats: pk(),
+			user: pk(),
+			userStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+
+		expect(ix).toBe(fakeIx as any);
+		expect(called.length).toBe(1);
+		expect(called[0][0]).toBe(7);
+	});
+
+	test('buildTriggerOrderInstruction wires accounts + args', async () => {
+		const called: any[] = [];
+		const fakeIx = {
+			keys: [],
+			programId: Keypair.generate().publicKey,
+			data: Buffer.alloc(0),
+		};
+
+		const program = {
+			instruction: {
+				triggerOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const pk = () => Keypair.generate().publicKey;
+
+		const ix = await DriftCore.buildTriggerOrderInstruction({
+			program,
+			orderId: 9,
+			state: pk(),
+			filler: pk(),
+			user: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+
+		expect(ix).toBe(fakeIx as any);
+		expect(called.length).toBe(1);
+		expect(called[0][0]).toBe(9);
+	});
+});

package/tests/DriftCore/instructions.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from 'bun:test';
+import { DriftCore } from '../../src/core/DriftCore';
+import { Keypair } from '@solana/web3.js';
+import { BN } from '../../src/isomorphic/anchor';
+
+describe('DriftCore instruction builders', () => {
+	test('buildDepositInstruction calls underlying program.deposit', async () => {
+		const called: any[] = [];
+		const fakeIx = {
+			keys: [],
+			programId: Keypair.generate().publicKey,
+			data: Buffer.alloc(0),
+		};
+
+		const program = {
+			instruction: {
+				deposit: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+
+		const pk = () => Keypair.generate().publicKey;
+
+		const ix = await DriftCore.buildDepositInstruction({
+			program,
+			marketIndex: 1,
+			amount: new BN(123),
+			reduceOnly: false,
+			state: pk(),
+			spotMarket: pk(),
+			spotMarketVault: pk(),
+			user: pk(),
+			userStats: pk(),
+			userTokenAccount: pk(),
+			authority: pk(),
+			tokenProgram: pk(),
+			remainingAccounts: [],
+		});
+
+		expect(ix).toBe(fakeIx as any);
+		expect(called.length).toBe(1);
+		expect(called[0][0]).toBe(1);
+	});
+});

package/tests/DriftCore/pdas.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from 'bun:test';
+import { Keypair, PublicKey } from '@solana/web3.js';
+import { DriftCore } from '../../src/core/DriftCore';
+
+describe('DriftCore.pdas', () => {
+	test('derives deterministic user/state PDAs', async () => {
+		const programId = Keypair.generate().publicKey;
+		const authority = Keypair.generate().publicKey;
+
+		const [state] = await DriftCore.pdas.getDriftStateAccountPublicKeyAndNonce(
+			programId
+		);
+		const user0 = await DriftCore.pdas.getUserAccountPublicKey(
+			programId,
+			authority,
+			0
+		);
+		const user1 = await DriftCore.pdas.getUserAccountPublicKey(
+			programId,
+			authority,
+			1
+		);
+
+		expect(state).toBeInstanceOf(PublicKey);
+		expect(user0).toBeInstanceOf(PublicKey);
+		expect(user1).toBeInstanceOf(PublicKey);
+		expect(user0.toBase58()).not.toEqual(user1.toBase58());
+	});
+});

package/tests/DriftCore/perp_orders.test.ts

@@ -0,0 +1,205 @@
+import { describe, expect, test } from 'bun:test';
+import { Keypair } from '@solana/web3.js';
+import { DriftCore } from '../../src/core/DriftCore';
+
+describe('DriftCore perp order instruction builders', () => {
+	const pk = () => Keypair.generate().publicKey;
+	const fakeIx = {
+		keys: [],
+		programId: Keypair.generate().publicKey,
+		data: Buffer.alloc(0),
+	};
+
+	test('buildPlacePerpOrderInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				placePerpOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ix = await DriftCore.buildPlacePerpOrderInstruction({
+			program,
+			orderParams: { x: 1 },
+			state: pk(),
+			user: pk(),
+			userStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toEqual({ x: 1 });
+	});
+
+	test('buildPlaceAndTakePerpOrderInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				placeAndTakePerpOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ix = await DriftCore.buildPlaceAndTakePerpOrderInstruction({
+			program,
+			orderParams: { m: 0 },
+			optionalParams: 256,
+			state: pk(),
+			user: pk(),
+			userStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][1]).toBe(256);
+	});
+
+	test('buildPlaceAndMakePerpOrderInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				placeAndMakePerpOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ix = await DriftCore.buildPlaceAndMakePerpOrderInstruction({
+			program,
+			orderParams: {},
+			takerOrderId: 7,
+			state: pk(),
+			user: pk(),
+			userStats: pk(),
+			taker: pk(),
+			takerStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][1]).toBe(7);
+	});
+
+	test('buildCancelOrderInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				cancelOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ix = await DriftCore.buildCancelOrderInstruction({
+			program,
+			orderId: 3,
+			state: pk(),
+			user: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(3);
+	});
+
+	test('buildCancelOrderByUserIdInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				cancelOrderByUserId: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ix = await DriftCore.buildCancelOrderByUserIdInstruction({
+			program,
+			userOrderId: 9,
+			state: pk(),
+			user: pk(),
+			authority: pk(),
+			oracle: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(9);
+	});
+
+	test('buildCancelOrdersByIdsInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				cancelOrdersByIds: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ids = [1, 2];
+		const ix = await DriftCore.buildCancelOrdersByIdsInstruction({
+			program,
+			orderIds: ids,
+			state: pk(),
+			user: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(ids);
+	});
+
+	test('buildModifyOrderInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				modifyOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const mp = { baseAssetAmount: null };
+		const ix = await DriftCore.buildModifyOrderInstruction({
+			program,
+			orderId: 4,
+			modifyParams: mp,
+			state: pk(),
+			user: pk(),
+			userStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(4);
+		expect(called[0][1]).toBe(mp);
+	});
+
+	test('buildModifyOrderByUserIdInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				modifyOrderByUserId: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const mp = { reduceOnly: false };
+		const ix = await DriftCore.buildModifyOrderByUserIdInstruction({
+			program,
+			userOrderId: 11,
+			modifyParams: mp,
+			state: pk(),
+			user: pk(),
+			userStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(11);
+		expect(called[0][1]).toBe(mp);
+	});
+});

package/tests/DriftCore/remainingAccounts.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from 'bun:test';
+import { Keypair } from '@solana/web3.js';
+import { DriftCore } from '../../src/core/DriftCore';
+import { BN } from '../../src/isomorphic/anchor';
+import type { UserAccount } from '../../src/types';
+
+describe('DriftCore.remainingAccounts', () => {
+	test('includes spot/perp + oracle accounts based on user positions', () => {
+		const spotMarket0 = {
+			marketIndex: 0,
+			pubkey: Keypair.generate().publicKey,
+			oracle: Keypair.generate().publicKey,
+		} as any;
+		const quoteSpotMarket = {
+			marketIndex: 0,
+			pubkey: spotMarket0.pubkey,
+			oracle: spotMarket0.oracle,
+		} as any;
+		const perpMarket0 = {
+			pubkey: Keypair.generate().publicKey,
+			quoteSpotMarketIndex: 0,
+			amm: {
+				oracle: Keypair.generate().publicKey,
+				oracleSource: { prelaunch: {} },
+			},
+		} as any;
+
+		const user: UserAccount = {
+			authority: Keypair.generate().publicKey,
+			subAccountId: 0,
+			spotPositions: [
+				{
+					marketIndex: 0,
+					scaledBalance: new BN(1),
+					openBids: new BN(0),
+					openAsks: new BN(0),
+					cumulativeDeposits: new BN(0),
+					balanceType: { deposit: {} },
+					openOrders: 0,
+				} as any,
+			],
+			perpPositions: [
+				{
+					marketIndex: 0,
+					baseAssetAmount: new BN(1),
+				} as any,
+			],
+		} as any;
+
+		const ctx = {
+			getPerpMarketAccount: () => perpMarket0,
+			getSpotMarketAccount: () => quoteSpotMarket,
+			getUserAccountAndSlot: () => ({ slot: 0 }),
+			activeSubAccountId: 0,
+			authority: user.authority,
+			perpMarketLastSlotCache: new Map<number, number>(),
+			spotMarketLastSlotCache: new Map<number, number>(),
+			mustIncludePerpMarketIndexes: new Set<number>(),
+			mustIncludeSpotMarketIndexes: new Set<number>(),
+		};
+
+		const metas = DriftCore.remainingAccounts.getRemainingAccounts(ctx as any, {
+			userAccounts: [user],
+		});
+
+		const keys = new Set(metas.map((m) => m.pubkey.toBase58()));
+		expect(keys.has(perpMarket0.pubkey.toBase58())).toBe(true);
+		expect(keys.has(perpMarket0.amm.oracle.toBase58())).toBe(true);
+	});
+});

package/tests/DriftCore/settlement_liquidation.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from 'bun:test';
+import { Keypair } from '@solana/web3.js';
+import { DriftCore } from '../../src/core/DriftCore';
+
+describe('DriftCore settlement/liquidation builders', () => {
+	test('buildSettlePnlInstruction wires args', async () => {
+		const called: any[] = [];
+		const fakeIx = {
+			keys: [],
+			programId: Keypair.generate().publicKey,
+			data: Buffer.alloc(0),
+		};
+		const program = {
+			instruction: {
+				settlePnl: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const pk = () => Keypair.generate().publicKey;
+
+		const ix = await DriftCore.buildSettlePnlInstruction({
+			program,
+			marketIndex: 1,
+			state: pk(),
+			authority: pk(),
+			user: pk(),
+			spotMarketVault: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(1);
+	});
+
+	test('buildLiquidatePerpInstruction wires args', async () => {
+		const called: any[] = [];
+		const fakeIx = {
+			keys: [],
+			programId: Keypair.generate().publicKey,
+			data: Buffer.alloc(0),
+		};
+		const program = {
+			instruction: {
+				liquidatePerp: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const pk = () => Keypair.generate().publicKey;
+
+		const ix = await DriftCore.buildLiquidatePerpInstruction({
+			program,
+			marketIndex: 2,
+			maxBaseAssetAmount: 123,
+			limitPrice: null,
+			state: pk(),
+			authority: pk(),
+			user: pk(),
+			userStats: pk(),
+			liquidator: pk(),
+			liquidatorStats: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(2);
+	});
+});