@usearete/sdk 0.21.0 → 0.22.1

package/dist/index.esm.js

@@ -8,6 +8,17 @@ const DEFAULT_CONFIG = {
     maxReconnectAttempts: 5,
     maxEntriesPerView: DEFAULT_MAX_ENTRIES_PER_VIEW,
 };
+const REPLAY_ERROR_CODES = {
+    'cursor-expired': true,
+    'cursor-epoch-changed': true,
+    'cursor-unknown': true,
+    'invalid-cursor': true,
+    'replay-gap': true,
+    'replay-lagged': true,
+};
+function isReplayErrorCode(code) {
+    return REPLAY_ERROR_CODES[code] === true;
+}
 /**
  * Determines if the error indicates the client should fetch a new token
  */
@@ -30,7 +41,9 @@ class AreteError extends Error {
     }
 }
 /**
- * Parse a kebab-case error code string (from X-Error-Code header) to AuthErrorCode
+ * Parse a kebab-case error code string (from X-Error-Code header) to AuthErrorCode.
+ * Replay refusals keep their wire code: each needs a different recovery, so
+ * collapsing them into a generic failure would destroy the only distinction.
  */
 function parseErrorCode(errorCode) {
     const codeMap = {
@@ -63,7 +76,10 @@ function parseErrorCode(errorCode) {
         'deployment-access-denied': 'DEPLOYMENT_ACCESS_DENIED',
         'quota-exceeded': 'QUOTA_EXCEEDED',
     };
-    return codeMap[errorCode.toLowerCase()] || 'INTERNAL_ERROR';
+    const normalized = errorCode.toLowerCase();
+    if (isReplayErrorCode(normalized))
+        return normalized;
+    return codeMap[normalized] || 'INTERNAL_ERROR';
 }
 
 const GZIP_MAGIC_0 = 0x1f;
@@ -96,6 +112,17 @@ function isSubscriptionId(value) {
 function isMode(value) {
     return typeof value === 'string' && FRAME_MODES.has(value);
 }
+function isOffset(value) {
+    return Number.isInteger(value) && value >= 0;
+}
+function isReplayWindow(value) {
+    return isRecord(value)
+        && typeof value['epoch'] === 'string'
+        && value['epoch'].length > 0
+        && isOffset(value['earliest'])
+        && isOffset(value['next'])
+        && (value['gapAfter'] === undefined || isOffset(value['gapAfter']));
+}
 function isSort(value) {
     if (!isRecord(value))
         return false;
@@ -170,7 +197,9 @@ function isValidFrame(frame) {
             && typeof frame['fatal'] === 'boolean'
             && (frame['message'] === undefined || typeof frame['message'] === 'string')
             && (frame['error'] === undefined || typeof frame['error'] === 'string')
-            && (frame['retryable'] === undefined || typeof frame['retryable'] === 'boolean');
+            && (frame['retryable'] === undefined || typeof frame['retryable'] === 'boolean')
+            && (frame['replayWindow'] === undefined || isReplayWindow(frame['replayWindow']))
+            && (frame['recoverFrom'] === undefined || typeof frame['recoverFrom'] === 'string');
     }
     if (!hasV2Identity(frame) || typeof frame['op'] !== 'string')
         return false;
@@ -179,7 +208,8 @@ function isValidFrame(frame) {
     if (frame['op'] === 'subscribed') {
         return isQuery(frame['query'])
             && isMode(frame['mode'])
-            && (frame['sort'] === undefined || isSort(frame['sort']));
+            && (frame['sort'] === undefined || isSort(frame['sort']))
+            && (frame['replayWindow'] === undefined || isReplayWindow(frame['replayWindow']));
     }
     if (!isMode(frame['mode']) || typeof frame['entity'] !== 'string')
         return false;
@@ -196,10 +226,49 @@ function isValidFrame(frame) {
         && typeof frame['key'] === 'string'
         && 'data' in frame
         && (frame['seq'] === undefined || typeof frame['seq'] === 'string')
+        && (frame['offset'] === undefined || isOffset(frame['offset']))
         && (frame['append'] === undefined
             || (Array.isArray(frame['append'])
                 && frame['append'].every((entry) => typeof entry === 'string')));
 }
+/**
+ * Builds the `{epoch}:{offset}` cursor a consumer stores and sends back as
+ * `query.after`. An offset only means something inside the epoch the
+ * acknowledgement named, so the epoch has to be carried across frames.
+ */
+class CursorTracker {
+    constructor() {
+        this.epochs = new Map();
+        this.cursors = new Map();
+    }
+    /** Records the frame and returns the cursor it carries, if any. */
+    observe(frame) {
+        if (isSubscribedFrame(frame)) {
+            const epoch = frame.replayWindow?.epoch;
+            if (epoch === undefined)
+                this.epochs.delete(frame.subscriptionId);
+            else
+                this.epochs.set(frame.subscriptionId, epoch);
+            return undefined;
+        }
+        if (!isEntityFrame(frame) || frame.offset === undefined)
+            return undefined;
+        const epoch = this.epochs.get(frame.subscriptionId);
+        if (epoch === undefined)
+            return undefined;
+        const cursor = `${epoch}:${frame.offset}`;
+        this.cursors.set(frame.subscriptionId, cursor);
+        return cursor;
+    }
+    /** The last cursor delivered on a subscription, for resuming after a drop. */
+    last(subscriptionId) {
+        return this.cursors.get(subscriptionId);
+    }
+    forget(subscriptionId) {
+        this.epochs.delete(subscriptionId);
+        this.cursors.delete(subscriptionId);
+    }
+}
 
 let fallbackId = 0;
 const QUERY_FIELDS = new Set([
@@ -444,6 +513,7 @@ class SubscriptionRegistry {
             onChange: (callback) => this.queryStore.onChange(subscriptionId, callback),
             onUpdate: (callback) => this.queryStore.onUpdate(subscriptionId, callback),
             onRichUpdate: (callback) => this.queryStore.onRichUpdate(subscriptionId, callback),
+            getError: () => this.queryStore.getError(subscriptionId),
             refresh: () => this.refreshTracker(tracker),
             release: () => {
                 if (released)
@@ -705,6 +775,12 @@ class ConnectionManager {
         this.currentState = 'disconnected';
         this.subscriptionQueue = new Map();
         this.activeSubscriptions = new Map();
+        /**
+         * Replay positions per subscription. Shared with the frame processor rather
+         * than duplicated: both observe the same frame stream, and this one is
+         * pruned on unsubscribe, so the processor gets that pruning for free.
+         */
+        this.cursors = new CursorTracker();
         this.socketGeneration = 0;
         this.pendingConnect = null;
         this.frameHandlers = new Set();
@@ -1516,6 +1592,7 @@ class ConnectionManager {
     }
     unsubscribe(subscriptionId) {
         this.subscriptionQueue.delete(subscriptionId);
+        this.cursors.forget(subscriptionId);
         if (this.activeSubscriptions.has(subscriptionId)) {
             this.activeSubscriptions.delete(subscriptionId);
             if (this.ws?.readyState === WebSocket.OPEN) {
@@ -1560,9 +1637,14 @@ class ConnectionManager {
     }
     resubscribeActive() {
         for (const subscription of this.activeSubscriptions.values()) {
-            if (this.ws?.readyState === WebSocket.OPEN) {
-                this.ws.send(JSON.stringify(subscription));
-            }
+            if (this.ws?.readyState !== WebSocket.OPEN)
+                continue;
+            // Re-sending the original `after` would replay what was already
+            // delivered; sending none would skip whatever the drop cost us.
+            const after = this.cursors.last(subscription.subscriptionId);
+            this.ws.send(JSON.stringify(after === undefined
+                ? subscription
+                : { ...subscription, query: { ...subscription.query, after } }));
         }
     }
     addQueuedSubscription(subscription) {
@@ -1583,6 +1665,7 @@ class ConnectionManager {
         }
     }
     notifyFrameHandlers(frame) {
+        this.cursors.observe(frame);
         for (const handler of this.frameHandlers) {
             handler(frame);
         }
@@ -1704,12 +1787,23 @@ function toCamelCaseSegment(value) {
     return pascal[0].toLowerCase() + pascal.slice(1);
 }
 class FrameProcessor {
+    /**
+     * Observe the connection's cursor tracker instead of a private one.
+     *
+     * The connection prunes on unsubscribe; this processor never sees an
+     * `unsubscribed` frame, so its own tracker would grow for the life of the
+     * page as a React app mounts and unmounts components with different queries.
+     */
+    useCursorTracker(cursors) {
+        this.cursors = cursors;
+    }
     constructor(storage, config = {}) {
         this.pendingUpdates = [];
         this.flushTimer = null;
         this.isProcessing = false;
         this.latestProcessedSlot = null;
         this.processedSlotWaiters = new Set();
+        this.cursors = new CursorTracker();
         this.storage = storage;
         this.maxEntriesPerView = config.maxEntriesPerView === undefined
             ? DEFAULT_MAX_ENTRIES_PER_VIEW
@@ -2054,6 +2148,7 @@ class FrameProcessor {
         return null;
     }
     handleSubscribedFrame(frame) {
+        this.cursors.observe(frame);
         const viewPath = frame.query.view;
         if (this.storage.setViewConfig && frame.sort) {
             this.storage.setViewConfig(viewPath, {
@@ -2099,7 +2194,11 @@ class FrameProcessor {
         const viewPath = frame.entity;
         const previousValue = this.storage.get(viewPath, frame.key);
         const previousSequence = this.getInternalSeq(previousValue);
-        const duplicateOrStaleSequence = frame.seq !== undefined
+        const cursor = this.cursors.observe(frame);
+        // On a tape the offset is the identity: two events decoded from one
+        // transaction share a seq, so the seq guard would discard the second.
+        const duplicateOrStaleSequence = frame.offset === undefined
+            && frame.seq !== undefined
             && previousSequence !== undefined
             && this.compareSeq(frame.seq, previousSequence) <= 0;
         switch (frame.op) {
@@ -2136,9 +2235,10 @@ class FrameProcessor {
                         type: 'upsert',
                         key: frame.key,
                         data: nextValue,
+                        cursor,
                     };
                     this.storage.notifyUpdate(viewPath, frame.key, update);
-                    const richUpdate = this.createRichUpdate(frame.key, previousValue, nextValue);
+                    const richUpdate = this.createRichUpdate(frame.key, previousValue, nextValue, undefined, cursor);
                     this.storage.notifyRichUpdate(viewPath, frame.key, richUpdate);
                     this.queryStore?.applyLive(frame.subscriptionId, frame.key, update, richUpdate, frame.seq ?? this.extractSeq(frame.data));
                     break;
@@ -2174,27 +2274,34 @@ class FrameProcessor {
                     type: 'patch',
                     key: frame.key,
                     data: normalizedPatch,
+                    cursor,
                 };
                 this.storage.notifyUpdate(viewPath, frame.key, update);
-                const richUpdate = this.createRichUpdate(frame.key, previousValue, nextValue, normalizedPatch);
+                const richUpdate = this.createRichUpdate(frame.key, previousValue, nextValue, normalizedPatch, cursor);
                 this.storage.notifyRichUpdate(viewPath, frame.key, richUpdate);
                 this.queryStore?.applyLive(frame.subscriptionId, frame.key, update, richUpdate, frame.seq ?? this.extractSeq(frame.data));
                 break;
             }
             case 'remove':
-                this.queryStore?.applyLive(frame.subscriptionId, frame.key, { type: 'remove', key: frame.key });
+                this.queryStore?.applyLive(frame.subscriptionId, frame.key, { type: 'remove', key: frame.key, cursor });
                 break;
             case 'delete':
                 this.storage.delete(viewPath, frame.key);
                 this.storage.notifyUpdate(viewPath, frame.key, {
                     type: 'delete',
                     key: frame.key,
+                    cursor,
                 });
                 if (previousValue !== null) {
-                    const richUpdate = { type: 'deleted', key: frame.key, lastKnown: previousValue };
+                    const richUpdate = {
+                        type: 'deleted',
+                        key: frame.key,
+                        lastKnown: previousValue,
+                        cursor,
+                    };
                     this.storage.notifyRichUpdate(viewPath, frame.key, richUpdate);
                 }
-                this.queryStore?.deleteGlobal(viewPath, frame.key, previousValue ?? undefined);
+                this.queryStore?.deleteGlobal(viewPath, frame.key, previousValue ?? undefined, frame.subscriptionId, cursor);
                 break;
         }
     }
@@ -2204,10 +2311,10 @@ class FrameProcessor {
             : { type: 'updated', key, before, after, patch };
         this.storage.notifyRichUpdate(viewPath, key, richUpdate);
     }
-    createRichUpdate(key, before, after, patch) {
+    createRichUpdate(key, before, after, patch, cursor) {
         return before === null
-            ? { type: 'created', key, data: after }
-            : { type: 'updated', key, before, after, patch };
+            ? { type: 'created', key, data: after, cursor }
+            : { type: 'updated', key, before, after, patch, cursor };
     }
     enforceMaxEntries(viewPath) {
         if (this.maxEntriesPerView === null)
@@ -2645,6 +2752,10 @@ class QueryStore {
     getQueryKey(subscriptionId) {
         return this.records.get(subscriptionId)?.queryKey;
     }
+    /** The current failure without rebuilding the snapshot's data. */
+    getError(subscriptionId) {
+        return this.records.get(subscriptionId)?.error;
+    }
     getSnapshot(subscriptionId) {
         const record = this.records.get(subscriptionId);
         if (!record)
@@ -2663,6 +2774,7 @@ class QueryStore {
             data,
             isLoading: record.isLoading,
             isRefreshing: record.isRefreshing,
+            ...(record.cursor ? { cursor: record.cursor } : {}),
             ...(record.error ? { error: record.error } : {}),
         };
         record.cachedSnapshot = snapshot;
@@ -2758,13 +2870,15 @@ class QueryStore {
         const record = this.records.get(subscriptionId);
         if (!record)
             return;
+        if (update.cursor !== undefined)
+            record.cursor = update.cursor;
         if (update.type === 'remove') {
             const lastKnown = this.storage.get(record.subscription.query.view, key) ?? undefined;
             record.keys = record.keys.filter((entry) => entry !== key);
             record.sequences.delete(key);
             this.touch(record);
             this.emitUpdate(record, update);
-            this.emitRichUpdate(record, { type: 'removed', key, lastKnown });
+            this.emitRichUpdate(record, { type: 'removed', key, lastKnown, cursor: update.cursor });
             return;
         }
         if (!record.keys.includes(key))
@@ -2783,15 +2897,22 @@ class QueryStore {
         if (richUpdate)
             this.emitRichUpdate(record, richUpdate);
     }
-    deleteGlobal(view, key, lastKnown) {
+    deleteGlobal(view, key, lastKnown, subscriptionId, cursor) {
         for (const record of this.records.values()) {
             if (record.subscription.query.view !== view || !record.keys.includes(key))
                 continue;
             record.keys = record.keys.filter((entry) => entry !== key);
             record.sequences.delete(key);
+            // A delete fans out to every subscription on the view, but only the one
+            // the frame named read it at this offset. Handing the position to the
+            // others would let a consumer still replaying checkpoint past events it
+            // has not been given.
+            const owned = cursor !== undefined && record.subscription.subscriptionId === subscriptionId;
+            if (owned)
+                record.cursor = cursor;
             this.touch(record);
-            this.emitUpdate(record, { type: 'delete', key });
-            this.emitRichUpdate(record, { type: 'deleted', key, lastKnown });
+            this.emitUpdate(record, owned ? { type: 'delete', key, cursor } : { type: 'delete', key });
+            this.emitRichUpdate(record, owned ? { type: 'deleted', key, lastKnown, cursor } : { type: 'deleted', key, lastKnown });
         }
     }
     evict(view, key) {
@@ -2932,43 +3053,112 @@ class QueryStore {
 }
 
 const MAX_QUEUE_SIZE = 1000;
-function enqueue(queue, value) {
-    if (queue.length >= MAX_QUEUE_SIZE)
-        queue.shift();
-    queue.push(value);
+/**
+ * A replayable record was dropped locally before the consumer read it.
+ * `cursor` is the last one delivered, so the stream can be resumed from it
+ * with `after` rather than silently skipping the lost records.
+ */
+class StreamGapError extends AreteError {
+    constructor(cursor) {
+        super(`Update stream dropped a replayable record; resume after ${cursor ?? 'the start of the window'}`, 'stream-gap', { cursor });
+        this.cursor = cursor;
+        this.name = 'StreamGapError';
+    }
+}
+/** Terminate the stream when a replay refusal makes further delivery impossible. */
+function watchRefusals(lease, fail) {
+    return lease.onChange(() => {
+        const error = lease.getError();
+        if (error && isReplayErrorCode(String(error.code)))
+            fail(error);
+    });
 }
 function createIterator(start) {
     const queue = [];
-    let waitingResolve = null;
+    let waiting = null;
     let done = false;
-    const push = (value) => {
-        if (waitingResolve) {
-            const resolve = waitingResolve;
-            waitingResolve = null;
-            resolve({ value, done: false });
-        }
-        else {
-            enqueue(queue, value);
-        }
-    };
-    const stop = start(push);
+    let failure = null;
+    let lastCursor;
+    let stop = () => { };
     const cleanup = () => {
         if (done)
             return;
         done = true;
         stop();
-        waitingResolve?.({ value: undefined, done: true });
-        waitingResolve = null;
+        waiting?.resolve({ value: undefined, done: true });
+        waiting = null;
+    };
+    const deliver = (item) => {
+        if (item.cursor !== undefined)
+            lastCursor = item.cursor;
+        return { value: item.value, done: false };
+    };
+    /**
+     * End the stream at `error`, after whatever is already queued.
+     *
+     * `discardQueued` is for a local overflow only: there the hole is at the
+     * front of the queue, so everything behind it is no longer contiguous with
+     * what the consumer has read. A server refusal is the opposite — it reports
+     * records skipped *after* everything already sent, so the queue is real data
+     * that arrived before the gap. Dropping it would lose records the consumer
+     * was never told about and leave `recoverFrom` pointing past them.
+     */
+    const fail = (error, discardQueued = false) => {
+        if (done || failure)
+            return;
+        failure = error;
+        if (discardQueued)
+            queue.length = 0;
+        const pending = waiting;
+        waiting = null;
+        // A waiter means the queue was empty, so there is nothing to drain first.
+        if (pending && queue.length === 0) {
+            failure = null;
+            cleanup();
+            pending.reject(error);
+            return;
+        }
+        if (pending) {
+            const item = queue.shift();
+            pending.resolve(deliver(item));
+        }
     };
+    const push = (value, cursor) => {
+        if (done || failure)
+            return;
+        if (waiting) {
+            const pending = waiting;
+            waiting = null;
+            pending.resolve(deliver({ value, cursor }));
+            return;
+        }
+        if (queue.length >= MAX_QUEUE_SIZE) {
+            const dropped = queue.shift();
+            if (dropped?.cursor !== undefined) {
+                fail(new StreamGapError(lastCursor), true);
+                return;
+            }
+        }
+        queue.push({ value, cursor });
+    };
+    stop = start(push, fail);
+    if (done)
+        stop();
     return {
         async next() {
+            const item = queue.shift();
+            if (item !== undefined)
+                return deliver(item);
+            if (failure) {
+                const error = failure;
+                failure = null;
+                cleanup();
+                throw error;
+            }
             if (done)
                 return { value: undefined, done: true };
-            const value = queue.shift();
-            if (value !== undefined)
-                return { value, done: false };
-            return new Promise((resolve) => {
-                waitingResolve = resolve;
+            return new Promise((resolve, reject) => {
+                waiting = { resolve, reject };
             });
         },
         async return() {
@@ -2987,14 +3177,16 @@ function acquire(registry, query, snapshotEnabled) {
 function createUpdateStream(_storage, subscriptionRegistry, query, keyFilter, snapshotEnabled = true) {
     return {
         [Symbol.asyncIterator]() {
-            return createIterator((push) => {
+            return createIterator((push, fail) => {
                 const lease = acquire(subscriptionRegistry, query, snapshotEnabled);
                 const unsubscribe = lease.onUpdate((update) => {
                     if (keyFilter === undefined || update.key === keyFilter)
-                        push(update);
+                        push(update, update.cursor);
                 });
+                const stopRefusals = watchRefusals(lease, fail);
                 return () => {
                     unsubscribe();
+                    stopRefusals();
                     lease.release();
                 };
             });
@@ -3005,16 +3197,16 @@ function createEntityStream(_storage, subscriptionRegistry, query, options, keyF
     const schema = options?.schema;
     return {
         [Symbol.asyncIterator]() {
-            return createIterator((push) => {
+            return createIterator((push, fail) => {
                 const lease = acquire(subscriptionRegistry, query, options?.withSnapshot ?? true);
-                const emit = (entity) => {
+                const emit = (entity, cursor) => {
                     if (!schema) {
-                        push(entity);
+                        push(entity, cursor);
                         return;
                     }
                     const parsed = schema.safeParse(entity);
                     if (parsed.success)
-                        push(parsed.data);
+                        push(parsed.data, cursor);
                 };
                 for (const [index, entity] of lease.getSnapshot().data.entries()) {
                     const key = lease.getSnapshot().keys[index];
@@ -3025,12 +3217,14 @@ function createEntityStream(_storage, subscriptionRegistry, query, options, keyF
                     if (keyFilter !== undefined && update.key !== keyFilter)
                         return;
                     if (update.type === 'created')
-                        emit(update.data);
+                        emit(update.data, update.cursor);
                     if (update.type === 'updated')
-                        emit(update.after);
+                        emit(update.after, update.cursor);
                 });
+                const stopRefusals = watchRefusals(lease, fail);
                 return () => {
                     unsubscribe();
+                    stopRefusals();
                     lease.release();
                 };
             });
@@ -3040,14 +3234,16 @@ function createEntityStream(_storage, subscriptionRegistry, query, options, keyF
 function createRichUpdateStream(_storage, subscriptionRegistry, query, keyFilter, snapshotEnabled = true) {
     return {
         [Symbol.asyncIterator]() {
-            return createIterator((push) => {
+            return createIterator((push, fail) => {
                 const lease = acquire(subscriptionRegistry, query, snapshotEnabled);
                 const unsubscribe = lease.onRichUpdate((update) => {
                     if (keyFilter === undefined || update.key === keyFilter)
-                        push(update);
+                        push(update, update.cursor);
                 });
+                const stopRefusals = watchRefusals(lease, fail);
                 return () => {
                     unsubscribe();
+                    stopRefusals();
                     lease.release();
                 };
             });
@@ -6835,6 +7031,7 @@ let Arete$1 = class Arete {
             auth: options.auth,
             fetch: this.fetchImpl,
         });
+        this.processor.useCursorTracker(this.connection.cursors);
         this.subscriptionRegistry = new SubscriptionRegistry(this.connection, this.queryStore);
         this.connection.onFrame((frame) => {
             this.processor.handleFrame(frame);
@@ -7726,5 +7923,5 @@ function stringifyBigints(value) {
 
 const Arete = Object.assign(Arete$1, { session: createSession });
 
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OPERATION_KIND, OperationCallbackError, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ProcessedSlotTimeoutError, QueryStore, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, TRANSACTION_RESOURCE_OPTION_KEYS, TransactionExecutionError, TransactionOptionsError, TransactionTransportError, account, appendFlowTransactions, appendTransactionInstructions, applyConnectedStackExtensions, arg, buildInstruction, bytes, canonicalQueryKey, chainAccountLoader, createChainClient, createEntityStream, createHostedSolanaGatewayTransports, createInstructionExecutor, createInstructionHandler, createPreparedFlow, createPreparedInstruction, createPreparedTransaction, createPreparedTransactionBody, createProgramPdas, createPublicKeySeed, createRichUpdateStream, createSeed, createSession, createSignerRegistry, createSubscriptionId, createTransactionTransport, createTypedListView, createTypedStateView, createTypedViews, createUpdateStream, decodeBase58, defineProgramExtensions, defineStackExtensions, deriveAssociatedTokenAccount, deriveHttpEndpoint, findProgramAddress as derivePda, describePreparedOperation, encodeBase58, executeInstruction, executePreparedOperation, extendProgram, extendPrograms, extendStack, findProgramAddress, findProgramAddressSync, flowOperation, formatPreparedOperation, formatProgramError, formatRawToUi, getMintDecimals, getOperationKind, getProgramRuntimeExtensions, getStackRuntimeExtensions, getTransactionFailureOutcome, hostedWebsocketSuffixes, inspectPreparedOperation, instructionOperation, isEntityFrame, isErrorFrame, isHostedAreteEndpoint, isSnapshotFrame, isSubscribedFrame, isUnsubscribedFrame, isValidFrame, literal, normalizeSubscription, normalizeSubscriptionQuery, normalizeSubscriptionRequest, normalizeTransactionError, parseFrame, parseFrameFromBlob, parseInstructionError, parseUiAmountToRaw, pda, prependFlowTransactionInstructions, prependTransactionInstructions, programAccountRead, programQuery, resolveAccounts, resolveAmount, resolveAmountToRaw, resolveAmountsToRaw, resolveTokenProgramAddress, resolveTransactionBuildOptions, safeToRawAmount, serializeInstructionData, serializeViewKey, setHostedWebsocketSuffixes, stackQuery, stringifyBigints, toJsonValue, toRawAmount, toWireResourceOptions, transactionOperation, unwrapOperationExecutionError, validateAccountResolution, validateProgramReadDescriptor, validateSubscriptionId, withProgramRead, withPrograms };
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OPERATION_KIND, OperationCallbackError, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ProcessedSlotTimeoutError, QueryStore, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, StreamGapError, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, TRANSACTION_RESOURCE_OPTION_KEYS, TransactionExecutionError, TransactionOptionsError, TransactionTransportError, account, appendFlowTransactions, appendTransactionInstructions, applyConnectedStackExtensions, arg, buildInstruction, bytes, canonicalQueryKey, chainAccountLoader, createChainClient, createEntityStream, createHostedSolanaGatewayTransports, createInstructionExecutor, createInstructionHandler, createPreparedFlow, createPreparedInstruction, createPreparedTransaction, createPreparedTransactionBody, createProgramPdas, createPublicKeySeed, createRichUpdateStream, createSeed, createSession, createSignerRegistry, createSubscriptionId, createTransactionTransport, createTypedListView, createTypedStateView, createTypedViews, createUpdateStream, decodeBase58, defineProgramExtensions, defineStackExtensions, deriveAssociatedTokenAccount, deriveHttpEndpoint, findProgramAddress as derivePda, describePreparedOperation, encodeBase58, executeInstruction, executePreparedOperation, extendProgram, extendPrograms, extendStack, findProgramAddress, findProgramAddressSync, flowOperation, formatPreparedOperation, formatProgramError, formatRawToUi, getMintDecimals, getOperationKind, getProgramRuntimeExtensions, getStackRuntimeExtensions, getTransactionFailureOutcome, hostedWebsocketSuffixes, inspectPreparedOperation, instructionOperation, isEntityFrame, isErrorFrame, isHostedAreteEndpoint, isReplayErrorCode, isSnapshotFrame, isSubscribedFrame, isUnsubscribedFrame, isValidFrame, literal, normalizeSubscription, normalizeSubscriptionQuery, normalizeSubscriptionRequest, normalizeTransactionError, parseFrame, parseFrameFromBlob, parseInstructionError, parseUiAmountToRaw, pda, prependFlowTransactionInstructions, prependTransactionInstructions, programAccountRead, programQuery, resolveAccounts, resolveAmount, resolveAmountToRaw, resolveAmountsToRaw, resolveTokenProgramAddress, resolveTransactionBuildOptions, safeToRawAmount, serializeInstructionData, serializeViewKey, setHostedWebsocketSuffixes, stackQuery, stringifyBigints, toJsonValue, toRawAmount, toWireResourceOptions, transactionOperation, unwrapOperationExecutionError, validateAccountResolution, validateProgramReadDescriptor, validateSubscriptionId, withProgramRead, withPrograms };
 //# sourceMappingURL=index.esm.js.map