@drift-labs/sdk-browser 2.104.0-beta.21

package/lib/browser/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/lib/browser/util/pythOracleUtils.d.ts

@@ -0,0 +1,17 @@
+import { TransactionInstruction } from '@solana/web3.js';
+export declare function trimFeedId(feedId: string): string;
+export declare function getFeedIdUint8Array(feedId: string): Uint8Array;
+export declare function getEd25519ArgsFromHex(hex: string): {
+    publicKey: Uint8Array;
+    signature: Uint8Array;
+    message: Uint8Array;
+};
+/**
+ * Constructs a minimal Ed25519 verification instruction that references the data
+ * inside the main instruction (postPythLazerOracleUpdate).
+ *
+ * @param customInstructionIndex The index of the custom instruction in the transaction (typically 1 if this is second).
+ * @param messageOffset The offset within the custom instruction data where the pythMessage begins.
+ * @param customInstructionData The entire instruction data array for the custom instruction.
+ */
+export declare function createMinimalEd25519VerifyIx(customInstructionIndex: number, messageOffset: number, customInstructionData: Uint8Array): TransactionInstruction;

package/lib/browser/util/pythOracleUtils.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMinimalEd25519VerifyIx = exports.getEd25519ArgsFromHex = exports.getFeedIdUint8Array = exports.trimFeedId = void 0;
+const web3_js_1 = require("@solana/web3.js");
+function trimFeedId(feedId) {
+    if (feedId.startsWith('0x')) {
+        return feedId.slice(2);
+    }
+    return feedId;
+}
+exports.trimFeedId = trimFeedId;
+function getFeedIdUint8Array(feedId) {
+    const trimmedFeedId = trimFeedId(feedId);
+    return Uint8Array.from(Buffer.from(trimmedFeedId, 'hex'));
+}
+exports.getFeedIdUint8Array = getFeedIdUint8Array;
+const SIGNATURE_LEN = 64;
+const PUBKEY_LEN = 32;
+const MAGIC_LEN = 4;
+const MESSAGE_SIZE_LEN = 2;
+function getEd25519ArgsFromHex(hex) {
+    const cleanedHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+    const buffer = new Uint8Array(Buffer.from(cleanedHex, 'hex'));
+    const signatureOffset = MAGIC_LEN;
+    const publicKeyOffset = signatureOffset + SIGNATURE_LEN;
+    const messageDataSizeOffset = publicKeyOffset + PUBKEY_LEN;
+    const messageDataOffset = messageDataSizeOffset + MESSAGE_SIZE_LEN;
+    const signature = buffer.slice(signatureOffset, signatureOffset + SIGNATURE_LEN);
+    const publicKey = buffer.slice(publicKeyOffset, publicKeyOffset + PUBKEY_LEN);
+    const messageSize = buffer[messageDataSizeOffset] | (buffer[messageDataSizeOffset + 1] << 8);
+    const message = buffer.slice(messageDataOffset, messageDataOffset + messageSize);
+    if (publicKey.length !== PUBKEY_LEN) {
+        throw new Error('Invalid public key length');
+    }
+    if (signature.length !== SIGNATURE_LEN) {
+        throw new Error('Invalid signature length');
+    }
+    return {
+        publicKey,
+        signature,
+        message,
+    };
+}
+exports.getEd25519ArgsFromHex = getEd25519ArgsFromHex;
+/**
+ * Constructs a minimal Ed25519 verification instruction that references the data
+ * inside the main instruction (postPythLazerOracleUpdate).
+ *
+ * @param customInstructionIndex The index of the custom instruction in the transaction (typically 1 if this is second).
+ * @param messageOffset The offset within the custom instruction data where the pythMessage begins.
+ * @param customInstructionData The entire instruction data array for the custom instruction.
+ */
+function createMinimalEd25519VerifyIx(customInstructionIndex, messageOffset, customInstructionData) {
+    const signatureOffset = messageOffset + MAGIC_LEN;
+    const publicKeyOffset = signatureOffset + SIGNATURE_LEN;
+    const messageDataSizeOffset = publicKeyOffset + PUBKEY_LEN;
+    const messageDataOffset = messageDataSizeOffset + MESSAGE_SIZE_LEN;
+    if (messageDataOffset > customInstructionData.length) {
+        throw new Error('Not enough data in main instruction to read message size');
+    }
+    const messageSize = customInstructionData[messageDataSizeOffset] |
+        (customInstructionData[messageDataSizeOffset + 1] << 8);
+    // Construct Ed25519SignatureOffsets
+    // struct Ed25519SignatureOffsets (14 bytes):
+    // u16 signature_offset
+    // u16 signature_instruction_index
+    // u16 public_key_offset
+    // u16 public_key_instruction_index
+    // u16 message_data_offset
+    // u16 message_data_size
+    // u16 message_instruction_index
+    const offsets = new Uint8Array(14);
+    const dv = new DataView(offsets.buffer);
+    let byteOffset = 0;
+    dv.setUint16(byteOffset, signatureOffset, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, customInstructionIndex, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, publicKeyOffset, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, customInstructionIndex, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, messageDataOffset, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, messageSize, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, customInstructionIndex, true);
+    byteOffset += 2;
+    const numSignatures = 1;
+    const padding = 0;
+    const ixData = new Uint8Array(2 + offsets.length);
+    ixData[0] = numSignatures;
+    ixData[1] = padding;
+    ixData.set(offsets, 2);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            {
+                pubkey: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+                isSigner: false,
+                isWritable: false,
+            },
+        ],
+        programId: web3_js_1.Ed25519Program.programId,
+        data: Buffer.from(ixData),
+    });
+}
+exports.createMinimalEd25519VerifyIx = createMinimalEd25519VerifyIx;

