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

package/lib/node/accounts/grpcProgramAccountSubscriber.js

@@ -0,0 +1,171 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcProgramAccountSubscriber = void 0;
+const bs58_1 = __importDefault(require("bs58"));
+const web3_js_1 = require("@solana/web3.js");
+const Buffer = __importStar(require("buffer"));
+const webSocketProgramAccountSubscriber_1 = require("./webSocketProgramAccountSubscriber");
+const grpc_1 = require("../isomorphic/grpc");
+class grpcProgramAccountSubscriber extends webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber {
+    constructor(grpcConfigs, subscriptionName, accountDiscriminator, program, decodeBufferFn, options = {
+        filters: [],
+    }, resubOpts) {
+        var _a, _b;
+        super(subscriptionName, accountDiscriminator, program, decodeBufferFn, options, resubOpts);
+        this.client = (0, grpc_1.createClient)(grpcConfigs.endpoint, grpcConfigs.token, (_a = grpcConfigs.channelOptions) !== null && _a !== void 0 ? _a : {});
+        this.commitmentLevel =
+            // @ts-ignore :: isomorphic exported enum fails typescript but will work at runtime
+            (_b = grpcConfigs.commitmentLevel) !== null && _b !== void 0 ? _b : grpc_1.CommitmentLevel.CONFIRMED;
+    }
+    async subscribe(onChange) {
+        if (this.listenerId != null || this.isUnsubscribing) {
+            return;
+        }
+        this.onChange = onChange;
+        // Subscribe with grpc
+        this.stream = await this.client.subscribe();
+        const filters = this.options.filters.map((filter) => {
+            return {
+                memcmp: {
+                    offset: filter.memcmp.offset.toString(),
+                    bytes: bs58_1.default.decode(filter.memcmp.bytes),
+                },
+            };
+        });
+        const request = {
+            slots: {},
+            accounts: {
+                drift: {
+                    account: [],
+                    owner: [this.program.programId.toBase58()],
+                    filters,
+                },
+            },
+            transactions: {},
+            blocks: {},
+            blocksMeta: {},
+            accountsDataSlice: [],
+            commitment: this.commitmentLevel,
+            entry: {},
+            transactionsStatus: {},
+        };
+        this.stream.on('data', (chunk) => {
+            var _a;
+            if (!chunk.account) {
+                return;
+            }
+            const slot = Number(chunk.account.slot);
+            const accountInfo = {
+                owner: new web3_js_1.PublicKey(chunk.account.account.owner),
+                lamports: Number(chunk.account.account.lamports),
+                data: Buffer.Buffer.from(chunk.account.account.data),
+                executable: chunk.account.account.executable,
+                rentEpoch: Number(chunk.account.account.rentEpoch),
+            };
+            if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                this.receivingData = true;
+                clearTimeout(this.timeoutId);
+                this.handleRpcResponse({
+                    slot,
+                }, {
+                    accountId: new web3_js_1.PublicKey(chunk.account.account.pubkey),
+                    accountInfo,
+                });
+                this.setTimeout();
+            }
+            else {
+                this.handleRpcResponse({
+                    slot,
+                }, {
+                    accountId: new web3_js_1.PublicKey(chunk.account.account.pubkey),
+                    accountInfo,
+                });
+            }
+        });
+        return new Promise((resolve, reject) => {
+            this.stream.write(request, (err) => {
+                var _a;
+                if (err === null || err === undefined) {
+                    this.listenerId = 1;
+                    if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                        this.receivingData = true;
+                        this.setTimeout();
+                    }
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        }).catch((reason) => {
+            console.error(reason);
+            throw reason;
+        });
+    }
+    async unsubscribe(onResub = false) {
+        if (!onResub && this.resubOpts) {
+            this.resubOpts.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.listenerId != null) {
+            const promise = new Promise((resolve, reject) => {
+                const request = {
+                    slots: {},
+                    accounts: {},
+                    transactions: {},
+                    blocks: {},
+                    blocksMeta: {},
+                    accountsDataSlice: [],
+                    entry: {},
+                    transactionsStatus: {},
+                };
+                this.stream.write(request, (err) => {
+                    if (err === null || err === undefined) {
+                        this.listenerId = undefined;
+                        this.isUnsubscribing = false;
+                        resolve();
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            }).catch((reason) => {
+                console.error(reason);
+                throw reason;
+            });
+            return promise;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.grpcProgramAccountSubscriber = grpcProgramAccountSubscriber;

package/lib/node/accounts/grpcUserAccountSubscriber.d.ts

@@ -0,0 +1,10 @@
+import { ResubOpts, GrpcConfigs } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { UserAccount } from '../types';
+import { WebSocketUserAccountSubscriber } from './webSocketUserAccountSubscriber';
+export declare class grpcUserAccountSubscriber extends WebSocketUserAccountSubscriber {
+    private grpcConfigs;
+    constructor(grpcConfigs: GrpcConfigs, program: Program, userAccountPublicKey: PublicKey, resubOpts?: ResubOpts);
+    subscribe(userAccount?: UserAccount): Promise<boolean>;
+}

package/lib/node/accounts/grpcUserAccountSubscriber.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcUserAccountSubscriber = void 0;
+const webSocketUserAccountSubscriber_1 = require("./webSocketUserAccountSubscriber");
+const grpcAccountSubscriber_1 = require("./grpcAccountSubscriber");
+class grpcUserAccountSubscriber extends webSocketUserAccountSubscriber_1.WebSocketUserAccountSubscriber {
+    constructor(grpcConfigs, program, userAccountPublicKey, resubOpts) {
+        super(program, userAccountPublicKey, resubOpts);
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe(userAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.userDataAccountSubscriber = new grpcAccountSubscriber_1.grpcAccountSubscriber(this.grpcConfigs, 'user', this.program, this.userAccountPublicKey, undefined, this.resubOpts);
+        if (userAccount) {
+            this.userDataAccountSubscriber.setData(userAccount);
+        }
+        await this.userDataAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('userAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+}
+exports.grpcUserAccountSubscriber = grpcUserAccountSubscriber;

package/lib/node/accounts/grpcUserStatsAccountSubscriber.d.ts

@@ -0,0 +1,10 @@
+import { ResubOpts, GrpcConfigs } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { UserStatsAccount } from '../types';
+import { WebSocketUserStatsAccountSubscriber } from './webSocketUserStatsAccountSubsriber';
+export declare class grpcUserStatsAccountSubscriber extends WebSocketUserStatsAccountSubscriber {
+    private grpcConfigs;
+    constructor(grpcConfigs: GrpcConfigs, program: Program, userStatsAccountPublicKey: PublicKey, resubOpts?: ResubOpts);
+    subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean>;
+}

package/lib/node/accounts/grpcUserStatsAccountSubscriber.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcUserStatsAccountSubscriber = void 0;
+const webSocketUserStatsAccountSubsriber_1 = require("./webSocketUserStatsAccountSubsriber");
+const grpcAccountSubscriber_1 = require("./grpcAccountSubscriber");
+class grpcUserStatsAccountSubscriber extends webSocketUserStatsAccountSubsriber_1.WebSocketUserStatsAccountSubscriber {
+    constructor(grpcConfigs, program, userStatsAccountPublicKey, resubOpts) {
+        super(program, userStatsAccountPublicKey, resubOpts);
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe(userStatsAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.userStatsAccountSubscriber = new grpcAccountSubscriber_1.grpcAccountSubscriber(this.grpcConfigs, 'userStats', this.program, this.userStatsAccountPublicKey, undefined, this.resubOpts);
+        if (userStatsAccount) {
+            this.userStatsAccountSubscriber.setData(userStatsAccount);
+        }
+        await this.userStatsAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('userStatsAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+}
+exports.grpcUserStatsAccountSubscriber = grpcUserStatsAccountSubscriber;

package/lib/node/accounts/oneShotUserAccountSubscriber.d.ts

@@ -0,0 +1,18 @@
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { UserAccount } from '../types';
+import { BasicUserAccountSubscriber } from './basicUserAccountSubscriber';
+import { Program } from '@coral-xyz/anchor';
+import { UserAccountSubscriber } from './types';
+/**
+ * Simple implementation of UserAccountSubscriber. It will fetch the UserAccount
+ * date on subscribe (or call to fetch) if no account data is provided on init.
+ * Expect to use only 1 RPC call unless you call fetch repeatedly.
+ */
+export declare class OneShotUserAccountSubscriber extends BasicUserAccountSubscriber implements UserAccountSubscriber {
+    program: Program;
+    commitment: Commitment;
+    constructor(program: Program, userAccountPublicKey: PublicKey, data?: UserAccount, slot?: number, commitment?: Commitment);
+    subscribe(userAccount?: UserAccount): Promise<boolean>;
+    fetchIfUnloaded(): Promise<void>;
+    fetch(): Promise<void>;
+}

package/lib/node/accounts/oneShotUserAccountSubscriber.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneShotUserAccountSubscriber = void 0;
+const basicUserAccountSubscriber_1 = require("./basicUserAccountSubscriber");
+/**
+ * Simple implementation of UserAccountSubscriber. It will fetch the UserAccount
+ * date on subscribe (or call to fetch) if no account data is provided on init.
+ * Expect to use only 1 RPC call unless you call fetch repeatedly.
+ */
+class OneShotUserAccountSubscriber extends basicUserAccountSubscriber_1.BasicUserAccountSubscriber {
+    constructor(program, userAccountPublicKey, data, slot, commitment) {
+        super(userAccountPublicKey, data, slot);
+        this.program = program;
+        this.commitment = commitment !== null && commitment !== void 0 ? commitment : 'confirmed';
+    }
+    async subscribe(userAccount) {
+        if (userAccount) {
+            this.user = { data: userAccount, slot: this.user.slot };
+            return true;
+        }
+        await this.fetchIfUnloaded();
+        if (this.doesAccountExist()) {
+            this.eventEmitter.emit('update');
+        }
+        return true;
+    }
+    async fetchIfUnloaded() {
+        if (this.user.data === undefined) {
+            await this.fetch();
+        }
+    }
+    async fetch() {
+        var _a, _b;
+        try {
+            const dataAndContext = await this.program.account.user.fetchAndContext(this.userAccountPublicKey, this.commitment);
+            if (dataAndContext.context.slot > ((_b = (_a = this.user) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : 0)) {
+                this.user = {
+                    data: dataAndContext.data,
+                    slot: dataAndContext.context.slot,
+                };
+            }
+        }
+        catch (e) {
+            console.error(`OneShotUserAccountSubscriber.fetch() UserAccount does not exist: ${e.message}`);
+        }
+    }
+}
+exports.OneShotUserAccountSubscriber = OneShotUserAccountSubscriber;

package/lib/node/accounts/pollingDriftClientAccountSubscriber.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+import { AccountToPoll, DataAndSlot, DelistedMarketSetting, DriftClientAccountEvents, DriftClientAccountSubscriber, OraclesToPoll } from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PerpMarketAccount, SpotMarketAccount, StateAccount, UserAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { PublicKey } from '@solana/web3.js';
+import { OracleInfo, OraclePriceData } from '../oracles/types';
+import { OracleClientCache } from '../oracles/oracleClientCache';
+export declare class PollingDriftClientAccountSubscriber implements DriftClientAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    perpMarketIndexes: number[];
+    spotMarketIndexes: number[];
+    oracleInfos: OracleInfo[];
+    oracleClientCache: OracleClientCache;
+    shouldFindAllMarketsAndOracles: boolean;
+    eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
+    accountLoader: BulkAccountLoader;
+    accountsToPoll: Map<string, AccountToPoll>;
+    oraclesToPoll: Map<string, OraclesToPoll>;
+    errorCallbackId?: string;
+    state?: DataAndSlot<StateAccount>;
+    perpMarket: Map<number, DataAndSlot<PerpMarketAccount>>;
+    perpOracleMap: Map<number, PublicKey>;
+    perpOracleStringMap: Map<number, string>;
+    spotMarket: Map<number, DataAndSlot<SpotMarketAccount>>;
+    spotOracleMap: Map<number, PublicKey>;
+    spotOracleStringMap: Map<number, string>;
+    oracles: Map<string, DataAndSlot<OraclePriceData>>;
+    user?: DataAndSlot<UserAccount>;
+    delistedMarketSetting: DelistedMarketSetting;
+    private isSubscribing;
+    private subscriptionPromise;
+    private subscriptionPromiseResolver;
+    constructor(program: Program, accountLoader: BulkAccountLoader, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, delistedMarketSetting: DelistedMarketSetting);
+    subscribe(): Promise<boolean>;
+    updateAccountsToPoll(): Promise<void>;
+    updatePerpMarketAccountsToPoll(): Promise<boolean>;
+    addPerpMarketAccountToPoll(marketIndex: number): Promise<boolean>;
+    updateSpotMarketAccountsToPoll(): Promise<boolean>;
+    addSpotMarketAccountToPoll(marketIndex: number): Promise<boolean>;
+    updateOraclesToPoll(): boolean;
+    addOracleToPoll(oracleInfo: OracleInfo): boolean;
+    addToAccountLoader(): Promise<void>;
+    addAccountToAccountLoader(accountToPoll: AccountToPoll): Promise<void>;
+    addOracleToAccountLoader(oracleToPoll: OraclesToPoll): Promise<void>;
+    fetch(): Promise<void>;
+    didSubscriptionSucceed(): boolean;
+    unsubscribe(): Promise<void>;
+    addSpotMarket(marketIndex: number): Promise<boolean>;
+    addPerpMarket(marketIndex: number): Promise<boolean>;
+    addOracle(oracleInfo: OracleInfo): Promise<boolean>;
+    private pauseForOracleToBeAdded;
+    setPerpOracleMap(): Promise<void>;
+    setSpotOracleMap(): Promise<void>;
+    handleDelistedMarkets(): void;
+    assertIsSubscribed(): void;
+    getStateAccountAndSlot(): DataAndSlot<StateAccount>;
+    getMarketAccountAndSlot(marketIndex: number): DataAndSlot<PerpMarketAccount> | undefined;
+    getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
+    getSpotMarketAccountAndSlot(marketIndex: number): DataAndSlot<SpotMarketAccount> | undefined;
+    getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[];
+    getOraclePriceDataAndSlot(oraclePublicKey: PublicKey | string): DataAndSlot<OraclePriceData> | undefined;
+    getOraclePriceDataAndSlotForPerpMarket(marketIndex: number): DataAndSlot<OraclePriceData> | undefined;
+    getOraclePriceDataAndSlotForSpotMarket(marketIndex: number): DataAndSlot<OraclePriceData> | undefined;
+    updateAccountLoaderPollingFrequency(pollingFrequency: number): void;
+}