@velocity-exchange/sdk 0.3.0 → 0.4.0

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

@@ -3,15 +3,72 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { RevenueShareAccount, RevenueShareEscrowAccount, UserAccount, UserStatsAccount } from '../types';
 import { VelocityProgram } from '../config';
+/**
+ * Fetches every `UserAccount` (sub-account) belonging to `authority`, from sub-account id `0`
+ * up to `limit - 1`, in a single batched `getMultipleAccountsInfo` RPC call.
+ * @param connection Connection used for the batched fetch.
+ * @param program Anchor program used to derive PDAs and decode account data.
+ * @param authority Wallet/authority pubkey whose sub-accounts to fetch.
+ * @param limit Number of sub-account ids to check, starting at 0. Defaults to 8.
+ * @returns One entry per sub-account id in order; `undefined` where no account exists at that id.
+ */
 export declare function fetchUserAccounts(connection: Connection, program: VelocityProgram, authority: PublicKey, limit?: number): Promise<(UserAccount | undefined)[]>;
+/**
+ * Fetches and decodes a specific list of `UserAccount` pubkeys in one batched
+ * `getMultipleAccountsInfo` RPC call. Unlike `fetchUserAccounts`, the caller supplies the exact
+ * addresses rather than deriving them by sub-account id.
+ * @param connection Connection used for the batched fetch.
+ * @param program Anchor program used to decode account data.
+ * @param userAccountPublicKeys Addresses to fetch, in order.
+ * @returns One entry per input pubkey, in the same order; `undefined` where no account exists at that address.
+ */
 export declare function fetchUserAccountsUsingKeys(connection: Connection, program: VelocityProgram, userAccountPublicKeys: PublicKey[]): Promise<(UserAccount | undefined)[]>;
+/**
+ * Fetches and decodes the `UserStatsAccount` for `authority`, if one exists.
+ * @param connection Connection used for the fetch.
+ * @param program Anchor program used to derive the PDA and decode account data.
+ * @param authority Wallet/authority pubkey the stats account belongs to.
+ * @returns The decoded account, or `undefined` if it hasn't been initialized on-chain.
+ */
 export declare function fetchUserStatsAccount(connection: Connection, program: VelocityProgram, authority: PublicKey): Promise<UserStatsAccount | undefined>;
+/**
+ * Fetches and decodes the `RevenueShareAccount` for `authority` (tracks referral/builder revenue
+ * share balances), if one exists.
+ * @param connection Connection used for the fetch.
+ * @param program Anchor program used to derive the PDA and decode account data.
+ * @param authority Wallet/authority pubkey the revenue share account belongs to.
+ * @returns The decoded account, or `null` if it hasn't been initialized on-chain.
+ */
 export declare function fetchRevenueShareAccount(connection: Connection, program: VelocityProgram, authority: PublicKey): Promise<RevenueShareAccount | null>;
+/**
+ * Fetches and decodes the `RevenueShareEscrowAccount` for `authority` (holds escrowed
+ * revenue-share amounts pending distribution), if one exists.
+ * @param connection Connection used for the fetch.
+ * @param program Anchor program used to derive the PDA and decode account data.
+ * @param authority Wallet/authority pubkey the escrow account belongs to.
+ * @returns The decoded account, or `null` if it hasn't been initialized on-chain.
+ */
 export declare function fetchRevenueShareEscrowAccount(connection: Connection, program: VelocityProgram, authority: PublicKey): Promise<RevenueShareEscrowAccount | null>;
+/** Options accepted by `fetchAccount`/`fetchAccounts`. */
 export type FetchAccountOptions = {
+    /** Commitment level for the underlying `getAccountInfo`/`getMultipleAccountsInfo` call; defaults to the connection's configured commitment if omitted. */
     commitment?: Parameters<Connection['getAccountInfo']>[1];
 };
-/** Raw account data buffer (no Anchor decode). */
+/**
+ * Fetches an account's raw data buffer without decoding it (no Anchor coder involved), for
+ * callers that only need the bytes.
+ * @param connection Connection used for the fetch.
+ * @param publicKey Account address to fetch.
+ * @param opts Optional commitment override.
+ * @returns The raw account data, or `null` if the account doesn't exist.
+ */
 export declare function fetchAccount(connection: Connection, publicKey: PublicKey, opts?: FetchAccountOptions): Promise<Buffer | null>;
