@velocity-exchange/sdk 0.0.1

package/lib/browser/velocityClientConfig.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * VelocityClientConfig — configuration types for constructing a {@link VelocityClient}.
+ *
+ * Key options: RPC connection, wallet/keypair, account subscription mode
+ * (WebSocket vs polling), oracle client selection, transaction sender config,
+ * and feature flags (activeSubAccountId, authority override).
+ */
+import { Commitment, ConfirmOptions, Connection, PublicKey, TransactionVersion } from '@solana/web3.js';
+import { IWallet, TxParams, UserAccount } from './types';
+import { OracleInfo } from './oracles/types';
+import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { VelocityEnv } from './config';
+import { TxSender } from './tx/types';
+import { TxHandler, TxHandlerConfig } from './tx/txHandler';
+import { GrpcConfigs, ResubOpts, DelistedMarketSetting } from './accounts/types';
+import { Coder, Program } from './isomorphic/anchor';
+import { WebSocketAccountSubscriber } from './accounts/webSocketAccountSubscriber';
+import { WebSocketAccountSubscriberV2 } from './accounts/webSocketAccountSubscriberV2';
+import { grpcVelocityClientAccountSubscriberV2 } from './accounts/grpcVelocityClientAccountSubscriberV2';
+import { grpcVelocityClientAccountSubscriber } from './accounts/grpcVelocityClientAccountSubscriber';
+import { grpcMultiUserAccountSubscriber } from './accounts/grpcMultiUserAccountSubscriber';
+import { WebSocketProgramAccountSubscriber } from './accounts/webSocketProgramAccountSubscriber';
+import { WebSocketVelocityClientAccountSubscriber } from './accounts/webSocketVelocityClientAccountSubscriber';
+import { WebSocketVelocityClientAccountSubscriberV2 } from './accounts/webSocketVelocityClientAccountSubscriberV2';
+export type VelocityClientConfig = {
+    connection: Connection;
+    wallet: IWallet;
+    env?: VelocityEnv;
+    programID?: PublicKey;
+    accountSubscription?: VelocityClientSubscriptionConfig;
+    opts?: ConfirmOptions;
+    txSender?: TxSender;
+    txHandler?: TxHandler;
+    subAccountIds?: number[];
+    activeSubAccountId?: number;
+    perpMarketIndexes?: number[];
+    spotMarketIndexes?: number[];
+    /** @deprecated use marketLookupTables */
+    marketLookupTable?: PublicKey;
+    marketLookupTables?: PublicKey[];
+    oracleInfos?: OracleInfo[];
+    userStats?: boolean;
+    authority?: PublicKey;
+    includeDelegates?: boolean;
+    authoritySubAccountMap?: Map<string, number[]>;
+    skipLoadUsers?: boolean;
+    txVersion?: TransactionVersion;
+    txParams?: TxParams;
+    enableMetricsEvents?: boolean;
+    txHandlerConfig?: TxHandlerConfig;
+    delistedMarketSetting?: DelistedMarketSetting;
+    useHotWalletAdmin?: boolean;
+    coder?: Coder;
+};
+/** @deprecated Use `VelocityClientConfig` instead. `DriftClientConfig` will be removed in a future major. */
+export type DriftClientConfig = VelocityClientConfig;
+export type VelocityClientSubscriptionConfig = {
+    type: 'grpc';
+    grpcConfigs: GrpcConfigs;
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+    velocityClientAccountSubscriber?: new (grpcConfigs: GrpcConfigs, program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, delistedMarketSetting: DelistedMarketSetting) => grpcVelocityClientAccountSubscriberV2 | grpcVelocityClientAccountSubscriber;
+    /** @deprecated Use `velocityClientAccountSubscriber` instead. `driftClientAccountSubscriber` will be removed in a future major. */
+    driftClientAccountSubscriber?: new (grpcConfigs: GrpcConfigs, program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, delistedMarketSetting: DelistedMarketSetting) => grpcVelocityClientAccountSubscriberV2 | grpcVelocityClientAccountSubscriber;
+    grpcMultiUserAccountSubscriber?: grpcMultiUserAccountSubscriber;
+} | {
+    type: 'websocket';
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+    commitment?: Commitment;
+    programUserAccountSubscriber?: WebSocketProgramAccountSubscriber<UserAccount>;
+    perpMarketAccountSubscriber?: new (accountName: string, program: Program, accountPublicKey: PublicKey, decodeBuffer?: (buffer: Buffer) => any, resubOpts?: ResubOpts, commitment?: Commitment) => WebSocketAccountSubscriberV2<any> | WebSocketAccountSubscriber<any>;
+    /** If you use V2 here, whatever you pass for perpMarketAccountSubscriber will be ignored and it will use v2 under the hood regardless */
+    velocityClientAccountSubscriber?: new (program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, delistedMarketSetting: DelistedMarketSetting) => WebSocketVelocityClientAccountSubscriber | WebSocketVelocityClientAccountSubscriberV2;
+    /** @deprecated Use `velocityClientAccountSubscriber` instead. `driftClientAccountSubscriber` will be removed in a future major. */
+    driftClientAccountSubscriber?: new (program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, delistedMarketSetting: DelistedMarketSetting) => WebSocketVelocityClientAccountSubscriber | WebSocketVelocityClientAccountSubscriberV2;
+} | {
+    type: 'polling';
+    accountLoader: BulkAccountLoader;
+};
+/** @deprecated Use `VelocityClientSubscriptionConfig` instead. `DriftClientSubscriptionConfig` will be removed in a future major. */
+export type DriftClientSubscriptionConfig = VelocityClientSubscriptionConfig;

