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

package/tests/insurance/test.ts

@@ -0,0 +1,40 @@
+import { BN, ZERO, timeRemainingUntilUpdate, ONE } from '../../src';
+// import { mockPerpMarkets } from '../dlob/helpers';
+
+import { assert } from '../../src/assert/assert';
+
+describe('Insurance Tests', () => {
+	it('time remaining updates', () => {
+		const now = new BN(1683576852);
+		const lastUpdate = new BN(1683576000);
+		const period = new BN(3600); //hourly
+
+		let tr;
+		// console.log(now.sub(lastUpdate).toString());
+
+		tr = timeRemainingUntilUpdate(now, lastUpdate, period);
+		// console.log(tr.toString());
+		assert(tr.eq(new BN('2748')));
+
+		tr = timeRemainingUntilUpdate(now, lastUpdate.sub(period), period);
+		// console.log(tr.toString());
+		assert(tr.eq(ZERO));
+
+		const tooLateUpdate = lastUpdate.sub(period.div(new BN(3)).add(ONE));
+		tr = timeRemainingUntilUpdate(
+			tooLateUpdate.add(ONE),
+			tooLateUpdate,
+			period
+		);
+		// console.log(tr.toString());
+		assert(tr.eq(new BN('4800')));
+
+		tr = timeRemainingUntilUpdate(now, lastUpdate.add(ONE), period);
+		// console.log(tr.toString());
+		assert(tr.eq(new BN('2748')));
+
+		tr = timeRemainingUntilUpdate(now, lastUpdate.sub(ONE), period);
+		// console.log(tr.toString());
+		assert(tr.eq(new BN('2748')));
+	});
+});

package/tests/spot/test.ts

