@drift-labs/sdk 2.26.0-beta.0 → 2.26.0-beta.2

package/src/phoenix/phoenixSubscriber.ts

@@ -0,0 +1,156 @@
+import { Connection, PublicKey, SYSVAR_CLOCK_PUBKEY } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import {
+	MarketData,
+	Client,
+	deserializeMarketData,
+	deserializeClockData,
+	toNum,
+	getMarketUiLadder,
+} from '@ellipsis-labs/phoenix-sdk';
+import { PRICE_PRECISION } from '../constants/numericConstants';
+import { BN } from '@coral-xyz/anchor';
+
+export type PhoenixMarketSubscriberConfig = {
+	connection: Connection;
+	programId: PublicKey;
+	marketAddress: PublicKey;
+	accountSubscription:
+		| {
+				// enables use to add web sockets in the future
+				type: 'polling';
+				accountLoader: BulkAccountLoader;
+		  }
+		| {
+				type: 'websocket';
+		  };
+};
+
+export class PhoenixSubscriber {
+	connection: Connection;
+	client: Client;
+	programId: PublicKey;
+	marketAddress: PublicKey;
+	subscriptionType: 'polling' | 'websocket';
+	accountLoader: BulkAccountLoader | undefined;
+	market: MarketData;
+	marketCallbackId: string | number;
+	clockCallbackId: string | number;
+
+	subscribed: boolean;
+	lastSlot: number;
+	lastUnixTimestamp: number;
+
+	public constructor(config: PhoenixMarketSubscriberConfig) {
+		this.connection = config.connection;
+		this.programId = config.programId;
+		this.marketAddress = config.marketAddress;
+		if (config.accountSubscription.type === 'polling') {
+			this.subscriptionType = 'polling';
+			this.accountLoader = config.accountSubscription.accountLoader;
+		} else {
+			this.subscriptionType = 'websocket';
+		}
+		this.lastSlot = 0;
+		this.lastUnixTimestamp = 0;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.subscribed) {
+			return;
+		}
+
+		this.market = deserializeMarketData(
+			(await this.connection.getAccountInfo(this.marketAddress, 'confirmed'))
+				.data
+		);
+
+		const clock = deserializeClockData(
+			(await this.connection.getAccountInfo(SYSVAR_CLOCK_PUBKEY, 'confirmed'))
+				.data
+		);
+		this.lastUnixTimestamp = toNum(clock.unixTimestamp);
+
+		if (this.subscriptionType === 'websocket') {
+			this.marketCallbackId = this.connection.onAccountChange(
+				this.marketAddress,
+				(accountInfo, _ctx) => {
+					this.market = deserializeMarketData(accountInfo.data);
+				}
+			);
+			this.clockCallbackId = this.connection.onAccountChange(
+				SYSVAR_CLOCK_PUBKEY,
+				(accountInfo, ctx) => {
+					this.lastSlot = ctx.slot;
+					const clock = deserializeClockData(accountInfo.data);
+					this.lastUnixTimestamp = toNum(clock.unixTimestamp);
+				}
+			);
+		} else {
+			this.marketCallbackId = await this.accountLoader.addAccount(
+				this.marketAddress,
+				(buffer, slot) => {
+					this.lastSlot = slot;
+					this.market = deserializeMarketData(buffer);
+				}
+			);
+			this.clockCallbackId = await this.accountLoader.addAccount(
+				SYSVAR_CLOCK_PUBKEY,
+				(buffer, slot) => {
+					this.lastSlot = slot;
+					const clock = deserializeClockData(buffer);
+					this.lastUnixTimestamp = toNum(clock.unixTimestamp);
+				}
+			);
+		}
+
+		this.subscribed = true;
+	}
+
+	public getBestBid(): BN {
+		const ladder = getMarketUiLadder(
+			this.market,
+			this.lastSlot,
+			this.lastUnixTimestamp,
+			1
+		);
+		return new BN(Math.floor(ladder.bids[0][0] * PRICE_PRECISION.toNumber()));
+	}
+
+	public getBestAsk(): BN {
+		const ladder = getMarketUiLadder(
+			this.market,
+			this.lastSlot,
+			this.lastUnixTimestamp,
+			1
+		);
+		return new BN(Math.floor(ladder.asks[0][0] * PRICE_PRECISION.toNumber()));
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscribed) {
+			return;
+		}
+
+		// remove listeners
+		if (this.subscriptionType === 'websocket') {
+			await this.connection.removeAccountChangeListener(
+				this.marketCallbackId as number
+			);
+			await this.connection.removeAccountChangeListener(
+				this.clockCallbackId as number
+			);
+		} else {
+			this.accountLoader.removeAccount(
+				this.marketAddress,
+				this.marketCallbackId as string
+			);
+			this.accountLoader.removeAccount(
+				SYSVAR_CLOCK_PUBKEY,
+				this.clockCallbackId as string
+			);
+		}
+
+		this.subscribed = false;
+	}
+}

package/src/serum/serumSubscriber.ts