-/** Batch variant of {@link fetchAccount}. */
+/**
+ * Batch variant of `fetchAccount` — fetches raw data buffers for multiple accounts in one
+ * `getMultipleAccountsInfo` call.
+ * @param connection Connection used for the fetch.
+ * @param publicKeys Account addresses to fetch, in order.
+ * @param opts Optional commitment override.
+ * @returns One entry per input pubkey, in the same order; `null` where the account doesn't exist.
+ */
 export declare function fetchAccounts(connection: Connection, publicKeys: PublicKey[], opts?: FetchAccountOptions): Promise<(Buffer | null)[]>;

package/lib/browser/accounts/fetch.js

@@ -2,6 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchAccounts = exports.fetchAccount = exports.fetchRevenueShareEscrowAccount = exports.fetchRevenueShareAccount = exports.fetchUserStatsAccount = exports.fetchUserAccountsUsingKeys = exports.fetchUserAccounts = void 0;
 const pda_1 = require("../addresses/pda");
+/**
+ * Fetches every `UserAccount` (sub-account) belonging to `authority`, from sub-account id `0`
+ * up to `limit - 1`, in a single batched `getMultipleAccountsInfo` RPC call.
+ * @param connection Connection used for the batched fetch.
+ * @param program Anchor program used to derive PDAs and decode account data.
+ * @param authority Wallet/authority pubkey whose sub-accounts to fetch.
+ * @param limit Number of sub-account ids to check, starting at 0. Defaults to 8.
+ * @returns One entry per sub-account id in order; `undefined` where no account exists at that id.
+ */
 async function fetchUserAccounts(connection, program, authority, limit = 8) {
     const userAccountPublicKeys = new Array();
     for (let i = 0; i < limit; i++) {
@@ -10,6 +19,15 @@ async function fetchUserAccounts(connection, program, authority, limit = 8) {
     return fetchUserAccountsUsingKeys(connection, program, userAccountPublicKeys);
 }
 exports.fetchUserAccounts = fetchUserAccounts;
+/**
+ * Fetches and decodes a specific list of `UserAccount` pubkeys in one batched
+ * `getMultipleAccountsInfo` RPC call. Unlike `fetchUserAccounts`, the caller supplies the exact
+ * addresses rather than deriving them by sub-account id.
+ * @param connection Connection used for the batched fetch.
+ * @param program Anchor program used to decode account data.
+ * @param userAccountPublicKeys Addresses to fetch, in order.
+ * @returns One entry per input pubkey, in the same order; `undefined` where no account exists at that address.
+ */
 async function fetchUserAccountsUsingKeys(connection, program, userAccountPublicKeys) {
     const accountInfos = await connection.getMultipleAccountsInfo(userAccountPublicKeys, 'confirmed');
     return accountInfos.map((accountInfo) => {
@@ -20,6 +38,13 @@ async function fetchUserAccountsUsingKeys(connection, program, userAccountPublic
     });
 }
 exports.fetchUserAccountsUsingKeys = fetchUserAccountsUsingKeys;
+/**
+ * Fetches and decodes the `UserStatsAccount` for `authority`, if one exists.
+ * @param connection Connection used for the fetch.
+ * @param program Anchor program used to derive the PDA and decode account data.
+ * @param authority Wallet/authority pubkey the stats account belongs to.
+ * @returns The decoded account, or `undefined` if it hasn't been initialized on-chain.
+ */
 async function fetchUserStatsAccount(connection, program, authority) {
     const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(program.programId, authority);
     const accountInfo = await connection.getAccountInfo(userStatsPublicKey, 'confirmed');
@@ -28,6 +53,14 @@ async function fetchUserStatsAccount(connection, program, authority) {
         : undefined;
 }
 exports.fetchUserStatsAccount = fetchUserStatsAccount;
+/**
+ * Fetches and decodes the `RevenueShareAccount` for `authority` (tracks referral/builder revenue
+ * share balances), if one exists.
+ * @param connection Connection used for the fetch.
+ * @param program Anchor program used to derive the PDA and decode account data.
+ * @param authority Wallet/authority pubkey the revenue share account belongs to.
+ * @returns The decoded account, or `null` if it hasn't been initialized on-chain.
+ */
 async function fetchRevenueShareAccount(connection, program, authority) {
     const revenueShareAccountPublicKey = (0, pda_1.getRevenueShareAccountPublicKey)(program.programId, authority);
     const accountInfo = await connection.getAccountInfo(revenueShareAccountPublicKey);
@@ -36,6 +69,14 @@ async function fetchRevenueShareAccount(connection, program, authority) {
     return program.account.revenueShare.coder.accounts.decode('revenueShare', accountInfo.data);
 }
 exports.fetchRevenueShareAccount = fetchRevenueShareAccount;
+/**
+ * Fetches and decodes the `RevenueShareEscrowAccount` for `authority` (holds escrowed
+ * revenue-share amounts pending distribution), if one exists.
+ * @param connection Connection used for the fetch.
+ * @param program Anchor program used to derive the PDA and decode account data.
+ * @param authority Wallet/authority pubkey the escrow account belongs to.
+ * @returns The decoded account, or `null` if it hasn't been initialized on-chain.
+ */
 async function fetchRevenueShareEscrowAccount(connection, program, authority) {
     const revenueShareEscrowPubKey = (0, pda_1.getRevenueShareEscrowAccountPublicKey)(program.programId, authority);
     const escrow = await connection.getAccountInfo(revenueShareEscrowPubKey);
@@ -45,14 +86,28 @@ async function fetchRevenueShareEscrowAccount(connection, program, authority) {
     return escrowAccount;
 }
 exports.fetchRevenueShareEscrowAccount = fetchRevenueShareEscrowAccount;
-/** Raw account data buffer (no Anchor decode). */
+/**
+ * Fetches an account's raw data buffer without decoding it (no Anchor coder involved), for
+ * callers that only need the bytes.
+ * @param connection Connection used for the fetch.
+ * @param publicKey Account address to fetch.
+ * @param opts Optional commitment override.
+ * @returns The raw account data, or `null` if the account doesn't exist.
+ */
 async function fetchAccount(connection, publicKey, opts) {
     var _a;
     const info = await connection.getAccountInfo(publicKey, opts === null || opts === void 0 ? void 0 : opts.commitment);
     return (_a = info === null || info === void 0 ? void 0 : info.data) !== null && _a !== void 0 ? _a : null;
 }
 exports.fetchAccount = fetchAccount;
-/** Batch variant of {@link fetchAccount}. */
+/**
+ * Batch variant of `fetchAccount` — fetches raw data buffers for multiple accounts in one
+ * `getMultipleAccountsInfo` call.
+ * @param connection Connection used for the fetch.
+ * @param publicKeys Account addresses to fetch, in order.
+ * @param opts Optional commitment override.
+ * @returns One entry per input pubkey, in the same order; `null` where the account doesn't exist.
+ */
 async function fetchAccounts(connection, publicKeys, opts) {
     const infos = await connection.getMultipleAccountsInfo(publicKeys, opts === null || opts === void 0 ? void 0 : opts.commitment);
     return infos.map((info) => { var _a; return (_a = info === null || info === void 0 ? void 0 : info.data) !== null && _a !== void 0 ? _a : null; });

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

@@ -5,6 +5,13 @@ import { PublicKey } from '@solana/web3.js';
 import { VelocityProgram } from '../config';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
 import { Client } from '../isomorphic/grpc';
+/**
+ * `AccountSubscriber` for a single account, streamed via a gRPC Geyser plugin (Yellowstone or
+ * LaserStream, per `GrpcConfigs`) instead of the standard `connection.onAccountChange` WebSocket.
+ * Extends `WebSocketAccountSubscriber` to reuse its buffering/decode/resub-timer logic — only the
+ * transport (`subscribe`/`unsubscribe`) is replaced. Construct via the static `create` factory,
+ * not the constructor directly, since establishing the gRPC client is asynchronous.
+ */
 export declare class grpcAccountSubscriber<T> extends WebSocketAccountSubscriber<T> {
     private client;
     private _stream?;
@@ -12,7 +19,30 @@ export declare class grpcAccountSubscriber<T> extends WebSocketAccountSubscriber
     private commitmentLevel;
     listenerId?: number;
     private constructor();
+    /**
+     * Creates a gRPC client (or reuses `clientProp`, letting multiple subscribers share one
+     * connection) and constructs a `grpcAccountSubscriber`. Does not itself start streaming — call
+     * `subscribe()` on the result.
+     * @param grpcConfigs gRPC Geyser endpoint/token/commitment config (Yellowstone or LaserStream).
+     * @param accountName Anchor account type name (used for logging and, absent `decodeBuffer`, for decoding via the program coder).
+     * @param program Anchor program providing the connection and coder.
+     * @param accountPublicKey Address of the account to track.
+     * @param decodeBuffer Optional custom decode function; defaults to `program.coder.accounts.decode(accountName, buffer)`.
+     * @param resubOpts Resubscription watchdog options; omit to disable the inactivity timer.
+     * @param clientProp Optional existing gRPC client to reuse instead of creating a new connection.
+     */
     static create<U>(grpcConfigs: GrpcConfigs, accountName: string, program: VelocityProgram, accountPublicKey: PublicKey, decodeBuffer?: (buffer: Buffer) => U, resubOpts?: ResubOpts, clientProp?: Client): Promise<grpcAccountSubscriber<U>>;
+    /**
+     * Seeds `dataAndSlot` with an initial `fetch()` (if not already set), opens a gRPC subscribe
+     * stream filtered to this single account, and writes the subscribe request. Idempotent: a
+     * no-op if already subscribed or mid-unsubscribe.
+     * @param onChange Invoked with the newly decoded account data on each accepted update.
+     */
     subscribe(onChange: (data: T) => void): Promise<void>;
+    /**
+     * Writes an empty subscribe request to clear the stream's account filter and cancels any
+     * pending resub timeout.
+     * @param onResub Internal flag set to `true` when called as part of an automatic resubscribe cycle, which preserves `resubOpts.resubTimeoutMs` instead of clearing it. Callers should omit this.
+     */
     unsubscribe(onResub?: boolean): Promise<void>;
 }

package/lib/browser/accounts/grpcAccountSubscriber.js

@@ -28,6 +28,13 @@ const web3_js_1 = require("@solana/web3.js");
 const Buffer = __importStar(require("buffer"));
 const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
 const grpc_1 = require("../isomorphic/grpc");
+/**
+ * `AccountSubscriber` for a single account, streamed via a gRPC Geyser plugin (Yellowstone or
+ * LaserStream, per `GrpcConfigs`) instead of the standard `connection.onAccountChange` WebSocket.
+ * Extends `WebSocketAccountSubscriber` to reuse its buffering/decode/resub-timer logic — only the
+ * transport (`subscribe`/`unsubscribe`) is replaced. Construct via the static `create` factory,
+ * not the constructor directly, since establishing the gRPC client is asynchronous.
+ */
 class grpcAccountSubscriber extends webSocketAccountSubscriber_1.WebSocketAccountSubscriber {
     get stream() {
         if (!this._stream) {
@@ -40,6 +47,18 @@ class grpcAccountSubscriber extends webSocketAccountSubscriber_1.WebSocketAccoun
         this.client = client;
         this.commitmentLevel = commitmentLevel;
     }
+    /**
+     * Creates a gRPC client (or reuses `clientProp`, letting multiple subscribers share one
+     * connection) and constructs a `grpcAccountSubscriber`. Does not itself start streaming — call
+     * `subscribe()` on the result.
+     * @param grpcConfigs gRPC Geyser endpoint/token/commitment config (Yellowstone or LaserStream).
+     * @param accountName Anchor account type name (used for logging and, absent `decodeBuffer`, for decoding via the program coder).
+     * @param program Anchor program providing the connection and coder.
+     * @param accountPublicKey Address of the account to track.
+     * @param decodeBuffer Optional custom decode function; defaults to `program.coder.accounts.decode(accountName, buffer)`.
+     * @param resubOpts Resubscription watchdog options; omit to disable the inactivity timer.
+     * @param clientProp Optional existing gRPC client to reuse instead of creating a new connection.
+     */
     static async create(grpcConfigs, accountName, program, accountPublicKey, decodeBuffer, resubOpts, clientProp) {
         var _a, _b;
         const client = clientProp
@@ -50,6 +69,12 @@ class grpcAccountSubscriber extends webSocketAccountSubscriber_1.WebSocketAccoun
         (_b = grpcConfigs.commitmentLevel) !== null && _b !== void 0 ? _b : grpc_1.CommitmentLevel.CONFIRMED;
         return new grpcAccountSubscriber(client, commitmentLevel, accountName, program, accountPublicKey, decodeBuffer, resubOpts);
     }
+    /**
+     * Seeds `dataAndSlot` with an initial `fetch()` (if not already set), opens a gRPC subscribe
+     * stream filtered to this single account, and writes the subscribe request. Idempotent: a
+     * no-op if already subscribed or mid-unsubscribe.
+     * @param onChange Invoked with the newly decoded account data on each accepted update.
+     */
     async subscribe(onChange) {
         if (this.listenerId != null || this.isUnsubscribing) {
             return;
@@ -125,6 +150,11 @@ class grpcAccountSubscriber extends webSocketAccountSubscriber_1.WebSocketAccoun
             throw reason;
         });
     }
+    /**
+     * Writes an empty subscribe request to clear the stream's account filter and cancels any
+     * pending resub timeout.
+     * @param onResub Internal flag set to `true` when called as part of an automatic resubscribe cycle, which preserves `resubOpts.resubTimeoutMs` instead of clearing it. Callers should omit this.
+     */
     async unsubscribe(onResub = false) {
         if (!onResub && this.resubOpts) {
             this.resubOpts.resubTimeoutMs = undefined;

package/lib/browser/accounts/grpcInsuranceFundStakeAccountSubscriber.d.ts

@@ -3,8 +3,24 @@ import { PublicKey } from '@solana/web3.js';
 import { InsuranceFundStake } from '../types';
 import { WebSocketInsuranceFundStakeAccountSubscriber } from './webSocketInsuranceFundStakeAccountSubscriber';
 import { VelocityProgram } from '../config';
+/**
+ * `InsuranceFundStakeAccountSubscriber` variant of `WebSocketInsuranceFundStakeAccountSubscriber`
+ * that tracks the `InsuranceFundStake` account via a `grpcAccountSubscriber` (gRPC Geyser stream)
+ * instead of `connection.onAccountChange`.
+ */
 export declare class grpcInsuranceFundStakeAccountSubscriber extends WebSocketInsuranceFundStakeAccountSubscriber {
     private grpcConfigs;
+    /**
+     * @param grpcConfigs gRPC Geyser endpoint/token/commitment config (Yellowstone or LaserStream).
+     * @param program Anchor program providing the connection and coder.
+     * @param insuranceFundStakeAccountPublicKey Address of the `InsuranceFundStake` account to track.
+     * @param resubTimeoutMs Resub watchdog timeout (ms) passed to the underlying `grpcAccountSubscriber`.
+     */
     constructor(grpcConfigs: GrpcConfigs, program: VelocityProgram, insuranceFundStakeAccountPublicKey: PublicKey, resubTimeoutMs?: number);
+    /**
+     * Creates the underlying `grpcAccountSubscriber` and subscribes it. Idempotent: a no-op
+     * (returns `true`) if already subscribed.
+     * @param insuranceFundStakeAccount Optional pre-fetched account data to seed the subscriber with, skipping the initial RPC fetch.
+     */
     subscribe(insuranceFundStakeAccount?: InsuranceFundStake): Promise<boolean>;
 }

package/lib/browser/accounts/grpcInsuranceFundStakeAccountSubscriber.js

@@ -3,11 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.grpcInsuranceFundStakeAccountSubscriber = void 0;
 const webSocketInsuranceFundStakeAccountSubscriber_1 = require("./webSocketInsuranceFundStakeAccountSubscriber");
 const grpcAccountSubscriber_1 = require("./grpcAccountSubscriber");
+/**
+ * `InsuranceFundStakeAccountSubscriber` variant of `WebSocketInsuranceFundStakeAccountSubscriber`
+ * that tracks the `InsuranceFundStake` account via a `grpcAccountSubscriber` (gRPC Geyser stream)
+ * instead of `connection.onAccountChange`.
+ */
 class grpcInsuranceFundStakeAccountSubscriber extends webSocketInsuranceFundStakeAccountSubscriber_1.WebSocketInsuranceFundStakeAccountSubscriber {
+    /**
+     * @param grpcConfigs gRPC Geyser endpoint/token/commitment config (Yellowstone or LaserStream).
+     * @param program Anchor program providing the connection and coder.
+     * @param insuranceFundStakeAccountPublicKey Address of the `InsuranceFundStake` account to track.
+     * @param resubTimeoutMs Resub watchdog timeout (ms) passed to the underlying `grpcAccountSubscriber`.
+     */
     constructor(grpcConfigs, program, insuranceFundStakeAccountPublicKey, resubTimeoutMs) {
         super(program, insuranceFundStakeAccountPublicKey, resubTimeoutMs);
         this.grpcConfigs = grpcConfigs;
     }
+    /**
+     * Creates the underlying `grpcAccountSubscriber` and subscribes it. Idempotent: a no-op
+     * (returns `true`) if already subscribed.
+     * @param insuranceFundStakeAccount Optional pre-fetched account data to seed the subscriber with, skipping the initial RPC fetch.
+     */
     async subscribe(insuranceFundStakeAccount) {
         if (this.isSubscribed) {
             return true;

package/lib/browser/accounts/grpcMultiAccountSubscriber.d.ts

@@ -4,6 +4,15 @@ import { Context, PublicKey } from '@solana/web3.js';
 import { VelocityProgram } from '../config';
 import { Client } from '../isomorphic/grpc';
 import { DataAndSlot, GrpcConfigs, ResubOpts } from './types';
+/**
+ * Multiplexes many accounts of the same Anchor type onto a single gRPC Geyser subscribe stream,
+ * rather than one `grpcAccountSubscriber` per account. Optional generic `U` ("account props")
+ * lets a caller attach metadata (e.g. `OracleInfo`) per pubkey — or per **array** of `U` values
+ * for a pubkey backing multiple logical entries (see `accountPropsMap`, used when several oracle
+ * ids share one underlying account). Construct via the static `create` factory, not the
+ * constructor directly, since establishing the gRPC client is asynchronous. Accounts can be added/
+ * removed from an already-open stream via `addAccounts`/`removeAccounts` without a full resubscribe.
+ */
 export declare class grpcMultiAccountSubscriber<T, U = undefined> {
     private client;
     private _stream?;
@@ -24,14 +33,64 @@ export declare class grpcMultiAccountSubscriber<T, U = undefined> {
     private accountPropsMap;
     private bufferMap;
     private constructor();
+    /**
+     * Creates a gRPC client (or reuses `clientProp`) and constructs a `grpcMultiAccountSubscriber`.
+     * Does not itself start streaming — call `subscribe(accounts, onChange)` on the result.
+     * @param grpcConfigs gRPC Geyser endpoint/token/commitment config (Yellowstone or LaserStream).
+     * @param accountName Anchor account type name all multiplexed accounts share, used for decoding via the program coder absent `decodeBuffer`.
+     * @param program Anchor program providing the connection (for `fetch()`) and coder.
+     * @param decodeBuffer Optional custom decode function receiving the buffer, the account's base58 pubkey, and its `accountProps` entry (or one element of it, if an array); defaults to `program.coder.accounts.decode(accountName, buffer)`.
+     * @param resubOpts Resubscription watchdog options; `resubTimeoutMs` triggers a full unsubscribe on inactivity (no automatic resubscribe here — see `onUnsubscribe`).
+     * @param clientProp Optional existing gRPC client to reuse instead of creating a new connection.
+     * @param onUnsubscribe Optional callback invoked after `unsubscribe()` completes (or the resub-timeout-driven unsubscribe fires), typically used by callers to drive their own resubscribe logic.
+     * @param accountPropsMap Optional per-pubkey metadata (or array of metadata, for a shared pubkey) passed through to `decodeBuffer` and the `subscribe`/`addAccounts` change callback.
+     */
     static create<T, U = undefined>(grpcConfigs: GrpcConfigs, accountName: string, program: VelocityProgram, decodeBuffer?: (buffer: Buffer, pubkey?: string, accountProps?: U) => T, resubOpts?: ResubOpts, clientProp?: Client, onUnsubscribe?: () => Promise<void>, accountPropsMap?: Map<string, U | Array<U>>): Promise<grpcMultiAccountSubscriber<T, U>>;
+    /**
+     * Seeds or overwrites the cached data for one account, bypassing gRPC/RPC. Used to inject
+     * data the caller already has (e.g. from an initial batch fetch) before the stream delivers
+     * live updates.
+     * @param accountPubkey Base58 pubkey of the account.
+     * @param data Decoded account data to store.
+     * @param slot Slot the data was observed at; defaults to 0 (the seeded sentinel) if omitted.
+     */
     setAccountData(accountPubkey: string, data: T, slot?: number): void;
+    /** Returns the cached data/slot for one account, or undefined if not yet loaded. */
     getAccountData(accountPubkey: string): DataAndSlot<T> | undefined;
+    /** Returns the full map of base58 pubkey to cached data/slot for every multiplexed account. */
     getAccountDataMap(): Map<string, DataAndSlot<T>>;
+    /**
+     * Fetches every subscribed account once via chunked `getMultipleAccountsInfoAndContext` calls
+     * (100 pubkeys per chunk, processed concurrently), updating `dataMap`/`bufferMap` for any
+     * account whose buffer changed at a non-decreasing slot. Errors are logged (if
+     * `resubOpts.logResubMessages`) and swallowed rather than thrown.
+     */
     fetch(): Promise<void>;
+    /**
+     * Opens a single gRPC subscribe stream covering all of `accounts`. Each update is decoded and
+     * cached (via `setAccountData`) before `onChange` is invoked. Idempotent: a no-op if already
+     * subscribed or mid-unsubscribe.
+     * @param accounts Pubkeys to include in the stream filter.
+     * @param onChange Invoked once per changed account with its pubkey, decoded data, the notification's `Context` (including `slot`), the raw buffer, and any `accountProps` metadata registered for that pubkey.
+     */
     subscribe(accounts: PublicKey[], onChange: (accountId: PublicKey, data: T, context: Context, buffer: Buffer, accountProps: U | undefined) => void): Promise<void>;
-    addAccounts(accounts: PublicKey[]): Promise<void>;
+    /**
+     * Extends the already-open stream's filter to include `accounts` (re-writing the full
+     * accumulated filter set, since the gRPC protocol has no incremental "add" primitive), then
+     * immediately calls `fetch()` to backfill their initial data.
+     * @param accounts Additional pubkeys to start tracking.
+     * @param accountProps Optional per-pubkey metadata to merge into `accountPropsMap` so the
+     *   injected decoder can decode the newly added accounts (without it, a new `(pubkey, source)`
+     *   oracle would decode with missing `accountProps` and throw).
+     */
+    addAccounts(accounts: PublicKey[], accountProps?: Map<string, U | Array<U>>): Promise<void>;
+    /**
+     * Removes `accounts` from `subscribedAccounts`/`onChangeMap` and re-writes the stream's filter
+     * to exclude them. Does not clear their cached data from `dataMap`/`bufferMap`.
+     * @param accounts Pubkeys to stop tracking.
+     */
     removeAccounts(accounts: PublicKey[]): Promise<void>;
+    /** Writes an empty subscribe request to clear the stream's account filter, cancels any pending resub timeout, and invokes `onUnsubscribe` if one was registered at construction. */
     unsubscribe(): Promise<void>;
     private setTimeout;
 }