@drift-labs/sdk 2.98.0-beta.9 → 2.99.0-beta.1

package/lib/node/slot/SlothashSubscriber.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlothashSubscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+const anchor_1 = require("@coral-xyz/anchor");
+class SlothashSubscriber {
+    constructor(connection, config) {
+        var _a;
+        this.connection = connection;
+        this.isUnsubscribing = false;
+        this.receivingData = false;
+        this.resubTimeoutMs = config === null || config === void 0 ? void 0 : config.resubTimeoutMs;
+        this.commitment = (_a = config === null || config === void 0 ? void 0 : config.commitment) !== null && _a !== void 0 ? _a : 'processed';
+        if (this.resubTimeoutMs < 1000) {
+            console.log('resubTimeoutMs should be at least 1000ms to avoid spamming resub');
+        }
+    }
+    async subscribe() {
+        if (this.subscriptionId != null) {
+            return;
+        }
+        const currentAccountData = await this.connection.getAccountInfo(web3_js_1.SYSVAR_SLOT_HASHES_PUBKEY, this.commitment);
+        if (currentAccountData == null) {
+            throw new Error('Failed to retrieve current slot hash');
+        }
+        this.currentSlothash = deserializeSlothash(currentAccountData.data);
+        this.subscriptionId = this.connection.onAccountChange(web3_js_1.SYSVAR_SLOT_HASHES_PUBKEY, (slothashInfo, context) => {
+            if (!this.currentSlothash || this.currentSlothash.slot < context.slot) {
+                if (this.resubTimeoutMs && !this.isUnsubscribing) {
+                    this.receivingData = true;
+                    clearTimeout(this.timeoutId);
+                    this.setTimeout();
+                }
+                this.currentSlothash = deserializeSlothash(slothashInfo.data);
+            }
+        }, this.commitment);
+        if (this.resubTimeoutMs) {
+            this.receivingData = true;
+            this.setTimeout();
+        }
+    }
+    setTimeout() {
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                console.log(`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`);
+                await this.unsubscribe(true);
+                this.receivingData = false;
+                await this.subscribe();
+            }
+        }, this.resubTimeoutMs);
+    }
+    getSlothash() {
+        return this.currentSlothash;
+    }
+    async unsubscribe(onResub = false) {
+        if (!onResub) {
+            this.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.subscriptionId != null) {
+            await this.connection.removeSlotChangeListener(this.subscriptionId);
+            this.subscriptionId = undefined;
+            this.isUnsubscribing = false;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.SlothashSubscriber = SlothashSubscriber;
+function deserializeSlothash(data) {
+    const slotNumber = new anchor_1.BN(data.subarray(8, 16), 10, 'le');
+    const hash = bytes_1.bs58.encode(data.subarray(16, 48));
+    return {
+        slot: slotNumber.toNumber(),
+        hash,
+    };
+}

package/lib/node/types.d.ts

@@ -647,8 +647,9 @@ export type SwiftOrderRecord = {
     user: PublicKey;
     hash: string;
     matchingOrderParams: OrderParams;
-    swiftOrderSlot: BN;
-    userNextOrderId: number;
+    swiftOrderMaxSlot: BN;
+    swiftOrderUuid: Uint8Array;
+    userOrderId: number;
 };
 export type OrderRecord = {
     ts: BN;
@@ -1118,10 +1119,10 @@ export declare const DefaultOrderParams: OrderParams;
 export type SwiftServerMessage = {
     slot: BN;
     swiftOrderSignature: Uint8Array;
+    uuid: Uint8Array;
 };
 export type SwiftOrderParamsMessage = {
     swiftOrderParams: OptionalOrderParams;
-    expectedOrderId: number;
     subAccountId: number;
     takeProfitOrderParams: SwiftTriggerOrderParams | null;
     stopLossOrderParams: SwiftTriggerOrderParams | null;

package/lib/node/user.js

@@ -1811,6 +1811,9 @@ class User {
         const state = this.driftClient.getStateAccount();
         let feeTierIndex = 0;
         if ((0, types_1.isVariant)(marketType, 'perp')) {
+            if (this.isHighLeverageMode()) {
+                return state.perpFeeStructure.feeTiers[0];
+            }
             const userStatsAccount = this.driftClient
                 .getUserStats()
                 .getAccount();

package/lib/node/userMap/referrerMap.d.ts

@@ -0,0 +1,45 @@
+import { MemcmpFilter } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { DriftClient } from '../driftClient';
+import { ReferrerInfo } from '../types';
+export declare class ReferrerMap {
+    /**
+     * map from authority pubkey to ReferrerInfo.
+     * - if a user has not been entered into the map, the value is undefined
+     * - if a user has no referrer, the value is null
+     * - if a user has a referrer, the value is a ReferrerInfo object
+     */
+    private referrerMap;
+    private driftClient;
+    private bulkAccountLoader;
+    private parallelSync;
+    private fetchPromise?;
+    private fetchPromiseResolver;
+    /**
+     * Creates a new UserStatsMap instance.
+     *
+     * @param {DriftClient} driftClient - The DriftClient instance.
+     * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
+     */
+    constructor(driftClient: DriftClient, bulkAccountLoader?: BulkAccountLoader, parallelSync?: boolean);
+    /**
+     * Subscribe to all UserStats accounts.
+     */
+    subscribe(): Promise<void>;
+    has(authorityPublicKey: string): boolean;
+    get(authorityPublicKey: string): ReferrerInfo | undefined;
+    addReferrerInfo(authority: string, referrerInfo?: ReferrerInfo | null): Promise<void>;
+    /**
+     * Enforce that a UserStats will exist for the given authorityPublicKey,
+     * reading one from the blockchain if necessary.
+     * @param authorityPublicKey
+     * @returns
+     */
+    mustGet(authorityPublicKey: string): Promise<ReferrerInfo | undefined>;
+    values(): IterableIterator<ReferrerInfo | null>;
+    size(): number;
+    sync(): Promise<void>;
+    syncAll(): Promise<void>;
+    syncReferrer(referrerFilter: MemcmpFilter): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/userMap/referrerMap.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferrerMap = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const bulkAccountLoader_1 = require("../accounts/bulkAccountLoader");
+const pda_1 = require("../addresses/pda");
+const memcmp_1 = require("../memcmp");
+const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+const DEFAULT_PUBLIC_KEY = web3_js_1.PublicKey.default.toBase58();
+class ReferrerMap {
+    /**
+     * Creates a new UserStatsMap instance.
+     *
+     * @param {DriftClient} driftClient - The DriftClient instance.
+     * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
+     */
+    constructor(driftClient, bulkAccountLoader, parallelSync) {
+        /**
+         * map from authority pubkey to ReferrerInfo.
+         * - if a user has not been entered into the map, the value is undefined
+         * - if a user has no referrer, the value is null
+         * - if a user has a referrer, the value is a ReferrerInfo object
+         */
+        this.referrerMap = new Map();
+        this.driftClient = driftClient;
+        if (!bulkAccountLoader) {
+            bulkAccountLoader = new bulkAccountLoader_1.BulkAccountLoader(driftClient.connection, driftClient.opts.commitment, 0);
+        }
+        this.bulkAccountLoader = bulkAccountLoader;
+        this.parallelSync = parallelSync !== undefined ? parallelSync : true;
+    }
+    /**
+     * Subscribe to all UserStats accounts.
+     */
+    async subscribe() {
+        if (this.size() > 0) {
+            return;
+        }
+        await this.driftClient.subscribe();
+        await this.sync();
+    }
+    has(authorityPublicKey) {
+        return this.referrerMap.has(authorityPublicKey);
+    }
+    get(authorityPublicKey) {
+        const info = this.referrerMap.get(authorityPublicKey);
+        return info === null ? undefined : info;
+    }
+    async addReferrerInfo(authority, referrerInfo) {
+        if (referrerInfo || referrerInfo === null) {
+            this.referrerMap.set(authority, referrerInfo);
+        }
+        else if (referrerInfo === undefined) {
+            const userStatsAccountPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, new web3_js_1.PublicKey(authority));
+            const buffer = (await this.driftClient.connection.getAccountInfo(userStatsAccountPublicKey, 'processed')).data;
+            const referrer = bytes_1.bs58.encode(buffer.subarray(40, 72));
+            const referrerKey = new web3_js_1.PublicKey(referrer);
+            this.addReferrerInfo(authority, referrer === DEFAULT_PUBLIC_KEY
+                ? null
+                : {
+                    referrer: (0, pda_1.getUserAccountPublicKeySync)(this.driftClient.program.programId, referrerKey, 0),
+                    referrerStats: (0, pda_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, referrerKey),
+                });
+        }
+    }
+    /**
+     * Enforce that a UserStats will exist for the given authorityPublicKey,
+     * reading one from the blockchain if necessary.
+     * @param authorityPublicKey
+     * @returns
+     */
+    async mustGet(authorityPublicKey) {
+        if (!this.has(authorityPublicKey)) {
+            await this.addReferrerInfo(authorityPublicKey);
+        }
+        return this.get(authorityPublicKey);
+    }
+    values() {
+        return this.referrerMap.values();
+    }
+    size() {
+        return this.referrerMap.size;
+    }
+    async sync() {
+        if (this.fetchPromise) {
+            return this.fetchPromise;
+        }
+        this.fetchPromise = new Promise((resolver) => {
+            this.fetchPromiseResolver = resolver;
+        });
+        try {
+            if (this.parallelSync) {
+                await Promise.all([
+                    this.syncAll(),
+                    this.syncReferrer((0, memcmp_1.getUserStatsIsReferredFilter)()),
+                    this.syncReferrer((0, memcmp_1.getUserStatsIsReferredOrReferrerFilter)()),
+                ]);
+            }
+            else {
+                await this.syncAll();
+                await this.syncReferrer((0, memcmp_1.getUserStatsIsReferredFilter)());
+                await this.syncReferrer((0, memcmp_1.getUserStatsIsReferredOrReferrerFilter)());
+            }
+        }
+        catch (e) {
+            console.error('error in referrerMap.sync', e);
+        }
+        finally {
+            this.fetchPromiseResolver();
+            this.fetchPromise = undefined;
+        }
+    }
+    async syncAll() {
+        const rpcRequestArgs = [
+            this.driftClient.program.programId.toBase58(),
+            {
+                commitment: this.driftClient.opts.commitment,
+                filters: [(0, memcmp_1.getUserStatsFilter)()],
+                encoding: 'base64',
+                dataSlice: {
+                    offset: 0,
+                    length: 0,
+                },
+                withContext: true,
+            },
+        ];
+        const rpcJSONResponse = 
+        // @ts-ignore
+        await this.driftClient.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
+        const rpcResponseAndContext = rpcJSONResponse.result;
+        for (const account of rpcResponseAndContext.value) {
+            // only add if it isn't already in the map
+            // so that if syncReferrer already set it, we dont overwrite
+            if (!this.has(account.pubkey)) {
+                this.addReferrerInfo(account.pubkey, null);
+            }
+        }
+    }
+    async syncReferrer(referrerFilter) {
+        const rpcRequestArgs = [
+            this.driftClient.program.programId.toBase58(),
+            {
+                commitment: this.driftClient.opts.commitment,
+                filters: [(0, memcmp_1.getUserStatsFilter)(), referrerFilter],
+                encoding: 'base64',
+                dataSlice: {
+                    offset: 0,
+                    length: 72,
+                },
+                withContext: true,
+            },
+        ];
+        const rpcJSONResponse = 
+        // @ts-ignore
+        await this.driftClient.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
+        const rpcResponseAndContext = rpcJSONResponse.result;
+        const batchSize = 1000;
+        for (let i = 0; i < rpcResponseAndContext.value.length; i += batchSize) {
+            const batch = rpcResponseAndContext.value.slice(i, i + batchSize);
+            await Promise.all(batch.map(async (programAccount) => {
+                // @ts-ignore
+                const buffer = Buffer.from(programAccount.account.data[0], programAccount.account.data[1]);
+                const authority = bytes_1.bs58.encode(buffer.subarray(8, 40));
+                const referrer = bytes_1.bs58.encode(buffer.subarray(40, 72));
+                const referrerKey = new web3_js_1.PublicKey(referrer);
+                this.addReferrerInfo(authority, referrer === DEFAULT_PUBLIC_KEY
+                    ? null
+                    : {
+                        referrer: (0, pda_1.getUserAccountPublicKeySync)(this.driftClient.program.programId, referrerKey, 0),
+                        referrerStats: (0, pda_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, referrerKey),
+                    });
+            }));
+            await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+    }
+    async unsubscribe() {
+        this.referrerMap.clear();
+    }
+}
+exports.ReferrerMap = ReferrerMap;

package/lib/node/util/digest.d.ts

@@ -1,3 +1,4 @@
 /// <reference types="node" />
 /// <reference types="node" />
 export declare function digest(data: Buffer): Buffer;
+export declare function digestSignature(signature: Uint8Array): string;

package/lib/node/util/digest.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.digest = void 0;
+exports.digestSignature = exports.digest = void 0;
 const crypto_1 = require("crypto");
 function digest(data) {
     const hash = (0, crypto_1.createHash)('sha256');
@@ -8,3 +8,7 @@ function digest(data) {
     return hash.digest();
 }
 exports.digest = digest;
+function digestSignature(signature) {
+    return (0, crypto_1.createHash)('sha256').update(signature).digest('base64');
+}
+exports.digestSignature = digestSignature;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.98.0-beta.9",
+	"version": "2.99.0-beta.1",
 	"main": "lib/node/index.js",
 	"types": "lib/node/index.d.ts",
 	"browser": "./lib/browser/index.js",

package/src/accounts/pollingHighLeverageModeConfigAccountSubscriber.ts

@@ -0,0 +1,189 @@
+import {
+	DataAndSlot,
+	NotSubscribedError,
+	HighLeverageModeConfigAccountEvents,
+	HighLeverageModeConfigAccountSubscriber,
+} from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { HighLeverageModeConfig } from '../types';
+
+export class PollingHighLeverageModeConfigAccountSubscriber
+	implements HighLeverageModeConfigAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<
+		EventEmitter,
+		HighLeverageModeConfigAccountEvents
+	>;
+	highLeverageModeConfigAccountPublicKey: PublicKey;
+
+	accountLoader: BulkAccountLoader;
+	callbackId?: string;
+	errorCallbackId?: string;
+
+	highLeverageModeConfigAccountAndSlot?: DataAndSlot<HighLeverageModeConfig>;
+
+	public constructor(
+		program: Program,
+		publicKey: PublicKey,
+		accountLoader: BulkAccountLoader
+	) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.highLeverageModeConfigAccountPublicKey = publicKey;
+		this.accountLoader = accountLoader;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	async subscribe(
+		highLeverageModeConfig?: HighLeverageModeConfig
+	): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		if (highLeverageModeConfig) {
+			this.highLeverageModeConfigAccountAndSlot = {
+				data: highLeverageModeConfig,
+				slot: undefined,
+			};
+		}
+
+		await this.addToAccountLoader();
+
+		await this.fetchIfUnloaded();
+
+		if (this.doesAccountExist()) {
+			this.eventEmitter.emit('update');
+		}
+
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async addToAccountLoader(): Promise<void> {
+		if (this.callbackId) {
+			return;
+		}
+
+		this.callbackId = await this.accountLoader.addAccount(
+			this.highLeverageModeConfigAccountPublicKey,
+			(buffer, slot: number) => {
+				if (!buffer) {
+					return;
+				}
+
+				if (
+					this.highLeverageModeConfigAccountAndSlot &&
+					this.highLeverageModeConfigAccountAndSlot.slot > slot
+				) {
+					return;
+				}
+
+				const account = this.program.account.user.coder.accounts.decode(
+					'HighLeverageModeConfig',
+					buffer
+				);
+				this.highLeverageModeConfigAccountAndSlot = { data: account, slot };
+				this.eventEmitter.emit('highLeverageModeConfigAccountUpdate', account);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this.eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		if (this.highLeverageModeConfigAccountAndSlot === undefined) {
+			await this.fetch();
+		}
+	}
+
+	async fetch(): Promise<void> {
+		try {
+			const dataAndContext =
+				await this.program.account.highLeverageModeConfig.fetchAndContext(
+					this.highLeverageModeConfigAccountPublicKey,
+					this.accountLoader.commitment
+				);
+			if (
+				dataAndContext.context.slot >
+				(this.highLeverageModeConfigAccountAndSlot?.slot ?? 0)
+			) {
+				this.highLeverageModeConfigAccountAndSlot = {
+					data: dataAndContext.data as HighLeverageModeConfig,
+					slot: dataAndContext.context.slot,
+				};
+			}
+		} catch (e) {
+			console.log(
+				`PollingHighLeverageModeConfigAccountSubscriber.fetch() HighLeverageModeConfig does not exist: ${e.message}`
+			);
+		}
+	}
+
+	doesAccountExist(): boolean {
+		return this.highLeverageModeConfigAccountAndSlot !== undefined;
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		this.accountLoader.removeAccount(
+			this.highLeverageModeConfigAccountPublicKey,
+			this.callbackId
+		);
+		this.callbackId = undefined;
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+		this.errorCallbackId = undefined;
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getHighLeverageModeConfigAccountAndSlot(): DataAndSlot<HighLeverageModeConfig> {
+		this.assertIsSubscribed();
+		return this.highLeverageModeConfigAccountAndSlot;
+	}
+
+	didSubscriptionSucceed(): boolean {
+		return !!this.highLeverageModeConfigAccountAndSlot;
+	}
+
+	public updateData(
+		highLeverageModeConfig: HighLeverageModeConfig,
+		slot: number
+	): void {
+		if (
+			!this.highLeverageModeConfigAccountAndSlot ||
+			this.highLeverageModeConfigAccountAndSlot.slot < slot
+		) {
+			this.highLeverageModeConfigAccountAndSlot = {
+				data: highLeverageModeConfig,
+				slot,
+			};
+			this.eventEmitter.emit(
+				'highLeverageModeConfigAccountUpdate',
+				highLeverageModeConfig
+			);
+			this.eventEmitter.emit('update');
+		}
+	}
+}

package/src/accounts/types.ts

@@ -11,7 +11,7 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { Context, PublicKey } from '@solana/web3.js';
 import { Account } from '@solana/spl-token';
-import { OracleInfo, OraclePriceData } from '..';
+import { HighLeverageModeConfig, OracleInfo, OraclePriceData } from '..';
 import { ChannelOptions, CommitmentLevel } from '../isomorphic/grpc';
 
 export interface AccountSubscriber<T> {
@@ -215,3 +215,27 @@ export type GrpcConfigs = {
 	commitmentLevel?: CommitmentLevel;
 	channelOptions?: ChannelOptions;
 };
+
+export interface HighLeverageModeConfigAccountSubscriber {
+	eventEmitter: StrictEventEmitter<
+		EventEmitter,
+		HighLeverageModeConfigAccountEvents
+	>;
+	isSubscribed: boolean;
+
+	subscribe(
+		highLeverageModeConfigAccount?: HighLeverageModeConfig
+	): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getHighLeverageModeConfigAccountAndSlot(): DataAndSlot<HighLeverageModeConfig>;
+}
+
+export interface HighLeverageModeConfigAccountEvents {
+	highLeverageModeConfigAccountUpdate: (
+		payload: HighLeverageModeConfig
+	) => void;
+	update: void;
+	error: (e: Error) => void;
+}