@@ -4,8 +4,9 @@ import { Market, Orderbook } from '@project-serum/serum';
 import { SerumMarketSubscriberConfig } from './types';
 import { BN } from '@coral-xyz/anchor';
 import { PRICE_PRECISION } from '../constants/numericConstants';
+import { L2Level, L2OrderBookGenerator } from '../dlob/orderBookLevels';
 
-export class SerumSubscriber {
+export class SerumSubscriber implements L2OrderBookGenerator {
 	connection: Connection;
 	programId: PublicKey;
 	marketAddress: PublicKey;
@@ -112,6 +113,31 @@ export class SerumSubscriber {
 		return new BN(bestAsk[0] * 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> {
+		// @ts-ignore
+		const basePrecision = Math.pow(10, this.market._baseSplTokenDecimals);
+		const pricePrecision = PRICE_PRECISION.toNumber();
+		for (let { price, size } of this[side].items(side === 'bids')) {
+			price = new BN(price * pricePrecision);
+			size = new BN(size * basePrecision);
+			yield {
+				price,
+				size,
+				sources: {
+					serum: size,
+				},
+			};
+		}
+	}
+
 	public async unsubscribe(): Promise<void> {
 		if (!this.subscribed) {
 			return;

package/src/token/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+function parseTokenAccount(data) {
+    const accountInfo = spl_token_1.AccountLayout.decode(data);
+    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
+    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
+    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
+    if (accountInfo.delegateOption === 0) {
+        accountInfo.delegate = null;
+        // eslint-disable-next-line new-cap
+        accountInfo.delegatedAmount = new spl_token_1.u64(0);
+    }
+    else {
+        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
+        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
+    }
+    accountInfo.isInitialized = accountInfo.state !== 0;
+    accountInfo.isFrozen = accountInfo.state === 2;
+    if (accountInfo.isNativeOption === 1) {
+        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
+        accountInfo.isNative = true;
+    }
+    else {
+        accountInfo.rentExemptReserve = null;
+        accountInfo.isNative = false;
+    }
+    if (accountInfo.closeAuthorityOption === 0) {
+        accountInfo.closeAuthority = null;
+    }
+    else {
+        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
+    }
+    return accountInfo;
+}
+exports.parseTokenAccount = parseTokenAccount;

package/src/types.ts

@@ -585,6 +585,7 @@ export type HistoricalIndexData = {
 export type SpotMarketAccount = {
 	status: MarketStatus;
 	assetTier: AssetTier;
+	name: number[];
 
 	marketIndex: number;
 	pubkey: PublicKey;

package/src/util/computeUnits.js

@@ -0,0 +1,27 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findComputeUnitConsumption = void 0;
+function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tx = yield connection.getTransaction(txSignature, { commitment });
+        const computeUnits = [];
+        const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`);
+        tx.meta.logMessages.forEach((logMessage) => {
+            const match = logMessage.match(regex);
+            if (match && match[1]) {
+                computeUnits.push(match[1]);
+            }
+        });
+        return computeUnits;
+    });
+}
+exports.findComputeUnitConsumption = findComputeUnitConsumption;

package/src/util/getTokenAddress.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAddress = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const getTokenAddress = (mintAddress, userPubKey) => {
+    return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+};
+exports.getTokenAddress = getTokenAddress;

package/src/util/promiseTimeout.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+function promiseTimeout(promise, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(null), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).then((result) => {
+        clearTimeout(timeoutId);
+        return result;
+    });
+}
+exports.promiseTimeout = promiseTimeout;

package/src/util/tps.js

@@ -0,0 +1,27 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTps = void 0;
+function estimateTps(programId, connection, failed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let signatures = yield connection.getSignaturesForAddress(programId, undefined, 'finalized');
+        if (failed) {
+            signatures = signatures.filter((signature) => signature.err);
+        }
+        const numberOfSignatures = signatures.length;
+        if (numberOfSignatures === 0) {
+            return 0;
+        }
+        return (numberOfSignatures /
+            (signatures[0].blockTime - signatures[numberOfSignatures - 1].blockTime));
+    });
+}
+exports.estimateTps = estimateTps;

package/tests/dlob/helpers.ts

@@ -254,6 +254,7 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 	{
 		status: MarketStatus.ACTIVE,
 		assetTier: AssetTier.COLLATERAL,
+		name: [],
 		maxTokenDeposits: new BN(100),
 		marketIndex: 0,
 		pubkey: PublicKey.default,
@@ -328,6 +329,7 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 	{
 		status: MarketStatus.ACTIVE,
 		assetTier: AssetTier.CROSS,
+		name: [],
 		maxTokenDeposits: new BN(100),
 		marketIndex: 1,
 		pubkey: PublicKey.default,
@@ -402,6 +404,7 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 	{
 		status: MarketStatus.ACTIVE,
 		assetTier: AssetTier.PROTECTED,
+		name: [],
 		maxTokenDeposits: new BN(100),
 		marketIndex: 2,
 		pubkey: PublicKey.default,