@attocash/cli 0.1.0

package/dist/wallet/signing.js

@@ -0,0 +1,128 @@
+import { createRequire } from 'node:module';
+import { AttoMnemonic, AttoTransaction, attoAccountSend, attoAccountReceive, attoAccountOpen, attoAccountChange, privateKeyToSigner, toAttoIndex, toSeedAsync, } from '@attocash/commons-core';
+import { AttoNodeClientAsyncBuilder } from '@attocash/commons-node-remote';
+import { AttoWorkerAsyncBuilder } from '@attocash/commons-worker-remote';
+import { AttoError } from '../domain/errors.js';
+import { NodeReader } from '../network/reader.js';
+import { retryNetwork } from '../network/retry.js';
+// Ktor's Node transport calls require even when the package is imported as ESM.
+Object.assign(globalThis, { require: createRequire(import.meta.url) });
+export async function mnemonicSeed(phrase) {
+    const normalized = phrase.normalize('NFKD').trim().replace(/\s+/g, ' ');
+    try {
+        if (normalized.split(' ').length !== 24)
+            throw new Error();
+        return await toSeedAsync(await AttoMnemonic.fromPhrase(normalized));
+    }
+    catch {
+        throw new AttoError('INVALID_MNEMONIC', 'Enter a valid 24-word Atto mnemonic.');
+    }
+}
+export async function derivedSigner(seed, index) {
+    if (!Number.isSafeInteger(index) || index < 0 || index > 0x7fff_ffff) {
+        throw new AttoError('INVALID_INDEX', 'Key index must be between 0 and 2147483647.');
+    }
+    return privateKeyToSigner(await seed.toPrivateKey(toAttoIndex(index)));
+}
+export async function signingWallet(seed, index, settings, beforeSign, suppliedWorker, retry) {
+    const client = new AttoNodeClientAsyncBuilder(settings.nodeUrl).build();
+    const worker = suppliedWorker ?? new AttoWorkerAsyncBuilder(settings.workerUrl).cached(false).timeoutSeconds(60n).build();
+    let signer = await derivedSigner(seed, index);
+    const address = signer.address;
+    const found = await retryNetwork(() => client.accountByAddresses([address]), retry);
+    for (const value of found) {
+        if (value.address.value !== address.value)
+            throw new AttoError('ACCOUNT_MISMATCH', 'The node returned a different wallet account.');
+        if (value.network.name !== settings.network)
+            throw new AttoError('NETWORK_MISMATCH', 'Account network differs from the configured wallet network.');
+    }
+    if (found.length > 1)
+        throw new AttoError('ACCOUNT_MISMATCH', 'The node returned duplicate wallet accounts.');
+    let account = found[0];
+    let queue = Promise.resolve();
+    function requireIndex(value) {
+        if (value.toInt() !== index)
+            throw new AttoError('INVALID_INDEX', 'This signing operation belongs to a different account.');
+    }
+    function requireAccount() {
+        if (!account)
+            throw new AttoError('ACCOUNT_NOT_OPEN', 'Receive funds to open this account before sending.');
+        return account;
+    }
+    async function perform(build, timestamp) {
+        const previous = queue;
+        let release;
+        queue = new Promise(resolve => { release = resolve; });
+        await previous;
+        try {
+            if (!signer)
+                throw new AttoError('WALLET_CLOSED', 'This signing operation is closed.');
+            const update = build((timestamp ?? await retryNetwork(() => client.now(), retry)).toString());
+            const block = update.block;
+            if (block.address.value !== address.value)
+                throw new AttoError('ACCOUNT_MISMATCH', 'The constructed block belongs to a different wallet account.');
+            if (block.network.name !== settings.network)
+                throw new AttoError('NETWORK_MISMATCH', 'Account network differs from the configured wallet network.');
+            if (!block.isValid())
+                throw new AttoError('INVALID_TRANSACTION', 'The constructed transaction is invalid.');
+            await beforeSign(block);
+            const signature = await signer.signBlock(block);
+            const work = await retryNetwork(() => suppliedWorker ? suppliedWorker.workBlock(block, retry?.signal) : worker.workBlock(block), retry);
+            const transaction = new AttoTransaction(block, signature, work);
+            if (!await transaction.isValid())
+                throw new AttoError('INVALID_TRANSACTION', 'The signed transaction is invalid.');
+            let attempted = false;
+            await retryNetwork(async () => {
+                if (attempted) {
+                    const confirmed = await new NodeReader(settings).transaction(transaction.hash.toString(), retry?.signal);
+                    if (confirmed) {
+                        if (confirmed.hash.toString() !== transaction.hash.toString() || !await confirmed.isValid()) {
+                            throw new AttoError('INVALID_NODE_RESPONSE', 'The node returned a different or invalid transaction.');
+                        }
+                        return;
+                    }
+                }
+                // Approval may have changed while waiting for work or during backoff.
+                // Recheck that the journal still permits this exact block.
+                if (retry)
+                    await beforeSign(block);
+                if (retry?.signal.aborted)
+                    throw new AttoError('CANCELLED', 'Send cancelled.');
+                attempted = true;
+                await client.publish(transaction);
+            }, retry);
+            account = update.account;
+            return transaction;
+        }
+        finally {
+            release();
+        }
+    }
+    // Commons' wallet builder calls its private Kotlin worker interface directly.
+    // Compose its public block, signing, validation, and publication APIs so the
+    // persistent JS work cache has an explicit supported boundary.
+    const wallet = {
+        async sendByIndex(value, destination, amount, timestamp) {
+            requireIndex(value);
+            return perform(time => attoAccountSend(requireAccount(), destination, amount, time), timestamp);
+        },
+        async receive(receivable, representative, timestamp) {
+            if (receivable.receiverAddress.value !== address.value)
+                throw new AttoError('WRONG_RECEIVER', 'The payment belongs to a different address.');
+            return perform(time => {
+                if (account)
+                    return attoAccountReceive(account, receivable, time);
+                if (!representative)
+                    throw new AttoError('REPRESENTATIVE_REQUIRED', 'Choose a representative to open this account.');
+                return attoAccountOpen(representative, receivable, time);
+            }, timestamp);
+        },
+        async change(value, representative, timestamp) {
+            requireIndex(value);
+            return perform(time => attoAccountChange(requireAccount(), representative, time), timestamp);
+        },
+        async getAccountByIndex(value) { requireIndex(value); return account ?? null; },
+        close() { signer = undefined; },
+    };
+    return { wallet, client, address };
+}