package/lib/browser/velocityClientConfig.js

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

package/lib/browser/wallet.d.ts

@@ -0,0 +1,16 @@
+import { Keypair, PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
+import { IWallet, IVersionedWallet } from './types';
+export declare class Wallet implements IWallet, IVersionedWallet {
+    readonly payer: Keypair;
+    constructor(payer: Keypair);
+    signTransaction(tx: Transaction): Promise<Transaction>;
+    signVersionedTransaction(tx: VersionedTransaction): Promise<VersionedTransaction>;
+    signAllTransactions(txs: Transaction[]): Promise<Transaction[]>;
+    signAllVersionedTransactions(txs: VersionedTransaction[]): Promise<VersionedTransaction[]>;
+    get publicKey(): PublicKey;
+}
+export declare class WalletV2 extends Wallet {
+    readonly payer: Keypair;
+    constructor(payer: Keypair);
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+}

package/lib/browser/wallet.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletV2 = exports.Wallet = void 0;
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+class Wallet {
+    constructor(payer) {
+        this.payer = payer;
+    }
+    async signTransaction(tx) {
+        tx.partialSign(this.payer);
+        return tx;
+    }
+    async signVersionedTransaction(tx) {
+        tx.sign([this.payer]);
+        return tx;
+    }
+    async signAllTransactions(txs) {
+        return txs.map((t) => {
+            t.partialSign(this.payer);
+            return t;
+        });
+    }
+    async signAllVersionedTransactions(txs) {
+        return txs.map((t) => {
+            t.sign([this.payer]);
+            return t;
+        });
+    }
+    get publicKey() {
+        return this.payer.publicKey;
+    }
+}
+exports.Wallet = Wallet;
+class WalletV2 extends Wallet {
+    constructor(payer) {
+        super(payer);
+        this.payer = payer;
+    }
+    async signMessage(message) {
+        return Buffer.from(tweetnacl_1.default.sign.detached(message, this.payer.secretKey));
+    }
+}
+exports.WalletV2 = WalletV2;

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

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { DataAndSlot, UserAccountEvents, UserAccountSubscriber } from './types';
+import { PublicKey } from '@solana/web3.js';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { UserAccount } from '../types';
+/**
+ * Basic implementation of UserAccountSubscriber. It will only take in UserAccount
+ * data during initialization and will not fetch or subscribe to updates.
+ */
+export declare class BasicUserAccountSubscriber implements UserAccountSubscriber {
+    isSubscribed: boolean;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+    userAccountPublicKey: PublicKey;
+    callbackId?: string;
+    errorCallbackId?: string;
+    user: DataAndSlot<UserAccount>;
+    constructor(userAccountPublicKey: PublicKey, data?: UserAccount, slot?: number);
+    subscribe(_userAccount?: UserAccount): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetch(): Promise<void>;
+    doesAccountExist(): boolean;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount>;
+    updateData(userAccount: UserAccount, slot: number): void;
+}
+//# sourceMappingURL=basicUserAccountSubscriber.d.ts.map

package/lib/node/accounts/basicUserAccountSubscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basicUserAccountSubscriber.d.ts","sourceRoot":"","sources":["../../../src/accounts/basicUserAccountSubscriber.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,kBAAkB,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC;;;GAGG;AACH,qBAAa,0BAA2B,YAAW,qBAAqB;IACvE,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,kBAAkB,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC;IAClE,oBAAoB,EAAE,SAAS,CAAC;IAEhC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,IAAI,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;gBAG9B,oBAAoB,EAAE,SAAS,EAC/B,IAAI,CAAC,EAAE,WAAW,EAClB,IAAI,CAAC,EAAE,MAAM;IAQR,SAAS,CAAC,YAAY,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAIvD,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAEnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAE5B,gBAAgB,IAAI,OAAO;IAIrB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAElC,kBAAkB,IAAI,IAAI;IAEnB,qBAAqB,IAAI,WAAW,CAAC,WAAW,CAAC;IAIjD,UAAU,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAO/D"}

package/lib/node/accounts/basicUserAccountSubscriber.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicUserAccountSubscriber = void 0;
+const events_1 = require("events");
+/**
+ * Basic implementation of UserAccountSubscriber. It will only take in UserAccount
+ * data during initialization and will not fetch or subscribe to updates.
+ */
+class BasicUserAccountSubscriber {
+    constructor(userAccountPublicKey, data, slot) {
+        this.isSubscribed = true;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.userAccountPublicKey = userAccountPublicKey;
+        this.user = { data, slot };
+    }
+    async subscribe(_userAccount) {
+        return true;
+    }
+    async addToAccountLoader() { }
+    async fetch() { }
+    doesAccountExist() {
+        return this.user !== undefined;
+    }
+    async unsubscribe() { }
+    assertIsSubscribed() { }
+    getUserAccountAndSlot() {
+        return this.user;
+    }
+    updateData(userAccount, slot) {
+        var _a;
+        if (!this.user || slot >= ((_a = this.user.slot) !== null && _a !== void 0 ? _a : 0)) {
+            this.user = { data: userAccount, slot };
+            this.eventEmitter.emit('userAccountUpdate', userAccount);
+            this.eventEmitter.emit('update');
+        }
+    }
+}
+exports.BasicUserAccountSubscriber = BasicUserAccountSubscriber;

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

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { DataAndSlot, UserStatsAccountEvents, UserStatsAccountSubscriber } from './types';
+import { PublicKey } from '@solana/web3.js';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { UserStatsAccount } from '../types';
+/**
+ * Basic implementation of UserStatsAccountSubscriber. It will only take in UserStatsAccount
+ * data during initialization and will not fetch or subscribe to updates.
+ */
+export declare class BasicUserStatsAccountSubscriber implements UserStatsAccountSubscriber {
+    isSubscribed: boolean;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+    userStatsAccountPublicKey: PublicKey;
+    callbackId?: string;
+    errorCallbackId?: string;
+    userStats: DataAndSlot<UserStatsAccount>;
+    constructor(userStatsAccountPublicKey: PublicKey, data?: UserStatsAccount, slot?: number);
+    subscribe(_userStatsAccount?: UserStatsAccount): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetch(): Promise<void>;
+    doesAccountExist(): boolean;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+    updateData(userStatsAccount: UserStatsAccount, slot: number): void;
+}
+//# sourceMappingURL=basicUserStatsAccountSubscriber.d.ts.map

package/lib/node/accounts/basicUserStatsAccountSubscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basicUserStatsAccountSubscriber.d.ts","sourceRoot":"","sources":["../../../src/accounts/basicUserStatsAccountSubscriber.ts"],"names":[],"mappings":";AAAA,OAAO,EACN,WAAW,EACX,sBAAsB,EACtB,0BAA0B,EAC1B,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,kBAAkB,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5C;;;GAGG;AACH,qBAAa,+BACZ,YAAW,0BAA0B;IAErC,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,kBAAkB,CAAC,YAAY,EAAE,sBAAsB,CAAC,CAAC;IACvE,yBAAyB,EAAE,SAAS,CAAC;IAErC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,SAAS,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;gBAGxC,yBAAyB,EAAE,SAAS,EACpC,IAAI,CAAC,EAAE,gBAAgB,EACvB,IAAI,CAAC,EAAE,MAAM;IAQR,SAAS,CAAC,iBAAiB,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIjE,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAEnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAE5B,gBAAgB,IAAI,OAAO;IAIrB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAElC,kBAAkB,IAAI,IAAI;IAEnB,0BAA0B,IAAI,WAAW,CAAC,gBAAgB,CAAC;IAI3D,UAAU,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAOzE"}

package/lib/node/accounts/basicUserStatsAccountSubscriber.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicUserStatsAccountSubscriber = void 0;
+const events_1 = require("events");
+/**
+ * Basic implementation of UserStatsAccountSubscriber. It will only take in UserStatsAccount
+ * data during initialization and will not fetch or subscribe to updates.
+ */
+class BasicUserStatsAccountSubscriber {
+    constructor(userStatsAccountPublicKey, data, slot) {
+        this.isSubscribed = true;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+        this.userStats = { data, slot };
+    }
+    async subscribe(_userStatsAccount) {
+        return true;
+    }
+    async addToAccountLoader() { }
+    async fetch() { }
+    doesAccountExist() {
+        return this.userStats !== undefined;
+    }
+    async unsubscribe() { }
+    assertIsSubscribed() { }
+    getUserStatsAccountAndSlot() {
+        return this.userStats;
+    }
+    updateData(userStatsAccount, slot) {
+        var _a;
+        if (!this.userStats || slot >= ((_a = this.userStats.slot) !== null && _a !== void 0 ? _a : 0)) {
+            this.userStats = { data: userStatsAccount, slot };
+            this.eventEmitter.emit('userStatsAccountUpdate', userStatsAccount);
+            this.eventEmitter.emit('update');
+        }
+    }
+}
+exports.BasicUserStatsAccountSubscriber = BasicUserStatsAccountSubscriber;

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

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { BufferAndSlot } from './types';
+import { Connection } from '../bankrun/bankrunConnection';
+export type AccountToLoad = {
+    publicKey: PublicKey;
+    callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
+};
+export declare class BulkAccountLoader {
+    connection: Connection;
+    commitment: Commitment;
+    pollingFrequency: number;
+    accountsToLoad: Map<string, AccountToLoad>;
+    bufferAndSlotMap: Map<string, BufferAndSlot>;
+    errorCallbacks: Map<string, (e: any) => void>;
+    intervalId?: ReturnType<typeof setTimeout>;
+    loadPromise?: Promise<void>;
+    loadPromiseResolver: () => void;
+    lastTimeLoadingPromiseCleared: number;
+    mostRecentSlot: number;
+    constructor(connection: Connection, commitment: Commitment, pollingFrequency: number);
+    addAccount(publicKey: PublicKey, callback: (buffer: Buffer, slot: number) => void): Promise<string>;
+    removeAccount(publicKey: PublicKey, callbackId: string): void;
+    addErrorCallbacks(callback: (error: Error) => void): string;
+    removeErrorCallbacks(callbackId: string): void;
+    chunks<T>(array: readonly T[], size: number): T[][];
+    load(): Promise<void>;
+    loadChunk(accountsToLoadChunks: AccountToLoad[][]): Promise<void>;
+    handleAccountCallbacks(accountToLoad: AccountToLoad, buffer: Buffer, slot: number): void;
+    getBufferAndSlot(publicKey: PublicKey): BufferAndSlot | undefined;
+    getSlot(): number;
+    startPolling(): void;
+    stopPolling(): void;
+    log(msg: string): void;
+    updatePollingFrequency(pollingFrequency: number): void;
+}
+//# sourceMappingURL=bulkAccountLoader.d.ts.map

package/lib/node/accounts/bulkAccountLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkAccountLoader.d.ts","sourceRoot":"","sources":["../../../src/accounts/bulkAccountLoader.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAExD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAG1D,MAAM,MAAM,aAAa,GAAG;IAC3B,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC,CAAC;CAC/D,CAAC;AAIF,qBAAa,iBAAiB;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,6BAAoC;IAClD,gBAAgB,6BAAoC;IACpD,cAAc,0BAA0B,IAAI,EAAI;IAChD,UAAU,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;IAE3C,WAAW,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,mBAAmB,EAAE,MAAM,IAAI,CAAC;IAChC,6BAA6B,SAAc;IAC3C,cAAc,SAAK;gBAGlB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,UAAU,EACtB,gBAAgB,EAAE,MAAM;IAOZ,UAAU,CACtB,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,GAC9C,OAAO,CAAC,MAAM,CAAC;IAkCX,aAAa,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAe7D,iBAAiB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM;IAM3D,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIrD,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE;IAOtC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAyC5B,SAAS,CAAC,oBAAoB,EAAE,aAAa,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAsFvE,sBAAsB,CACrB,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACV,IAAI;IAgBA,gBAAgB,CAAC,SAAS,EAAE,SAAS,GAAG,aAAa,GAAG,SAAS;IAIjE,OAAO,IAAI,MAAM;IAIjB,YAAY,IAAI,IAAI;IAYpB,WAAW,IAAI,IAAI;IAOnB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAItB,sBAAsB,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI;CAO7D"}

package/lib/node/accounts/bulkAccountLoader.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkAccountLoader = void 0;
+const uuid_1 = require("uuid");
+const promiseTimeout_1 = require("../util/promiseTimeout");
+const numericConstants_1 = require("../constants/numericConstants");
+const oneMinute = 60 * 1000;
+class BulkAccountLoader {
+    constructor(connection, commitment, pollingFrequency) {
+        this.accountsToLoad = new Map();
+        this.bufferAndSlotMap = new Map();
+        this.errorCallbacks = new Map();
+        this.lastTimeLoadingPromiseCleared = Date.now();
+        this.mostRecentSlot = 0;
+        this.connection = connection;
+        this.commitment = commitment;
+        this.pollingFrequency = pollingFrequency;
+    }
+    async addAccount(publicKey, callback) {
+        if (!publicKey) {
+            console.trace(`Caught adding blank publickey to bulkAccountLoader`);
+        }
+        const existingSize = this.accountsToLoad.size;
+        const callbackId = (0, uuid_1.v4)();
+        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+        if (existingAccountToLoad) {
+            existingAccountToLoad.callbacks.set(callbackId, callback);
+        }
+        else {
+            const callbacks = new Map();
+            callbacks.set(callbackId, callback);
+            const newAccountToLoad = {
+                publicKey,
+                callbacks,
+            };
+            this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
+        }
+        if (existingSize === 0) {
+            this.startPolling();
+        }
+        // resolve the current loadPromise in case client wants to call load
+        await this.loadPromise;
+        return callbackId;
+    }
+    removeAccount(publicKey, callbackId) {
+        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+        if (existingAccountToLoad) {
+            existingAccountToLoad.callbacks.delete(callbackId);
+            if (existingAccountToLoad.callbacks.size === 0) {
+                this.bufferAndSlotMap.delete(publicKey.toString());
+                this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
+            }
+        }
+        if (this.accountsToLoad.size === 0) {
+            this.stopPolling();
+        }
+    }
+    addErrorCallbacks(callback) {
+        const callbackId = (0, uuid_1.v4)();
+        this.errorCallbacks.set(callbackId, callback);
+        return callbackId;
+    }
+    removeErrorCallbacks(callbackId) {
+        this.errorCallbacks.delete(callbackId);
+    }
+    chunks(array, size) {
+        return new Array(Math.ceil(array.length / size))
+            .fill(null)
+            .map((_, index) => index * size)
+            .map((begin) => array.slice(begin, begin + size));
+    }
+    async load() {
+        if (this.loadPromise) {
+            const now = Date.now();
+            if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
+                this.loadPromise = undefined;
+            }
+            else {
+                return this.loadPromise;
+            }
+        }
+        this.loadPromise = new Promise((resolver) => {
+            this.loadPromiseResolver = resolver;
+        });
+        this.lastTimeLoadingPromiseCleared = Date.now();
+        try {
+            const chunks = this.chunks(this.chunks(Array.from(this.accountsToLoad.values()), numericConstants_1.GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE), 10);
+            await Promise.all(chunks.map((chunk) => {
+                return this.loadChunk(chunk);
+            }));
+        }
+        catch (e) {
+            console.error(`Error in bulkAccountLoader.load()`);
+            console.error(e);
+            for (const [_, callback] of this.errorCallbacks) {
+                callback(e);
+            }
+        }
+        finally {
+            this.loadPromiseResolver();
+            this.loadPromise = undefined;
+        }
+    }
+    async loadChunk(accountsToLoadChunks) {
+        if (accountsToLoadChunks.length === 0) {
+            return;
+        }
+        const requests = new Array();
+        for (const accountsToLoadChunk of accountsToLoadChunks) {
+            const args = [
+                accountsToLoadChunk
+                    .filter((accountToLoad) => accountToLoad.callbacks.size > 0)
+                    .map((accountToLoad) => {
+                    return accountToLoad.publicKey.toBase58();
+                }),
+                { commitment: this.commitment },
+            ];
+            requests.push({
+                methodName: 'getMultipleAccounts',
+                args,
+            });
+        }
+        const rpcResponses = await (0, promiseTimeout_1.promiseTimeout)(
+        // @ts-ignore
+        this.connection._rpcBatchRequest(requests), 10 * 1000 // 30 second timeout
+        );
+        if (rpcResponses === null) {
+            this.log('request to rpc timed out');
+            return;
+        }
+        rpcResponses.forEach((rpcResponse, i) => {
+            if (!rpcResponse.result) {
+                console.error('rpc response missing result:');
+                console.log(JSON.stringify(rpcResponse));
+                return;
+            }
+            const newSlot = rpcResponse.result.context.slot;
+            if (newSlot > this.mostRecentSlot) {
+                this.mostRecentSlot = newSlot;
+            }
+            const accountsToLoad = accountsToLoadChunks[i];
+            accountsToLoad.forEach((accountToLoad, j) => {
+                if (accountToLoad.callbacks.size === 0) {
+                    return;
+                }
+                const key = accountToLoad.publicKey.toBase58();
+                const oldRPCResponse = this.bufferAndSlotMap.get(key);
+                if (oldRPCResponse && newSlot < oldRPCResponse.slot) {
+                    return;
+                }
+                let newBuffer = undefined;
+                if (rpcResponse.result.value[j]) {
+                    const raw = rpcResponse.result.value[j].data[0];
+                    const dataType = rpcResponse.result.value[j].data[1];
+                    newBuffer = Buffer.from(raw, dataType);
+                }
+                if (!oldRPCResponse) {
+                    this.bufferAndSlotMap.set(key, {
+                        slot: newSlot,
+                        buffer: newBuffer,
+                    });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                    return;
+                }
+                const oldBuffer = oldRPCResponse.buffer;
+                if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+                    this.bufferAndSlotMap.set(key, {
+                        slot: newSlot,
+                        buffer: newBuffer,
+                    });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                }
+            });
+        });
+    }
+    handleAccountCallbacks(accountToLoad, buffer, slot) {
+        for (const [_, callback] of accountToLoad.callbacks) {
+            try {
+                callback(buffer, slot);
+            }
+            catch (e) {
+                console.log('Bulk account load: error in account callback');
+                console.log('accounto to load', accountToLoad.publicKey.toString());
+                console.log('buffer', buffer.toString('base64'));
+                for (const callback of accountToLoad.callbacks.values()) {
+                    console.log('account to load cb', callback);
+                }
+                throw e;
+            }
+        }
+    }
+    getBufferAndSlot(publicKey) {
+        return this.bufferAndSlotMap.get(publicKey.toString());
+    }
+    getSlot() {
+        return this.mostRecentSlot;
+    }
+    startPolling() {
+        if (this.intervalId) {
+            return;
+        }
+        if (this.pollingFrequency !== 0)
+            this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
+    }
+    stopPolling() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+    log(msg) {
+        console.log(msg);
+    }
+    updatePollingFrequency(pollingFrequency) {
+        this.stopPolling();
+        this.pollingFrequency = pollingFrequency;
+        if (this.accountsToLoad.size > 0) {
+            this.startPolling();
+        }
+    }
+}
+exports.BulkAccountLoader = BulkAccountLoader;

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