@@ -0,0 +1,226 @@
+import {
+	BN,
+	ZERO,
+	calculateSpotMarketBorrowCapacity,
+	SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION,
+	calculateSizePremiumLiabilityWeight,
+	calculateBorrowRate,
+	calculateDepositRate,
+} from '../../src';
+import { mockSpotMarkets } from '../dlob/helpers';
+import * as _ from 'lodash';
+
+import { assert } from '../../src/assert/assert';
+
+describe('Spot Tests', () => {
+	it('size premium via imf factor', () => {
+		const maintLiabWgt = new BN(1.1 * 1e4);
+
+		const ans0 = calculateSizePremiumLiabilityWeight(
+			new BN(200000 * 1e9),
+			ZERO,
+			maintLiabWgt,
+			new BN(1e4)
+		);
+		assert(ans0.eq(maintLiabWgt));
+
+		const ans = calculateSizePremiumLiabilityWeight(
+			new BN(200000 * 1e9),
+			new BN(0.00055 * 1e6),
+			maintLiabWgt,
+			new BN(1e4)
+		);
+		assert(ans.eq(new BN('11259')));
+		assert(ans.gt(maintLiabWgt));
+
+		const ans2 = calculateSizePremiumLiabilityWeight(
+			new BN(10000 * 1e9),
+			new BN(0.003 * 1e6),
+			maintLiabWgt,
+			new BN(1e4)
+		);
+		assert(ans2.eq(new BN('11800')));
+		assert(ans.gt(maintLiabWgt));
+
+		const ans3 = calculateSizePremiumLiabilityWeight(
+			new BN(100000 * 1e9),
+			new BN(0.003 * 1e6),
+			maintLiabWgt,
+			new BN(1e4)
+		);
+		assert(ans3.eq(new BN('18286')));
+		assert(ans3.gt(maintLiabWgt));
+	});
+
+	it('base borrow capacity', () => {
+		const mockSpot = _.cloneDeep(mockSpotMarkets[0]);
+		mockSpot.maxBorrowRate = 1000000;
+		mockSpot.optimalBorrowRate = 100000;
+		mockSpot.optimalUtilization = 700000;
+
+		mockSpot.decimals = 9;
+		mockSpot.cumulativeDepositInterest =
+			SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION;
+		mockSpot.cumulativeBorrowInterest =
+			SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION;
+
+		const tokenAmount = 100000;
+		// no borrows
+		mockSpot.depositBalance = new BN(tokenAmount * 1e9);
+		mockSpot.borrowBalance = ZERO;
+
+		// todo, should incorp all other spot market constraints?
+		const { remainingCapacity: aboveMaxAmount } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(2000000));
+		assert(aboveMaxAmount.gt(mockSpot.depositBalance));
+
+		const { remainingCapacity: maxAmount } = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(1000000)
+		);
+		assert(maxAmount.eq(mockSpot.depositBalance));
+
+		const { remainingCapacity: optAmount } = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(100000)
+		);
+		const ans = new BN((mockSpot.depositBalance.toNumber() * 7) / 10);
+		// console.log('optAmount:', optAmount.toNumber(), ans.toNumber());
+		assert(optAmount.eq(ans));
+
+		const { remainingCapacity: betweenOptMaxAmount } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(810000));
+		// console.log('betweenOptMaxAmount:', betweenOptMaxAmount.toNumber());
+		assert(betweenOptMaxAmount.lt(mockSpot.depositBalance));
+		assert(betweenOptMaxAmount.gt(ans));
+		assert(betweenOptMaxAmount.eq(new BN(93666600000000)));
+
+		const { remainingCapacity: belowOptAmount } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(50000));
+		// console.log('belowOptAmount:', belowOptAmount.toNumber());
+		assert(belowOptAmount.eq(ans.div(new BN(2))));
+
+		const { remainingCapacity: belowOptAmount2 } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(24900));
+		// console.log('belowOptAmount2:', belowOptAmount2.toNumber());
+		assert(belowOptAmount2.lt(ans.div(new BN(4))));
+		assert(belowOptAmount2.eq(new BN('17430000000000')));
+
+		const { remainingCapacity: belowOptAmount3 } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(1));
+		// console.log('belowOptAmount3:', belowOptAmount3.toNumber());
+		assert(belowOptAmount3.eq(new BN('700000000'))); //0.7
+	});
+
+	it('complex borrow capacity', () => {
+		const mockSpot = _.cloneDeep(mockSpotMarkets[0]);
+		mockSpot.maxBorrowRate = 1000000;
+		mockSpot.optimalBorrowRate = 70000;
+		mockSpot.optimalUtilization = 700000;
+
+		mockSpot.decimals = 9;
+		mockSpot.cumulativeDepositInterest = new BN(
+			1.0154217042 * SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION.toNumber()
+		);
+		mockSpot.cumulativeBorrowInterest = new BN(
+			1.0417153549 * SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION.toNumber()
+		);
+
+		mockSpot.depositBalance = new BN(88522.734106451 * 1e9);
+		mockSpot.borrowBalance = new BN(7089.91675884 * 1e9);
+
+		// todo, should incorp all other spot market constraints?
+		const { remainingCapacity: aboveMaxAmount } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(2000000));
+		assert(aboveMaxAmount.eq(new BN('111498270939007')));
+
+		const { remainingCapacity: maxAmount } = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(1000000)
+		);
+		assert(maxAmount.eq(new BN('82502230374168')));
+		// console.log('aboveMaxAmount:', aboveMaxAmount.toNumber(), 'maxAmount:', maxAmount.toNumber());
+		const { remainingCapacity: optAmount } = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(70000)
+		);
+		// console.log('optAmount:', optAmount.toNumber());
+		assert(optAmount.eq(new BN('55535858716123'))); // ~ 55535
+
+		const { remainingCapacity: betweenOptMaxAmount } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(810000));
+		// console.log('betweenOptMaxAmount:', betweenOptMaxAmount.toNumber());
+		assert(betweenOptMaxAmount.lt(maxAmount));
+		assert(betweenOptMaxAmount.eq(new BN(76992910756523)));
+		assert(betweenOptMaxAmount.gt(optAmount));
+
+		const { remainingCapacity: belowOptAmount } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(50000));
+		// console.log('belowOptAmount:', belowOptAmount.toNumber());
+		assert(belowOptAmount.eq(new BN('37558277610760')));
+
+		const { remainingCapacity: belowOptAmount2 } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(24900));
+		// console.log('belowOptAmount2:', belowOptAmount2.toNumber());
+		assert(belowOptAmount2.eq(new BN('14996413323529')));
+
+		const { remainingCapacity: belowOptAmount3 } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(4900));
+		// console.log('belowOptAmount2:', belowOptAmount3.toNumber());
+		assert(belowOptAmount3.eq(new BN('0')));
+
+		const { remainingCapacity: belowOptAmount4 } =
+			calculateSpotMarketBorrowCapacity(mockSpot, new BN(1));
+		// console.log('belowOptAmount3:', belowOptAmount4.toNumber());
+		assert(belowOptAmount4.eq(new BN('0')));
+	});
+
+	it('borrow rates', () => {
+		const mockSpot = _.cloneDeep(mockSpotMarkets[0]);
+		mockSpot.maxBorrowRate = 1000000;
+		mockSpot.optimalBorrowRate = 70000;
+		mockSpot.optimalUtilization = 700000;
+
+		mockSpot.decimals = 9;
+		mockSpot.cumulativeDepositInterest = new BN(
+			1.0154217042 * SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION.toNumber()
+		);
+		mockSpot.cumulativeBorrowInterest = new BN(
+			1.0417153549 * SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION.toNumber()
+		);
+
+		mockSpot.depositBalance = new BN(88522.734106451 * 1e9);
+		mockSpot.borrowBalance = new BN(17089.91675884 * 1e9);
+
+		const noDeltad = calculateDepositRate(mockSpot);
+		// console.log(noDeltad.toNumber());
+		assert(noDeltad.eqn(3922));
+		const noDelta = calculateBorrowRate(mockSpot);
+		// console.log(noDelta.toNumber());
+		assert(noDelta.eqn(19805));
+
+		// manually update deposits
+		mockSpot.depositBalance = new BN((88522.734106451 + 9848.12512736) * 1e9);
+		const noDeltad2 = calculateDepositRate(mockSpot);
+		console.log(noDeltad2.toNumber());
+		assert(noDeltad2.eqn(3176));
+		const noDelta2 = calculateBorrowRate(mockSpot);
+		console.log(noDelta2.toNumber());
+		assert(noDelta2.eqn(17822));
+
+		mockSpot.depositBalance = new BN(88522.734106451 * 1e9);
+		const addDep1d = calculateDepositRate(mockSpot, new BN(10000 * 1e9));
+		// console.log(addDep1d.toNumber());
+		assert(addDep1d.eqn(3176)); // went down
+		const addDep1 = calculateBorrowRate(mockSpot, new BN(10000 * 1e9));
+		// console.log(addDep1.toNumber());
+		assert(addDep1.eqn(17822)); // went down
+
+		const addBord1 = calculateDepositRate(mockSpot, new BN(-1000 * 1e9));
+		// console.log(addBord1.toNumber());
+		assert(addBord1.eqn(4375)); // went up
+		const addBor1 = calculateBorrowRate(mockSpot, new BN(-1000 * 1e9));
+		// console.log(addBor1.toNumber());
+		assert(addBor1.eqn(20918)); // went up
+	});
+});