package/lib/browser/util/tps.d.ts

@@ -0,0 +1,2 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+export declare function estimateTps(programId: PublicKey, connection: Connection, failed: boolean): Promise<number>;

package/lib/browser/util/tps.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTps = void 0;
+async function estimateTps(programId, connection, failed) {
+    let signatures = await 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/lib/browser/wallet.d.ts

@@ -0,0 +1,11 @@
+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;
+}

package/lib/browser/wallet.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wallet = void 0;
+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;

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

@@ -0,0 +1,27 @@
+/// <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;
+}

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/bulkAccountLoader.d.ts

@@ -0,0 +1,37 @@
+/// <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;
+}

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 GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
+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()), 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,7 @@
+import { UserStats } from '../userStats';
+import { BulkAccountLoader } from './bulkAccountLoader';
+/**
+ * @param userStats
+ * @param accountLoader
+ */
+export declare function bulkPollingUserStatsSubscribe(userStats: UserStats[], accountLoader: BulkAccountLoader): Promise<void>;

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,7 @@
+import { User } from '../user';
+import { BulkAccountLoader } from './bulkAccountLoader';
+/**
+ * @param users
+ * @param accountLoader
+ */
+export declare function bulkPollingUserSubscribe(users: User[], accountLoader: BulkAccountLoader): Promise<void>;

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;

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

@@ -0,0 +1,6 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { UserAccount, UserStatsAccount } from '../types';
+import { Program } from '@coral-xyz/anchor';
+export declare function fetchUserAccounts(connection: Connection, program: Program, authority: PublicKey, limit?: number): Promise<(UserAccount | undefined)[]>;
+export declare function fetchUserAccountsUsingKeys(connection: Connection, program: Program, userAccountPublicKeys: PublicKey[]): Promise<(UserAccount | undefined)[]>;
+export declare function fetchUserStatsAccount(connection: Connection, program: Program, authority: PublicKey): Promise<UserStatsAccount | undefined>;

package/lib/node/accounts/fetch.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchUserStatsAccount = exports.fetchUserAccountsUsingKeys = exports.fetchUserAccounts = void 0;
+const pda_1 = require("../addresses/pda");
+async function fetchUserAccounts(connection, program, authority, limit = 8) {
+    const userAccountPublicKeys = new Array();
+    for (let i = 0; i < limit; i++) {
+        userAccountPublicKeys.push(await (0, pda_1.getUserAccountPublicKey)(program.programId, authority, i));
+    }
+    return fetchUserAccountsUsingKeys(connection, program, userAccountPublicKeys);
+}
+exports.fetchUserAccounts = fetchUserAccounts;
+async function fetchUserAccountsUsingKeys(connection, program, userAccountPublicKeys) {
+    const accountInfos = await connection.getMultipleAccountsInfo(userAccountPublicKeys, 'confirmed');
+    return accountInfos.map((accountInfo) => {
+        if (!accountInfo) {
+            return undefined;
+        }
+        return program.account.user.coder.accounts.decodeUnchecked('User', accountInfo.data);
+    });
+}
+exports.fetchUserAccountsUsingKeys = fetchUserAccountsUsingKeys;
+async function fetchUserStatsAccount(connection, program, authority) {
+    const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(program.programId, authority);
+    const accountInfo = await connection.getAccountInfo(userStatsPublicKey, 'confirmed');
+    return accountInfo
+        ? program.account.user.coder.accounts.decodeUnchecked('UserStats', accountInfo.data)
+        : undefined;
+}
+exports.fetchUserStatsAccount = fetchUserStatsAccount;

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

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ResubOpts, GrpcConfigs } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+import { Client, ClientDuplexStream, CommitmentLevel, SubscribeRequest, SubscribeUpdate } from '../isomorphic/grpc';
+export declare class grpcAccountSubscriber<T> extends WebSocketAccountSubscriber<T> {
+    client: Client;
+    stream: ClientDuplexStream<SubscribeRequest, SubscribeUpdate>;
+    commitmentLevel: CommitmentLevel;
+    listenerId?: number;
+    constructor(grpcConfigs: GrpcConfigs, accountName: string, program: Program, accountPublicKey: PublicKey, decodeBuffer?: (buffer: Buffer) => T, resubOpts?: ResubOpts);
+    subscribe(onChange: (data: T) => void): Promise<void>;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}