@drift-labs/sdk 2.97.0-beta.9 → 2.98.0-beta.0

package/lib/node/userConfig.d.ts

@@ -0,0 +1,26 @@
+import { DriftClient } from './driftClient';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { GrpcConfigs, UserAccountSubscriber } from './accounts/types';
+export type UserConfig = {
+    accountSubscription?: UserSubscriptionConfig;
+    driftClient: DriftClient;
+    userAccountPublicKey: PublicKey;
+};
+export type UserSubscriptionConfig = {
+    type: 'grpc';
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+    grpcConfigs: GrpcConfigs;
+} | {
+    type: 'websocket';
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+    commitment?: Commitment;
+} | {
+    type: 'polling';
+    accountLoader: BulkAccountLoader;
+} | {
+    type: 'custom';
+    userAccountSubscriber: UserAccountSubscriber;
+};

package/lib/node/userConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { UserMap } from './userMap';
+export declare class PollingSubscription {
+    private userMap;
+    private frequency;
+    private skipInitialLoad;
+    intervalId?: NodeJS.Timeout;
+    constructor({ userMap, frequency, skipInitialLoad, }: {
+        userMap: UserMap;
+        frequency: number;
+        skipInitialLoad?: boolean;
+        includeIdle?: boolean;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/userMap/PollingSubscription.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingSubscription = void 0;
+class PollingSubscription {
+    constructor({ userMap, frequency, skipInitialLoad = false, }) {
+        this.userMap = userMap;
+        this.frequency = frequency;
+        this.skipInitialLoad = skipInitialLoad;
+    }
+    async subscribe() {
+        if (this.intervalId || this.frequency <= 0) {
+            return;
+        }
+        const executeSync = async () => {
+            await this.userMap.sync();
+            this.intervalId = setTimeout(executeSync, this.frequency);
+        };
+        if (!this.skipInitialLoad) {
+            await this.userMap.sync();
+        }
+        executeSync();
+    }
+    async unsubscribe() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+}
+exports.PollingSubscription = PollingSubscription;

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

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { UserMap } from './userMap';
+import { UserAccount } from '../types';
+import { Commitment } from '@solana/web3.js';
+import { ResubOpts } from '../accounts/types';
+export declare class WebsocketSubscription {
+    private userMap;
+    private commitment;
+    private skipInitialLoad;
+    private resubOpts?;
+    private includeIdle?;
+    private decodeFn;
+    private subscriber;
+    constructor({ userMap, commitment, skipInitialLoad, resubOpts, includeIdle, decodeFn, }: {
+        userMap: UserMap;
+        commitment: Commitment;
+        skipInitialLoad?: boolean;
+        resubOpts?: ResubOpts;
+        includeIdle?: boolean;
+        decodeFn: (name: string, data: Buffer) => UserAccount;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/userMap/WebsocketSubscription.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketSubscription = void 0;
+const memcmp_1 = require("../memcmp");
+const webSocketProgramAccountSubscriber_1 = require("../accounts/webSocketProgramAccountSubscriber");
+class WebsocketSubscription {
+    constructor({ userMap, commitment, skipInitialLoad = false, resubOpts, includeIdle = false, decodeFn, }) {
+        this.userMap = userMap;
+        this.commitment = commitment;
+        this.skipInitialLoad = skipInitialLoad;
+        this.resubOpts = resubOpts;
+        this.includeIdle = includeIdle || false;
+        this.decodeFn = decodeFn;
+    }
+    async subscribe() {
+        if (!this.subscriber) {
+            const filters = [(0, memcmp_1.getUserFilter)()];
+            if (!this.includeIdle) {
+                filters.push((0, memcmp_1.getNonIdleUserFilter)());
+            }
+            this.subscriber = new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('UserMap', 'User', this.userMap.driftClient.program, this.decodeFn, {
+                filters,
+                commitment: this.commitment,
+            }, this.resubOpts);
+        }
+        await this.subscriber.subscribe((accountId, account, context) => {
+            const userKey = accountId.toBase58();
+            this.userMap.updateUserAccount(userKey, account, context.slot);
+        });
+        if (!this.skipInitialLoad) {
+            await this.userMap.sync();
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscriber)
+            return;
+        await this.subscriber.unsubscribe();
+        this.subscriber = undefined;
+    }
+}
+exports.WebsocketSubscription = WebsocketSubscription;

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

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { UserMap } from './userMap';
+import { UserAccount } from '../types';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+export declare class grpcSubscription {
+    private grpcConfigs;
+    private userMap;
+    private skipInitialLoad;
+    private resubOpts?;
+    private includeIdle?;
+    private decodeFn;
+    private subscriber;
+    constructor({ grpcConfigs, userMap, skipInitialLoad, resubOpts, includeIdle, decodeFn, }: {
+        grpcConfigs: GrpcConfigs;
+        userMap: UserMap;
+        skipInitialLoad?: boolean;
+        resubOpts?: ResubOpts;
+        includeIdle?: boolean;
+        decodeFn: (name: string, data: Buffer) => UserAccount;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/userMap/grpcSubscription.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcSubscription = void 0;
+const memcmp_1 = require("../memcmp");
+const grpcProgramAccountSubscriber_1 = require("../accounts/grpcProgramAccountSubscriber");
+class grpcSubscription {
+    constructor({ grpcConfigs, userMap, skipInitialLoad = false, resubOpts, includeIdle = false, decodeFn, }) {
+        this.userMap = userMap;
+        this.skipInitialLoad = skipInitialLoad;
+        this.resubOpts = resubOpts;
+        this.includeIdle = includeIdle || false;
+        this.decodeFn = decodeFn;
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe() {
+        if (!this.subscriber) {
+            const filters = [(0, memcmp_1.getUserFilter)()];
+            if (!this.includeIdle) {
+                filters.push((0, memcmp_1.getNonIdleUserFilter)());
+            }
+            this.subscriber = new grpcProgramAccountSubscriber_1.grpcProgramAccountSubscriber(this.grpcConfigs, 'UserMap', 'User', this.userMap.driftClient.program, this.decodeFn, {
+                filters,
+            }, this.resubOpts);
+        }
+        await this.subscriber.subscribe((accountId, account, context) => {
+            const userKey = accountId.toBase58();
+            this.userMap.updateUserAccount(userKey, account, context.slot);
+        });
+        if (!this.skipInitialLoad) {
+            await this.userMap.sync();
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscriber)
+            return;
+        await this.subscriber.unsubscribe();
+        this.subscriber = undefined;
+    }
+}
+exports.grpcSubscription = grpcSubscription;

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

@@ -0,0 +1,88 @@
+import { User, DriftClient, UserAccount, OrderRecord, WrappedEvent, DLOB, UserSubscriptionConfig, DataAndSlot } from '..';
+import { PublicKey } from '@solana/web3.js';
+import { UserAccountFilterCriteria as UserFilterCriteria, UserMapConfig } from './userMapConfig';
+export interface UserMapInterface {
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    addPubkey(userAccountPublicKey: PublicKey, userAccount?: UserAccount, slot?: number, accountSubscription?: UserSubscriptionConfig): Promise<void>;
+    has(key: string): boolean;
+    get(key: string): User | undefined;
+    getWithSlot(key: string): DataAndSlot<User> | undefined;
+    mustGet(key: string, accountSubscription?: UserSubscriptionConfig): Promise<User>;
+    mustGetWithSlot(key: string, accountSubscription?: UserSubscriptionConfig): Promise<DataAndSlot<User>>;
+    getUserAuthority(key: string): PublicKey | undefined;
+    updateWithOrderRecord(record: OrderRecord): Promise<void>;
+    values(): IterableIterator<User>;
+    valuesWithSlot(): IterableIterator<DataAndSlot<User>>;
+    entries(): IterableIterator<[string, User]>;
+    entriesWithSlot(): IterableIterator<[string, DataAndSlot<User>]>;
+}
+export declare class UserMap implements UserMapInterface {
+    private userMap;
+    driftClient: DriftClient;
+    private connection;
+    private commitment;
+    private includeIdle;
+    private disableSyncOnTotalAccountsChange;
+    private lastNumberOfSubAccounts;
+    private subscription;
+    private stateAccountUpdateCallback;
+    private decode;
+    private mostRecentSlot;
+    private syncConfig;
+    private syncPromise?;
+    private syncPromiseResolver;
+    /**
+     * Constructs a new UserMap instance.
+     */
+    constructor(config: UserMapConfig);
+    subscribe(): Promise<void>;
+    addPubkey(userAccountPublicKey: PublicKey, userAccount?: UserAccount, slot?: number, accountSubscription?: UserSubscriptionConfig): Promise<void>;
+    has(key: string): boolean;
+    /**
+     * gets the User for a particular userAccountPublicKey, if no User exists, undefined is returned
+     * @param key userAccountPublicKey to get User for
+     * @returns user User | undefined
+     */
+    get(key: string): User | undefined;
+    getWithSlot(key: string): DataAndSlot<User> | undefined;
+    /**
+     * gets the User for a particular userAccountPublicKey, if no User exists, new one is created
+     * @param key userAccountPublicKey to get User for
+     * @returns  User
+     */
+    mustGet(key: string, accountSubscription?: UserSubscriptionConfig): Promise<User>;
+    mustGetWithSlot(key: string, accountSubscription?: UserSubscriptionConfig): Promise<DataAndSlot<User>>;
+    /**
+     * gets the Authority for a particular userAccountPublicKey, if no User exists, undefined is returned
+     * @param key userAccountPublicKey to get User for
+     * @returns authority PublicKey | undefined
+     */
+    getUserAuthority(key: string): PublicKey | undefined;
+    /**
+     * implements the {@link DLOBSource} interface
+     * create a DLOB from all the subscribed users
+     * @param slot
+     */
+    getDLOB(slot: number): Promise<DLOB>;
+    updateWithOrderRecord(record: OrderRecord): Promise<void>;
+    updateWithEventRecord(record: WrappedEvent<any>): Promise<void>;
+    values(): IterableIterator<User>;
+    valuesWithSlot(): IterableIterator<DataAndSlot<User>>;
+    entries(): IterableIterator<[string, User]>;
+    entriesWithSlot(): IterableIterator<[string, DataAndSlot<User>]>;
+    size(): number;
+    /**
+     * Returns a unique list of authorities for all users in the UserMap that meet the filter criteria
+     * @param filterCriteria: Users must meet these criteria to be included
+     * @returns
+     */
+    getUniqueAuthorities(filterCriteria?: UserFilterCriteria): PublicKey[];
+    sync(): Promise<void>;
+    private defaultSync;
+    private paginatedSync;
+    unsubscribe(): Promise<void>;
+    updateUserAccount(key: string, userAccount: UserAccount, slot: number): Promise<void>;
+    updateLatestSlot(slot: number): void;
+    getSlot(): number;
+}