@@ -0,0 +1,8 @@
+import { UserStats } from '../userStats';
+import { BulkAccountLoader } from './bulkAccountLoader';
+/**
+ * @param userStats
+ * @param accountLoader
+ */
+export declare function bulkPollingUserStatsSubscribe(userStats: UserStats[], accountLoader: BulkAccountLoader): Promise<void>;
+//# sourceMappingURL=bulkUserStatsSubscription.d.ts.map

package/lib/node/accounts/bulkUserStatsSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkUserStatsSubscription.d.ts","sourceRoot":"","sources":["../../../src/accounts/bulkUserStatsSubscription.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGxD;;;GAGG;AACH,wBAAsB,6BAA6B,CAClD,SAAS,EAAE,SAAS,EAAE,EACtB,aAAa,EAAE,iBAAiB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/lib/node/accounts/bulkUserStatsSubscription.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkPollingUserStatsSubscribe = void 0;
+/**
+ * @param userStats
+ * @param accountLoader
+ */
+async function bulkPollingUserStatsSubscribe(userStats, accountLoader) {
+    if (userStats.length === 0) {
+        await accountLoader.load();
+        return;
+    }
+    await Promise.all(userStats.map((userStat) => {
+        return userStat.accountSubscriber.addToAccountLoader();
+    }));
+    await accountLoader.load();
+    await Promise.all(userStats.map(async (userStat) => {
+        return userStat.subscribe();
+    }));
+}
+exports.bulkPollingUserStatsSubscribe = bulkPollingUserStatsSubscribe;

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