package/tests/subscriber/openbook.ts

@@ -0,0 +1,62 @@
+import { OpenbookV2Subscriber, PRICE_PRECISION } from '../../src';
+import { Connection, PublicKey } from '@solana/web3.js';
+
+describe('openbook v2 subscriber', function () {
+	this.timeout(100_000);
+
+	it('works', async function () {
+		if (!process.env.MAINNET_RPC_ENDPOINT) {
+			return;
+		}
+
+		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();
+	});
+});

package/tests/tx/TransactionConfirmationManager.test.ts

@@ -0,0 +1,305 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import {
+	Connection,
+	SignatureStatus,
+	VersionedTransactionResponse,
+} from '@solana/web3.js';
+import { TransactionConfirmationManager } from '../../src/util/TransactionConfirmationManager';
+import assert from 'assert';
+
+describe('TransactionConfirmationManager_Polling_Tests', () => {
+	let manager: TransactionConfirmationManager;
+	let mockConnection: sinon.SinonStubbedInstance<Connection>;
+
+	beforeEach(() => {
+		mockConnection = sinon.createStubInstance(Connection);
+		manager = new TransactionConfirmationManager(
+			mockConnection as unknown as Connection
+		);
+	});
+
+	afterEach(() => {
+		sinon.restore();
+	});
+
+	it('should throw error for invalid poll interval', async () => {
+		try {
+			await manager.confirmTransactionPolling(
+				'fakeTxSig',
+				'confirmed',
+				30000,
+				300
+			);
+			assert.fail('Expected an error to be thrown');
+		} catch (error) {
+			assert(error instanceof Error);
+			assert.strictEqual(
+				error.message,
+				'Transaction confirmation polling interval must be at least 400ms and a multiple of 100ms'
+			);
+		}
+	});
+
+	it('should resolve when transaction is confirmed', async () => {
+		const fakeTxSig = 'fakeTxSig';
+		const fakeStatus: SignatureStatus = {
+			slot: 100,
+			confirmations: 1,
+			err: null,
+			confirmationStatus: 'confirmed',
+		};
+
+		mockConnection.getSignatureStatuses.resolves({
+			context: { slot: 100 },
+			value: [fakeStatus],
+		});
+
+		const result = await manager.confirmTransactionPolling(
+			fakeTxSig,
+			'confirmed',
+			30000,
+			400
+		);
+
+		expect(result).to.deep.equal(fakeStatus);
+		expect(
+			mockConnection.getSignatureStatuses.calledWith([fakeTxSig], {
+				searchTransactionHistory: false,
+			})
+		).to.be.true;
+	});
+
+	it('should reject when transaction fails', async function () {
+		const fakeTxSig = 'fakeTxSig';
+		const fakeStatus: SignatureStatus = {
+			slot: 100,
+			confirmations: 1,
+			err: { InstructionError: [0, 'Custom'] },
+			confirmationStatus: 'confirmed',
+		};
+
+		mockConnection.getSignatureStatuses.resolves({
+			context: { slot: 100 },
+			value: [fakeStatus],
+		});
+
+		// The transaction manager falls into getTransaction when it detects a transaction failure so we need to mock that as well
+		// @ts-ignore
+		mockConnection.getTransaction.resolves({
+			meta: {
+				logMessages: ['Transaction failed: Custom'],
+				err: { InstructionError: [0, 'Custom'] },
+			},
+		} as VersionedTransactionResponse);
+
+		try {
+			await manager.confirmTransactionPolling(
+				fakeTxSig,
+				'confirmed',
+				30000,
+				400
+			);
+			assert.fail('Expected an error to be thrown');
+		} catch (error) {
+			return;
+		}
+	});
+
+	it('should reject on timeout', async () => {
+		const clock = sinon.useFakeTimers();
+
+		const fakeTxSig = 'fakeTxSig';
+		mockConnection.getSignatureStatuses.resolves({
+			context: { slot: 100 },
+			value: [null],
+		});
+
+		const promise = manager.confirmTransactionPolling(
+			fakeTxSig,
+			'confirmed',
+			5000,
+			1000
+		);
+
+		clock.tick(6000);
+
+		try {
+			await promise;
+			assert.fail('Expected an error to be thrown');
+		} catch (error) {
+			assert(error instanceof Error);
+			assert.strictEqual(
+				error.message,
+				'Transaction confirmation timeout after 5000ms'
+			);
+		}
+
+		clock.restore();
+	});
+
+	it('should check multiple transactions together', async () => {
+		const fakeTxSig1 = 'fakeTxSig1';
+		const fakeTxSig2 = 'fakeTxSig2';
+		const fakeStatus1: SignatureStatus = {
+			slot: 100,
+			confirmations: 1,
+			err: null,
+			confirmationStatus: 'confirmed',
+		};
+		const fakeStatus2: SignatureStatus = {
+			slot: 100,
+			confirmations: 1,
+			err: null,
+			confirmationStatus: 'confirmed',
+		};
+
+		mockConnection.getSignatureStatuses.resolves({
+			context: { slot: 100 },
+			value: [fakeStatus1, fakeStatus2],
+		});
+
+		const promise1 = manager.confirmTransactionPolling(
+			fakeTxSig1,
+			'confirmed',
+			30000,
+			400
+		);
+		const promise2 = manager.confirmTransactionPolling(
+			fakeTxSig2,
+			'confirmed',
+			30000,
+			400
+		);
+
+		const clock = sinon.useFakeTimers();
+		clock.tick(400);
+		clock.restore();
+
+		const [result1, result2] = await Promise.all([promise1, promise2]);
+
+		expect(result1).to.deep.equal(fakeStatus1);
+		expect(result2).to.deep.equal(fakeStatus2);
+		expect(
+			mockConnection.getSignatureStatuses.calledWith([fakeTxSig1, fakeTxSig2], {
+				searchTransactionHistory: false,
+			})
+		).to.be.true;
+	});
+
+	it('should have overlapping request for transactions with 400ms and 1200ms intervals on the third 400ms interval', async function () {
+		this.timeout(5000); // Increase timeout for this test to 5 seconds
+
+		const fakeTxSig1 = 'fakeTxSig1'; // 400ms interval
+		const fakeTxSig2 = 'fakeTxSig2'; // 1200ms interval
+		const fakeStatus: SignatureStatus = {
+			slot: 100,
+			confirmations: 1,
+			err: null,
+			confirmationStatus: 'confirmed',
+		};
+
+		let callCount = 0;
+		const callTimes: number[] = [];
+		const callSignatures: string[][] = [];
+
+		mockConnection.getSignatureStatuses = async (signatures) => {
+			callCount++;
+			const currentTime = Date.now();
+			callTimes.push(currentTime);
+			callSignatures.push([...signatures]);
+
+			if (callCount < 3) {
+				return {
+					context: { slot: 100 },
+					value: signatures.map(() => null),
+				};
+			} else {
+				return {
+					context: { slot: 100 },
+					value: signatures.map(() => fakeStatus),
+				};
+			}
+		};
+
+		const startTime = Date.now();
+
+		// Start both confirmation processes
+		const promise1 = manager.confirmTransactionPolling(
+			fakeTxSig1,
+			'confirmed',
+			5000,
+			400
+		);
+		const promise2 = manager.confirmTransactionPolling(
+			fakeTxSig2,
+			'confirmed',
+			5000,
+			1200
+		);
+
+		// Wait for 1250ms to ensure we've hit the third 400ms interval and first 1200ms interval
+		await new Promise((resolve) => setTimeout(resolve, 1250));
+
+		// Resolve both promises
+		await Promise.all([promise1, promise2]);
+
+		// Check the call times and signatures
+		assert.strictEqual(callTimes.length, 3, 'Should have exactly 3 calls');
+
+		// Check if the third call is close to 1200ms and includes both signatures
+		const overlapCall = 2; // The third call should be the overlapping one
+		const overlapTime = callTimes[overlapCall] - startTime;
+
+		assert(
+			Math.abs(overlapTime - 1200) < 100,
+			`Overlapping call should be around 1200ms, but was at ${overlapTime}ms`
+		);
+
+		// Verify the call pattern
+		assert(
+			callSignatures[0].includes(fakeTxSig1) &&
+				!callSignatures[0].includes(fakeTxSig2),
+			'First call should only include 400ms interval transaction'
+		);
+		assert(
+			callSignatures[1].includes(fakeTxSig1) &&
+				!callSignatures[1].includes(fakeTxSig2),
+			'Second call should only include 400ms interval transaction'
+		);
+		assert(
+			callSignatures[2].includes(fakeTxSig1) &&
+				callSignatures[2].includes(fakeTxSig2),
+			'Third call should include both transactions'
+		);
+
+		// Wait for 1000ms to check that we haven't made any more calls now that all transactions are confirmed
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+
+		// Verify that no more calls were made
+		assert.strictEqual(
+			callTimes.length,
+			3,
+			'Should not have made any more calls after all transactions are confirmed'
+		);
+
+		// Verify that only the third call returns non-null results
+		callCount = 0;
+		const results = await Promise.all(
+			callSignatures.map((sigs) => mockConnection.getSignatureStatuses!(sigs))
+		);
+
+		assert(
+			results[0].value.every((v) => v === null),
+			'First call should return null results'
+		);
+		assert(
+			results[1].value.every((v) => v === null),
+			'Second call should return null results'
+		);
+		assert(
+			results[2].value.every((v) => v !== null),
+			'Third call should return non-null results'
+		);
+	});
+});