package/dist/wallet/types.d.ts

@@ -0,0 +1,65 @@
+import type { PaymentMetadata } from '../spending/journal.js';
+export type NetworkName = 'LIVE' | 'BETA' | 'DEV' | 'LOCAL';
+export type AmountUnit = 'ATTO' | 'RAW';
+export interface SpendingRule {
+    days: number;
+    amount: string;
+    unit: AmountUnit;
+}
+export interface SpendingPolicy {
+    perRequest: {
+        amount: string;
+        unit: AmountUnit;
+    } | null;
+    rolling: SpendingRule[];
+}
+export interface AccountPool {
+    indexes: number[];
+    consolidate: boolean;
+}
+export interface WalletSettings {
+    network: NetworkName;
+    nodeUrl: string;
+    workerUrl: string;
+    representative: string;
+    autoReceive: boolean;
+    minReceiveRaw: string;
+}
+export interface WalletAddress {
+    index: number;
+    address: string;
+    publicKey: string;
+    active: boolean;
+}
+export interface WalletIdentity {
+    fingerprint: string;
+    address: string;
+}
+export type EventKind = 'account' | 'transaction' | 'entry' | 'receivable';
+export interface StreamFilter {
+    event: EventKind;
+    addresses?: string[];
+    hash?: string;
+    fromHeight?: string;
+    toHeight?: string;
+    minAmountRaw?: string;
+}
+export interface ListRequest extends StreamFilter {
+    limit?: number;
+    timeoutMs?: number;
+    cursor?: string;
+}
+export interface SendRequest {
+    index?: number;
+    destination?: string;
+    destinationLabel?: string;
+    amount: string;
+    unit?: AmountUnit | 'USD';
+    requestId: string;
+    metadata?: PaymentMetadata;
+}
+export interface ReceiveRequest {
+    index?: number;
+    hash: string;
+    representative?: string;
+}

package/dist/wallet/types.js

@@ -0,0 +1 @@
+export {};

package/dist/wallet/work.d.ts