@@ -0,0 +1,8 @@
+import { User } from '../user';
+import { BulkAccountLoader } from './bulkAccountLoader';
+/**
+ * @param users
+ * @param accountLoader
+ */
+export declare function bulkPollingUserSubscribe(users: User[], accountLoader: BulkAccountLoader): Promise<void>;
+//# sourceMappingURL=bulkUserSubscription.d.ts.map

package/lib/node/accounts/bulkUserSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkUserSubscription.d.ts","sourceRoot":"","sources":["../../../src/accounts/bulkUserSubscription.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGxD;;;GAGG;AACH,wBAAsB,wBAAwB,CAC7C,KAAK,EAAE,IAAI,EAAE,EACb,aAAa,EAAE,iBAAiB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/lib/node/accounts/bulkUserSubscription.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkPollingUserSubscribe = void 0;
+/**
+ * @param users
+ * @param accountLoader
+ */
+async function bulkPollingUserSubscribe(users, accountLoader) {
+    if (users.length === 0) {
+        await accountLoader.load();
+        return;
+    }
+    await Promise.all(users.map((user) => {
+        return user.accountSubscriber.addToAccountLoader();
+    }));
+    await accountLoader.load();
+    await Promise.all(users.map(async (user) => {
+        return user.subscribe();
+    }));
+}
+exports.bulkPollingUserSubscribe = bulkPollingUserSubscribe;