@velocity-exchange/sdk 0.0.1

package/lib/browser/accounts/grpcMultiAccountSubscriber.js

@@ -0,0 +1,378 @@
+"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.grpcMultiAccountSubscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const Buffer = __importStar(require("buffer"));
+const bs58_1 = __importDefault(require("bs58"));
+const grpc_1 = require("../isomorphic/grpc");
+function commitmentLevelToCommitment(commitmentLevel) {
+    switch (commitmentLevel) {
+        case grpc_1.CommitmentLevel.PROCESSED:
+            return 'processed';
+        case grpc_1.CommitmentLevel.CONFIRMED:
+            return 'confirmed';
+        case grpc_1.CommitmentLevel.FINALIZED:
+            return 'finalized';
+        default:
+            return 'confirmed';
+    }
+}
+class grpcMultiAccountSubscriber {
+    constructor(client, commitmentLevel, accountName, program, decodeBuffer, resubOpts, onUnsubscribe, accountPropsMap) {
+        this.isUnsubscribing = false;
+        this.receivingData = false;
+        this.subscribedAccounts = new Set();
+        this.onChangeMap = new Map();
+        this.dataMap = new Map();
+        this.accountPropsMap = new Map();
+        this.bufferMap = new Map();
+        this.client = client;
+        this.commitmentLevel = commitmentLevel;
+        this.accountName = accountName;
+        this.program = program;
+        this.decodeBufferFn = decodeBuffer;
+        this.resubOpts = resubOpts;
+        this.onUnsubscribe = onUnsubscribe;
+        this.accountPropsMap = accountPropsMap;
+    }
+    static async create(grpcConfigs, accountName, program, decodeBuffer, resubOpts, clientProp, onUnsubscribe, accountPropsMap) {
+        var _a, _b;
+        const client = clientProp
+            ? clientProp
+            : await (0, grpc_1.createClient)(grpcConfigs.endpoint, grpcConfigs.token, (_a = grpcConfigs.channelOptions) !== null && _a !== void 0 ? _a : {});
+        const 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;
+        return new grpcMultiAccountSubscriber(client, commitmentLevel, accountName, program, decodeBuffer, resubOpts, onUnsubscribe, accountPropsMap);
+    }
+    setAccountData(accountPubkey, data, slot) {
+        this.dataMap.set(accountPubkey, { data, slot });
+    }
+    getAccountData(accountPubkey) {
+        return this.dataMap.get(accountPubkey);
+    }
+    getAccountDataMap() {
+        return this.dataMap;
+    }
+    async fetch() {
+        var _a;
+        try {
+            // Chunk account IDs into groups of 100 (getMultipleAccounts limit)
+            const chunkSize = 100;
+            const chunks = [];
+            const accountIds = Array.from(this.subscribedAccounts.values());
+            for (let i = 0; i < accountIds.length; i += chunkSize) {
+                chunks.push(accountIds.slice(i, i + chunkSize));
+            }
+            // Process all chunks concurrently
+            await Promise.all(chunks.map(async (chunk) => {
+                const accountAddresses = chunk.map((accountId) => new web3_js_1.PublicKey(accountId));
+                const rpcResponseAndContext = await this.program.provider.connection.getMultipleAccountsInfoAndContext(accountAddresses, {
+                    commitment: commitmentLevelToCommitment(this.commitmentLevel),
+                });
+                const rpcResponse = rpcResponseAndContext.value;
+                const currentSlot = rpcResponseAndContext.context.slot;
+                for (let i = 0; i < chunk.length; i++) {
+                    const accountId = chunk[i];
+                    const accountInfo = rpcResponse[i];
+                    if (accountInfo) {
+                        const prev = this.bufferMap.get(accountId);
+                        const newBuffer = accountInfo.data;
+                        if (prev && currentSlot < prev.slot) {
+                            continue;
+                        }
+                        if (prev &&
+                            prev.buffer &&
+                            newBuffer &&
+                            newBuffer.equals(prev.buffer)) {
+                            continue;
+                        }
+                        this.bufferMap.set(accountId, {
+                            buffer: newBuffer,
+                            slot: currentSlot,
+                        });
+                        const accountDecoded = this.program.coder.accounts.decode(this.capitalize(this.accountName), newBuffer);
+                        this.setAccountData(accountId, accountDecoded, currentSlot);
+                    }
+                }
+            }));
+        }
+        catch (error) {
+            if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.logResubMessages) {
+                console.log(`[${this.accountName}] grpcMultiAccountSubscriber error fetching accounts:`, error);
+            }
+        }
+    }
+    async subscribe(accounts, onChange) {
+        var _a;
+        if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.logResubMessages) {
+            console.log(`[${this.accountName}] grpcMultiAccountSubscriber subscribe`);
+        }
+        if (this.listenerId != null || this.isUnsubscribing) {
+            return;
+        }
+        // Track accounts and single onChange for all
+        for (const pk of accounts) {
+            const key = pk.toBase58();
+            this.subscribedAccounts.add(key);
+            this.onChangeMap.set(key, (data, ctx, buffer, accountProps) => {
+                this.setAccountData(key, data, ctx.slot);
+                onChange(new web3_js_1.PublicKey(key), data, ctx, buffer, accountProps);
+            });
+        }
+        this.stream =
+            (await this.client.subscribe());
+        const request = {
+            slots: {},
+            accounts: {
+                account: {
+                    account: accounts.map((a) => a.toBase58()),
+                    owner: [],
+                    filters: [],
+                },
+            },
+            transactions: {},
+            blocks: {},
+            blocksMeta: {},
+            accountsDataSlice: [],
+            commitment: this.commitmentLevel,
+            entry: {},
+            transactionsStatus: {},
+        };
+        this.stream.on('data', (chunk) => {
+            var _a, _b;
+            if (!chunk.account) {
+                return;
+            }
+            const slot = Number(chunk.account.slot);
+            const accountPubkeyBytes = chunk.account.account.pubkey;
+            const accountPubkey = bs58_1.default.encode(accountPubkeyBytes);
+            if (!accountPubkey || !this.subscribedAccounts.has(accountPubkey)) {
+                return;
+            }
+            // Touch resub timer on any incoming account update for subscribed keys
+            if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                this.receivingData = true;
+                clearTimeout(this.timeoutId);
+                this.setTimeout();
+            }
+            // Skip processing if we already have data for this account at a newer slot
+            const existing = this.dataMap.get(accountPubkey);
+            if ((existing === null || existing === void 0 ? void 0 : existing.slot) !== undefined && existing.slot > slot) {
+                return;
+            }
+            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),
+            };
+            const context = { slot };
+            const buffer = accountInfo.data;
+            // Check existing buffer for this account and skip if unchanged or slot regressed
+            const prevBuffer = this.bufferMap.get(accountPubkey);
+            if (prevBuffer && slot < prevBuffer.slot) {
+                return;
+            }
+            if (prevBuffer &&
+                prevBuffer.buffer &&
+                buffer &&
+                buffer.equals(prevBuffer.buffer)) {
+                return;
+            }
+            this.bufferMap.set(accountPubkey, { buffer, slot });
+            const accountProps = (_b = this.accountPropsMap) === null || _b === void 0 ? void 0 : _b.get(accountPubkey);
+            const handleDataBuffer = (context, buffer, accountProps) => {
+                const data = this.decodeBufferFn
+                    ? this.decodeBufferFn(buffer, accountPubkey, accountProps)
+                    : this.program.account[this.accountName].coder.accounts.decode(this.capitalize(this.accountName), buffer);
+                const handler = this.onChangeMap.get(accountPubkey);
+                if (handler) {
+                    handler(data, context, buffer, accountProps);
+                }
+            };
+            if (Array.isArray(accountProps)) {
+                for (const props of accountProps) {
+                    handleDataBuffer(context, buffer, props);
+                }
+            }
+            else {
+                handleDataBuffer(context, buffer, accountProps);
+            }
+        });
+        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;
+                    }
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        }).catch((reason) => {
+            console.error(reason);
+            throw reason;
+        });
+    }
+    async addAccounts(accounts) {
+        for (const pk of accounts) {
+            this.subscribedAccounts.add(pk.toBase58());
+        }
+        const request = {
+            slots: {},
+            accounts: {
+                account: {
+                    account: Array.from(this.subscribedAccounts.values()),
+                    owner: [],
+                    filters: [],
+                },
+            },
+            transactions: {},
+            blocks: {},
+            blocksMeta: {},
+            accountsDataSlice: [],
+            commitment: this.commitmentLevel,
+            entry: {},
+            transactionsStatus: {},
+        };
+        await new Promise((resolve, reject) => {
+            this.stream.write(request, (err) => {
+                if (err === null || err === undefined) {
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+        await this.fetch();
+    }
+    async removeAccounts(accounts) {
+        for (const pk of accounts) {
+            const k = pk.toBase58();
+            this.subscribedAccounts.delete(k);
+            this.onChangeMap.delete(k);
+        }
+        const request = {
+            slots: {},
+            accounts: {
+                account: {
+                    account: Array.from(this.subscribedAccounts.values()),
+                    owner: [],
+                    filters: [],
+                },
+            },
+            transactions: {},
+            blocks: {},
+            blocksMeta: {},
+            accountsDataSlice: [],
+            commitment: this.commitmentLevel,
+            entry: {},
+            transactionsStatus: {},
+        };
+        await new Promise((resolve, reject) => {
+            this.stream.write(request, (err) => {
+                if (err === null || err === undefined) {
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    async unsubscribe() {
+        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;
+        }
+        if (this.onUnsubscribe) {
+            try {
+                await this.onUnsubscribe();
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+    setTimeout() {
+        var _a;
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing) {
+                return;
+            }
+            if (this.receivingData) {
+                await this.unsubscribe();
+                this.receivingData = false;
+            }
+        }, (_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs);
+    }
+    capitalize(value) {
+        if (!value)
+            return value;
+        return value.charAt(0).toUpperCase() + value.slice(1);
+    }
+}
+exports.grpcMultiAccountSubscriber = grpcMultiAccountSubscriber;

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

@@ -0,0 +1,25 @@
+import { GrpcConfigs, ResubOpts, UserAccountSubscriber } from './types';
+import { PublicKey } from '@solana/web3.js';
+import { UserAccount } from '../types';
+import { VelocityProgram } from '../config';
+import { grpcMultiAccountSubscriber } from './grpcMultiAccountSubscriber';
+export declare class grpcMultiUserAccountSubscriber {
+    private program;
+    private multiSubscriber;
+    private userData;
+    private listeners;
+    private keyToPk;
+    private pendingAddKeys;
+    private debounceTimer?;
+    private debounceMs;
+    private isMultiSubscribed;
+    private userAccountSubscribers;
+    private grpcConfigs;
+    resubOpts?: ResubOpts;
+    private handleAccountChange;
+    constructor(program: VelocityProgram, grpcConfigs: GrpcConfigs, resubOpts?: ResubOpts, multiSubscriber?: grpcMultiAccountSubscriber<UserAccount>);
+    subscribe(): Promise<void>;
+    forUser(userAccountPublicKey: PublicKey): UserAccountSubscriber;
+    private scheduleFlush;
+    private flushPending;
+}

package/lib/browser/accounts/grpcMultiUserAccountSubscriber.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcMultiUserAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const web3_js_1 = require("@solana/web3.js");
+const grpcMultiAccountSubscriber_1 = require("./grpcMultiAccountSubscriber");
+class grpcMultiUserAccountSubscriber {
+    constructor(program, grpcConfigs, resubOpts, multiSubscriber) {
+        this.userData = new Map();
+        this.listeners = new Map();
+        this.keyToPk = new Map();
+        this.pendingAddKeys = new Set();
+        this.debounceMs = 20;
+        this.isMultiSubscribed = false;
+        this.userAccountSubscribers = new Map();
+        this.handleAccountChange = (accountId, data, context, _buffer, _accountProps) => {
+            const k = accountId.toBase58();
+            this.userData.set(k, { data, slot: context.slot });
+            const setForKey = this.listeners.get(k);
+            if (setForKey) {
+                for (const emitter of setForKey) {
+                    emitter.emit('userAccountUpdate', data);
+                    emitter.emit('update');
+                }
+            }
+        };
+        this.program = program;
+        this.multiSubscriber = multiSubscriber;
+        this.grpcConfigs = grpcConfigs;
+        this.resubOpts = resubOpts;
+    }
+    async subscribe() {
+        if (!this.multiSubscriber) {
+            this.multiSubscriber =
+                await grpcMultiAccountSubscriber_1.grpcMultiAccountSubscriber.create(this.grpcConfigs, 'user', this.program, undefined, this.resubOpts);
+        }
+        // Subscribe all per-user subscribers first
+        await Promise.all(Array.from(this.userAccountSubscribers.values()).map((subscriber) => subscriber.subscribe()));
+        // Ensure we immediately register any pending keys and kick off underlying subscription/fetch
+        await this.flushPending();
+        // Proactively fetch once to populate data for all subscribed accounts
+        await this.multiSubscriber.fetch();
+        // Wait until the underlying multi-subscriber has data for every registered user key
+        const targetKeys = Array.from(this.listeners.keys());
+        if (targetKeys.length === 0)
+            return;
+        // Poll until all keys are present in dataMap
+        // Use debounceMs as the polling cadence to avoid introducing new magic numbers
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const map = this.multiSubscriber.getAccountDataMap();
+            let allPresent = true;
+            for (const k of targetKeys) {
+                if (!map.has(k)) {
+                    allPresent = false;
+                    break;
+                }
+            }
+            if (allPresent)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, this.debounceMs));
+        }
+    }
+    forUser(userAccountPublicKey) {
+        if (this.userAccountSubscribers.has(userAccountPublicKey.toBase58())) {
+            return this.userAccountSubscribers.get(userAccountPublicKey.toBase58());
+        }
+        const key = userAccountPublicKey.toBase58();
+        const perUserEmitter = new events_1.EventEmitter();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const parent = this;
+        let isSubscribed = false;
+        const registerHandlerIfNeeded = async () => {
+            if (!this.listeners.has(key)) {
+                this.listeners.set(key, new Set());
+                this.keyToPk.set(key, userAccountPublicKey);
+                this.pendingAddKeys.add(key);
+                if (this.isMultiSubscribed) {
+                    // only schedule flush if already subscribed to the multi-subscriber
+                    this.scheduleFlush();
+                }
+            }
+        };
+        const perUser = {
+            get eventEmitter() {
+                return perUserEmitter;
+            },
+            set eventEmitter(_v) { },
+            get isSubscribed() {
+                return isSubscribed;
+            },
+            set isSubscribed(_v) {
+                isSubscribed = _v;
+            },
+            async subscribe(userAccount) {
+                if (isSubscribed)
+                    return true;
+                if (userAccount) {
+                    this.updateData(userAccount, 0);
+                }
+                await registerHandlerIfNeeded();
+                const setForKey = parent.listeners.get(key);
+                setForKey.add(perUserEmitter);
+                isSubscribed = true;
+                return true;
+            },
+            async fetch() {
+                if (!isSubscribed) {
+                    throw new types_1.NotSubscribedError('Must subscribe before fetching account updates');
+                }
+                const account = (await parent.program.account.user.fetch(userAccountPublicKey));
+                this.updateData(account, 0);
+            },
+            updateData(userAccount, slot) {
+                const existingData = parent.userData.get(key);
+                if (existingData && existingData.slot > slot) {
+                    return;
+                }
+                parent.userData.set(key, { data: userAccount, slot });
+                perUserEmitter.emit('userAccountUpdate', userAccount);
+                perUserEmitter.emit('update');
+            },
+            async unsubscribe() {
+                if (!isSubscribed)
+                    return;
+                const setForKey = parent.listeners.get(key);
+                if (setForKey) {
+                    setForKey.delete(perUserEmitter);
+                    if (setForKey.size === 0) {
+                        parent.listeners.delete(key);
+                        await parent.multiSubscriber.removeAccounts([userAccountPublicKey]);
+                        parent.userData.delete(key);
+                        parent.keyToPk.delete(key);
+                        parent.pendingAddKeys.delete(key);
+                    }
+                }
+                isSubscribed = false;
+            },
+            getUserAccountAndSlot() {
+                const das = parent.userData.get(key);
+                if (!das) {
+                    throw new types_1.NotSubscribedError('Must subscribe before getting user account data');
+                }
+                return das;
+            },
+        };
+        this.userAccountSubscribers.set(userAccountPublicKey.toBase58(), perUser);
+        return perUser;
+    }
+    scheduleFlush() {
+        if (this.debounceTimer)
+            return;
+        this.debounceTimer = setTimeout(() => {
+            void this.flushPending();
+        }, this.debounceMs);
+    }
+    async flushPending() {
+        const hasPending = this.pendingAddKeys.size > 0;
+        if (!hasPending) {
+            this.debounceTimer = undefined;
+            return;
+        }
+        const allPks = [];
+        for (const k of this.listeners.keys()) {
+            const pk = this.keyToPk.get(k);
+            if (pk)
+                allPks.push(pk);
+        }
+        if (allPks.length === 0) {
+            this.pendingAddKeys.clear();
+            this.debounceTimer = undefined;
+            return;
+        }
+        if (!this.isMultiSubscribed) {
+            await this.multiSubscriber.subscribe(allPks, this.handleAccountChange);
+            this.isMultiSubscribed = true;
+            await this.multiSubscriber.fetch();
+            for (const k of this.pendingAddKeys) {
+                const pk = this.keyToPk.get(k);
+                if (pk) {
+                    const data = this.multiSubscriber.getAccountData(k);
+                    if (data) {
+                        this.handleAccountChange(pk, data.data, { slot: data.slot }, undefined, undefined);
+                    }
+                }
+            }
+        }
+        else {
+            const ms = this.multiSubscriber;
+            for (const k of this.pendingAddKeys) {
+                ms.onChangeMap.set(k, (data, ctx, buffer, accountProps) => {
+                    this.multiSubscriber.setAccountData(k, data, ctx.slot);
+                    this.handleAccountChange(new web3_js_1.PublicKey(k), data, ctx, buffer, accountProps);
+                });
+            }
+            await this.multiSubscriber.addAccounts(allPks);
+        }
+        this.pendingAddKeys.clear();
+        this.debounceTimer = undefined;
+    }
+}
+exports.grpcMultiUserAccountSubscriber = grpcMultiUserAccountSubscriber;

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ResubOpts, GrpcConfigs } from './types';
+import { Context, MemcmpFilter, PublicKey } from '@solana/web3.js';
+import { VelocityProgram } from '../config';
+import { WebSocketProgramAccountSubscriber } from './webSocketProgramAccountSubscriber';
+export declare class grpcProgramAccountSubscriber<T> extends WebSocketProgramAccountSubscriber<T> {
+    private client;
+    private stream;
+    private commitmentLevel;
+    listenerId?: number;
+    private constructor();
+    static create<U>(grpcConfigs: GrpcConfigs, subscriptionName: string, accountDiscriminator: string, program: VelocityProgram, decodeBufferFn: (accountName: string, ix: Buffer) => U, options?: {
+        filters: MemcmpFilter[];
+    }, resubOpts?: ResubOpts): Promise<grpcProgramAccountSubscriber<U>>;
+    subscribe(onChange: (accountId: PublicKey, data: T, context: Context, buffer: Buffer) => void): Promise<void>;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}