@@ -0,0 +1,29 @@
+import { AttoAccount, AttoBlock, AttoWork } from '@attocash/commons-core';
+import type { StateStore } from '../storage/state.js';
+import type { WalletSettings } from './types.js';
+export interface BlockWorker {
+    workBlock(block: AttoBlock, signal?: AbortSignal): Promise<AttoWork>;
+    close(): void;
+}
+/** Public work only: no signer, mnemonic, or seed enters this owner. */
+export declare class WalletWork {
+    private readonly store;
+    private readonly settings;
+    private readonly queued;
+    private readonly pending;
+    private readonly requests;
+    private backgroundCount;
+    private closed;
+    constructor(store: StateStore, settings: () => WalletSettings);
+    isReady(account: AttoAccount): boolean;
+    prepare(accounts: readonly AttoAccount[]): void;
+    worker(): BlockWorker;
+    close(): Promise<void>;
+    private nextBlock;
+    private key;
+    private read;
+    private save;
+    private obtain;
+    private compute;
+    private drain;
+}

package/dist/wallet/work.js

@@ -0,0 +1,154 @@
+import { AttoInstant, AttoWork, attoAccountChange, attoBlockWorkTarget, } from '@attocash/commons-core';
+import { requestWork } from '../network/work.js';
+import { AttoError } from '../domain/errors.js';
+const BACKGROUND_LIMIT = 2;
+const QUEUE_LIMIT = 100;
+/** Public work only: no signer, mnemonic, or seed enters this owner. */
+export class WalletWork {
+    store;
+    settings;
+    queued = new Map();
+    pending = new Map();
+    requests = new Set();
+    backgroundCount = 0;
+    closed = false;
+    constructor(store, settings) {
+        this.store = store;
+        this.settings = settings;
+    }
+    isReady(account) {
+        if (this.closed || account.network.name !== this.settings().network)
+            return false;
+        return this.read(this.nextBlock(account)) !== undefined;
+    }
+    prepare(accounts) {
+        if (this.closed)
+            return;
+        for (const account of accounts) {
+            if (account.network.name !== this.settings().network)
+                continue;
+            const block = this.nextBlock(account);
+            if (this.read(block))
+                continue;
+            const key = this.key(block);
+            if (this.queued.size < QUEUE_LIMIT || this.queued.has(key))
+                this.queued.set(key, block);
+        }
+        this.drain();
+    }
+    worker() {
+        // A signing operation borrows this cache; only the application closes it.
+        return { workBlock: (block, signal) => this.obtain(block, false, signal), close() { } };
+    }
+    async close() {
+        this.closed = true;
+        this.queued.clear();
+        for (const request of this.requests)
+            request.abort();
+        await Promise.allSettled([...this.pending.values()].map(job => job.promise));
+    }
+    nextBlock(account) {
+        // Commons constructs the next-head target and validates its own work. This
+        // unsigned block is only a work request; it is never signed or published.
+        return attoAccountChange(account, account.representativeAddress, AttoInstant.Companion.now().toString()).block;
+    }
+    key(block) { return `work.${block.network.name}.${block.publicKey.toString()}`; }
+    read(block) {
+        try {
+            const record = this.store.get(this.key(block));
+            if (!record || record.target !== attoBlockWorkTarget(block) || !/^[0-9a-f]{16}$/i.test(record.work))
+                return;
+            const work = AttoWork.Companion.parse(record.work);
+            return work.isValid(block) ? work : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    save(block, work) {
+        if (this.closed || block.network.name !== this.settings().network)
+            return;
+        const key = this.key(block);
+        this.store.transaction(() => {
+            const prior = this.store.get(key);
+            // An older in-flight job must not displace work for a newer account head,
+            // including work another CLI/MCP process has already persisted.
+            if (prior && /^\d+$/.test(prior.height) && BigInt(prior.height) > BigInt(block.height.toString()))
+                return;
+            this.store.set(key, { target: attoBlockWorkTarget(block), height: block.height.toString(), work: work.toString() });
+        });
+    }
+    async obtain(block, speculative = false, signal) {
+        if (this.closed)
+            throw new AttoError('WORK_CLOSED', 'The wallet work cache is closed.');
+        const settings = this.settings();
+        if (block.network.name !== settings.network)
+            throw new AttoError('NETWORK_MISMATCH', 'Work must use the configured wallet network.');
+        const ready = this.read(block);
+        if (ready)
+            return ready;
+        const key = `${this.key(block)}.${attoBlockWorkTarget(block)}`;
+        const existing = this.pending.get(key);
+        if (existing) {
+            try {
+                const work = await existing.promise;
+                // A job begun before a threshold change may no longer satisfy this block.
+                if (work.isValid(block))
+                    return work;
+            }
+            catch (error) {
+                // Speculation has a shorter deadline. A real transaction retains the
+                // normal worker budget if that earlier background attempt failed.
+                if (speculative || !existing.speculative)
+                    throw error;
+            }
+        }
+        if (this.closed)
+            throw new AttoError('WORK_CLOSED', 'The wallet work cache is closed.');
+        const job = { promise: this.compute(block, settings.workerUrl, speculative ? 10 : 60, signal), speculative };
+        this.pending.set(key, job);
+        try {
+            return await job.promise;
+        }
+        finally {
+            if (this.pending.get(key) === job)
+                this.pending.delete(key);
+        }
+    }
+    async compute(block, url, timeoutSeconds, signal) {
+        const controller = new AbortController();
+        this.requests.add(controller);
+        const timer = setTimeout(() => controller.abort(), timeoutSeconds * 1000);
+        try {
+            const work = await requestWork(block, url, AbortSignal.any([controller.signal, ...(signal ? [signal] : [])]));
+            this.save(block, work);
+            return work;
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw new AttoError('CANCELLED', 'Send cancelled.');
+            if (this.closed)
+                throw new AttoError('WORK_CLOSED', 'The wallet work cache is closed.');
+            if (controller.signal.aborted)
+                throw new AttoError('WORK_TIMEOUT', 'Proof-of-work generation timed out.');
+            if (error instanceof AttoError)
+                throw error;
+            throw new AttoError('WORK_FAILED', 'Proof-of-work generation failed. Check the worker endpoint.');
+        }
+        finally {
+            clearTimeout(timer);
+            this.requests.delete(controller);
+        }
+    }
+    drain() {
+        while (!this.closed && this.backgroundCount < BACKGROUND_LIMIT && this.queued.size > 0) {
+            const [key, block] = this.queued.entries().next().value;
+            this.queued.delete(key);
+            this.backgroundCount++;
+            void this.obtain(block, true).catch(() => { }).finally(() => {
+                this.backgroundCount--;
+                this.drain();
+            });
+        }
+    }
+}

package/dist/watches/manager.d.ts

@@ -0,0 +1,75 @@
+import { NodeReader } from '../network/reader.js';
+import type { StreamFilter } from '../wallet/types.js';
+interface Checkpoints {
+    get<T>(key: string): T | undefined;
+    set(key: string, value: unknown): void;
+}
+interface WatchOptions {
+    backoffMs?: number;
+    maxBackoffMs?: number;
+    retention?: number;
+    maxWatches?: number;
+}
+/** Session watches retain events until read; acknowledged heights survive process restarts. */
+export declare class WatchManager {
+    private readonly reader;
+    private readonly checkpoints?;
+    private readonly watches;
+    private readonly backoffMs;
+    private readonly maxBackoffMs;
+    private readonly retention;
+    private readonly maxWatches;
+    private closed;
+    constructor(reader: NodeReader, checkpoints?: Checkpoints | undefined, options?: WatchOptions);
+    start(input: StreamFilter): {
+        lastError?: {
+            code: string;
+            message: string;
+        } | undefined;
+        id: string;
+        filter: StreamFilter;
+        status: "running" | "reconnecting" | "stopped" | "completed";
+        createdAt: string;
+        reconnects: number;
+        replayable: boolean;
+    };
+    list(): {
+        lastError?: {
+            code: string;
+            message: string;
+        } | undefined;
+        id: string;
+        filter: StreamFilter;
+        status: "running" | "reconnecting" | "stopped" | "completed";
+        createdAt: string;
+        reconnects: number;
+        replayable: boolean;
+    }[];
+    read(id: string, cursor?: number, limit?: number): {
+        events: {
+            cursor: number;
+            data: unknown;
+        }[];
+        nextCursor: number;
+        gapDetected: boolean;
+        oldestCursor: number;
+        latestCursor: number;
+        lastError?: {
+            code: string;
+            message: string;
+        } | undefined;
+        id: string;
+        filter: StreamFilter;
+        status: "running" | "reconnecting" | "stopped" | "completed";
+        createdAt: string;
+        reconnects: number;
+        replayable: boolean;
+    };
+    stop(id: string): Promise<void>;
+    close(): Promise<void>;
+    private get;
+    private describe;
+    private append;
+    private run;
+}
+export {};

package/dist/watches/manager.js

@@ -0,0 +1,197 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { AttoError, errorResult } from '../domain/errors.js';
+import { eventPosition, isReplayable, normalizeFilter, publicModel } from '../network/reader.js';
+function sleep(milliseconds, signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise(resolve => {
+        const finish = () => { clearTimeout(timer); signal.removeEventListener('abort', finish); resolve(); };
+        const timer = setTimeout(finish, milliseconds);
+        signal.addEventListener('abort', finish, { once: true });
+    });
+}
+/** Session watches retain events until read; acknowledged heights survive process restarts. */
+export class WatchManager {
+    reader;
+    checkpoints;
+    watches = new Map();
+    backoffMs;
+    maxBackoffMs;
+    retention;
+    maxWatches;
+    closed = false;
+    constructor(reader, checkpoints, options = {}) {
+        this.reader = reader;
+        this.checkpoints = checkpoints;
+        this.backoffMs = options.backoffMs ?? 1000;
+        this.maxBackoffMs = options.maxBackoffMs ?? 30_000;
+        this.retention = options.retention ?? 1000;
+        this.maxWatches = options.maxWatches ?? 32;
+        if (![this.backoffMs, this.maxBackoffMs, this.retention, this.maxWatches].every(value => Number.isInteger(value) && value > 0)) {
+            throw new AttoError('INVALID_WATCH_OPTIONS', 'Watch limits and backoff values must be positive integers.');
+        }
+    }
+    start(input) {
+        if (this.closed)
+            throw new AttoError('WATCH_MANAGER_CLOSED', 'This watch session has closed.');
+        if (this.watches.size >= this.maxWatches) {
+            const finished = [...this.watches.values()].find(watch => watch.status === 'stopped' || watch.status === 'completed');
+            if (finished)
+                this.watches.delete(finished.id);
+            else
+                throw new AttoError('WATCH_LIMIT', 'The session watch limit has been reached.');
+        }
+        const filter = normalizeFilter(input);
+        const checkpointKey = `watch:${createHash('sha256').update(JSON.stringify([this.reader.settings.nodeUrl, this.reader.settings.network, filter])).digest('hex')}`;
+        const stored = isReplayable(filter) ? this.checkpoints?.get(checkpointKey) : undefined;
+        const acknowledged = {};
+        for (const address of filter.addresses ?? []) {
+            const value = stored?.[address];
+            if (typeof value === 'string' && /^\d+$/.test(value) && BigInt(value) < 18446744073709551616n)
+                acknowledged[address] = value;
+        }
+        const watch = {
+            id: randomUUID(), filter, status: 'running', createdAt: new Date().toISOString(), reconnects: 0,
+            controller: new AbortController(), task: Promise.resolve(), events: [], sequence: 0,
+            acknowledged, observed: { ...acknowledged }, checkpointKey, seen: new Set(),
+        };
+        this.watches.set(watch.id, watch);
+        const filters = isReplayable(filter) ? filter.addresses.map(address => ({ ...filter, addresses: [address] })) : [filter];
+        watch.task = Promise.all(filters.map(part => this.run(watch, part))).then(() => {
+            if (!watch.controller.signal.aborted)
+                watch.status = 'completed';
+        });
+        return this.describe(watch);
+    }
+    list() { return [...this.watches.values()].map(watch => this.describe(watch)); }
+    read(id, cursor = 0, limit = 100) {
+        const watch = this.get(id);
+        if (!Number.isSafeInteger(cursor) || cursor < 0 || cursor > watch.sequence || !Number.isInteger(limit) || limit < 1 || limit > 1000) {
+            throw new AttoError('INVALID_WATCH_CURSOR', 'Use an existing nonnegative cursor and a limit from 1 to 1000.');
+        }
+        // A supplied cursor acknowledges a prior page. Saving on arrival would lose unread
+        // events when a process exits between receiving an event and returning its page.
+        let checkpointChanged = false;
+        for (const event of watch.events) {
+            if (event.cursor > cursor)
+                break;
+            const position = event.position;
+            if (position && BigInt(position.height) > BigInt(watch.acknowledged[position.address] ?? '0')) {
+                watch.acknowledged[position.address] = position.height;
+                checkpointChanged = true;
+            }
+        }
+        if (checkpointChanged)
+            this.checkpoints?.set(watch.checkpointKey, { ...watch.acknowledged });
+        const page = watch.events.filter(event => event.cursor > cursor).slice(0, limit);
+        const oldestCursor = watch.events[0]?.cursor ?? watch.sequence + 1;
+        return {
+            ...this.describe(watch),
+            events: page.map(({ cursor: eventCursor, data }) => ({ cursor: eventCursor, data })),
+            nextCursor: page.at(-1)?.cursor ?? cursor,
+            gapDetected: cursor < oldestCursor - 1 || page.some(event => event.gap),
+            oldestCursor,
+            latestCursor: watch.sequence,
+        };
+    }
+    async stop(id) {
+        const watch = this.get(id);
+        watch.status = 'stopped';
+        watch.controller.abort();
+        await watch.task;
+        // Keep buffered events readable after stopping; a new watch may replace the
+        // oldest finished watch when the session reaches its retention limit.
+    }
+    async close() {
+        this.closed = true;
+        await Promise.all([...this.watches.keys()].map(id => this.stop(id)));
+        this.watches.clear();
+    }
+    get(id) {
+        const watch = this.watches.get(id);
+        if (!watch)
+            throw new AttoError('WATCH_NOT_FOUND', 'The watch does not exist in this session.');
+        return watch;
+    }
+    describe(watch) {
+        return {
+            id: watch.id, filter: watch.filter, status: watch.status, createdAt: watch.createdAt,
+            reconnects: watch.reconnects, replayable: isReplayable(watch.filter),
+            ...(watch.lastError ? { lastError: watch.lastError } : {}),
+        };
+    }
+    append(watch, data, position, gap = false) {
+        watch.events.push({ cursor: ++watch.sequence, data, ...(position ? { position } : {}), ...(gap ? { gap } : {}) });
+        if (watch.events.length > this.retention)
+            watch.events.splice(0, watch.events.length - this.retention);
+    }
+    async run(watch, original) {
+        const signal = watch.controller.signal;
+        const replayable = isReplayable(original);
+        const address = original.addresses?.[0];
+        let delay = this.backoffMs;
+        while (!signal.aborted) {
+            let filter = original;
+            if (replayable && address) {
+                const next = BigInt(watch.observed[address] ?? (BigInt(original.fromHeight ?? '1') - 1n).toString()) + 1n;
+                const from = next < BigInt(original.fromHeight ?? '1') ? BigInt(original.fromHeight ?? '1') : next;
+                if (from > BigInt(original.toHeight ?? '18446744073709551615'))
+                    return;
+                filter = { ...original, fromHeight: from.toString() };
+                watch.observed[address] = (from - 1n).toString();
+            }
+            try {
+                watch.status = 'running';
+                await this.reader.stream(filter, model => {
+                    if (signal.aborted)
+                        return;
+                    const position = replayable ? eventPosition(model) : undefined;
+                    if (replayable) {
+                        if (!position || position.address !== address)
+                            throw new AttoError('INVALID_NODE_RESPONSE', 'The node returned an event for a different watched account.');
+                        const last = BigInt(watch.observed[address] ?? (BigInt(filter.fromHeight) - 1n).toString());
+                        if (BigInt(position.height) <= last)
+                            return;
+                        if (BigInt(position.height) !== last + 1n || (filter.toHeight && BigInt(position.height) > BigInt(filter.toHeight))) {
+                            throw new AttoError('HISTORY_GAP', 'The node returned a gap in watched account history.');
+                        }
+                    }
+                    const data = publicModel(model);
+                    if (!replayable) {
+                        const identity = createHash('sha256').update(JSON.stringify(data)).digest('hex');
+                        if (watch.seen.has(identity))
+                            return;
+                        watch.seen.add(identity);
+                        if (watch.seen.size > this.retention)
+                            watch.seen.delete(watch.seen.values().next().value);
+                    }
+                    this.append(watch, data, position);
+                    if (position)
+                        watch.observed[position.address] = position.height;
+                    delay = this.backoffMs;
+                    watch.status = 'running';
+                    delete watch.lastError;
+                }, signal);
+                if (signal.aborted)
+                    return;
+                if (replayable && address && original.toHeight && BigInt(watch.observed[address] ?? '0') >= BigInt(original.toHeight))
+                    return;
+                if (original.hash && watch.events.some(event => !event.gap))
+                    return;
+                watch.lastError = { code: 'STREAM_CLOSED', message: 'The node closed the stream; reconnecting.' };
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                const safe = errorResult(error);
+                watch.lastError = { code: safe.code, message: safe.message };
+            }
+            watch.status = 'reconnecting';
+            watch.reconnects++;
+            if (!replayable)
+                this.append(watch, { type: 'gap', reason: 'disconnected', replayable: false }, undefined, true);
+            await sleep(delay, signal);
+            delay = Math.min(delay * 2, this.maxBackoffMs);
+        }
+    }
+}