@intent-engine/cli 0.1.22 → 0.1.26

package/dist/src/transport.d.ts

@@ -1,208 +0,0 @@
-import { type Address, type Base64EncodedWireTransaction, type Blockhash, type Instruction, type Signature, type TransactionSigner } from "@solana/kit";
-export type AccountView = {
-    owner: Address;
-    data: Uint8Array;
-    lamports: bigint;
-    executable?: boolean;
-};
-export type ProgramAccount = {
-    address: Address;
-    data: Uint8Array;
-};
-export type EngineTransaction = {
-    signature: string;
-    slot: bigint;
-    blockTime: bigint | null;
-    failed: boolean;
-    emitted: Uint8Array[];
-    memos?: string[];
-    unread?: true;
-};
-export type Latest = {
-    blockhash: Blockhash;
-    lastValidBlockHeight: bigint;
-};
-export type Simulation = {
-    err: string | null;
-    logs: string[];
-    unitsConsumed: bigint | null;
-    accounts: (Uint8Array | null)[];
-};
-export interface Transport {
-    getAccount(address: Address): Promise<AccountView | null>;
-    getAccounts(addresses: readonly Address[]): Promise<(AccountView | null)[]>;
-    warm?(addresses: readonly Address[]): Promise<void>;
-    send(instructions: readonly Instruction[], payer: TransactionSigner): Promise<string>;
-    latestBlockhash(): Promise<Latest>;
-    sendWire(wire: Base64EncodedWireTransaction, latest: Latest): Promise<string>;
-    submitWire(wire: Base64EncodedWireTransaction): Promise<string>;
-    simulate(wire: Base64EncodedWireTransaction, watch?: readonly Address[]): Promise<Simulation>;
-    genesisHash(): Promise<string>;
-    intents(owner?: Address): Promise<ProgramAccount[]>;
-    engineTransactions(limit: number, of?: Address): Promise<EngineTransaction[]>;
-    recentFees(accounts: readonly Address[]): Promise<bigint[]>;
-    budget(instructions: readonly Instruction[], feePayer: Address): Promise<Instruction[]>;
-    airdrop(address: Address, lamports: bigint): Promise<string>;
-}
-type Pending<T> = {
-    send(): Promise<T>;
-};
-type RawAccount = {
-    owner: Address;
-    data: readonly [string, string];
-    lamports: bigint;
-    executable: boolean;
-};
-export type RpcLike = {
-    getMultipleAccounts(addresses: Address[], config: {
-        encoding: "base64";
-    }): Pending<{
-        value: (RawAccount | null)[];
-    }>;
-    getAccountInfo(address: Address, config: {
-        encoding: "base64";
-    }): Pending<{
-        value: {
-            owner: Address;
-            data: readonly [string, string];
-            lamports: bigint;
-            executable: boolean;
-        } | null;
-    }>;
-    getLatestBlockhash(): Pending<{
-        value: {
-            blockhash: Blockhash;
-            lastValidBlockHeight: bigint;
-        };
-    }>;
-    sendTransaction(wire: Base64EncodedWireTransaction, config: {
-        encoding: "base64";
-        skipPreflight?: boolean;
-    }): Pending<Signature>;
-    simulateTransaction(wire: Base64EncodedWireTransaction, config: {
-        encoding: "base64";
-        sigVerify: false;
-        replaceRecentBlockhash: true;
-        accounts?: {
-            addresses: Address[];
-            encoding: "base64";
-        };
-    }): Pending<{
-        value: {
-            err: unknown;
-            logs: readonly string[] | null;
-            unitsConsumed?: bigint | undefined;
-            accounts?: readonly ({
-                data: readonly [string, string];
-            } | null)[] | null;
-        };
-    }>;
-    getSignatureStatuses(signatures: Signature[], config?: {
-        searchTransactionHistory: boolean;
-    }): Pending<{
-        context: {
-            slot: bigint;
-        };
-        value: readonly ({
-            err: unknown;
-            confirmationStatus: string | null;
-        } | null)[];
-    }>;
-    getEpochInfo(): Pending<{
-        blockHeight: bigint;
-        absoluteSlot: bigint;
-    }>;
-    requestAirdrop(address: Address, lamports: bigint): Pending<Signature>;
-    getRecentPrioritizationFees(addresses: readonly Address[]): Pending<readonly {
-        prioritizationFee: bigint;
-    }[]>;
-    getGenesisHash(): Pending<string>;
-    getProgramAccounts(program: Address, config: {
-        encoding: "base64";
-        filters: readonly ({
-            dataSize: bigint;
-        } | {
-            memcmp: {
-                offset: bigint;
-                bytes: string;
-                encoding: "base58";
-            };
-        })[];
-    }): Pending<readonly {
-        pubkey: Address;
-        account: {
-            data: readonly [string, string];
-        };
-    }[]>;
-    getSignaturesForAddress(address: Address, config: {
-        limit: number;
-    }): Pending<readonly {
-        signature: Signature;
-        slot: bigint;
-        blockTime: bigint | null;
-        err: unknown;
-    }[]>;
-    getTransaction(signature: Signature, config: {
-        encoding: "json";
-        maxSupportedTransactionVersion: 0;
-        commitment: "confirmed";
-    }): Pending<{
-        transaction: {
-            message: {
-                accountKeys: readonly Address[];
-                instructions?: readonly {
-                    programIdIndex: number;
-                    data: string;
-                }[];
-            };
-        };
-        meta: {
-            loadedAddresses?: {
-                writable: readonly Address[];
-                readonly: readonly Address[];
-            };
-            innerInstructions?: readonly {
-                instructions: readonly {
-                    programIdIndex: number;
-                    data: string;
-                }[];
-            }[] | null;
-        } | null;
-    } | null>;
-};
-export declare const MEMO_PROGRAM_ADDRESS: Address;
-export declare const POLL_MS = 500;
-export declare const CONFIRM_POLLS = 360;
-export declare const RATE_LIMIT_ATTEMPTS = 6;
-export declare function rateLimited(error: unknown): boolean;
-export declare function patiently<T>(call: () => Promise<T>, wait?: (ms: number) => Promise<void>): Promise<T>;
-export declare class Charged extends Error {
-    constructor(message: string);
-}
-export declare class FailedOnChain extends Charged {
-}
-export declare class BlockhashExpired extends Error {
-    constructor(message: string);
-}
-export declare const neverLanded: (error: unknown) => boolean;
-export type SignatureWatch = (signature: Signature, signal: AbortSignal) => Promise<void>;
-export declare function signatureWatch(url: string): SignatureWatch;
-export declare function confirm(rpc: RpcLike, signature: Signature, lastValidBlockHeight: bigint, wait?: (ms: number) => Promise<void>, watch?: SignatureWatch): Promise<void>;
-export declare function confirmSent(rpc: RpcLike, signature: Signature, lastValidBlockHeight: bigint, wait?: (ms: number) => Promise<void>, watch?: SignatureWatch): Promise<void>;
-export declare const MULTIPLE_ACCOUNTS_LIMIT = 100;
-export declare const TRANSACTION_FETCHES = 4;
-export declare const KEPT_TRANSACTIONS = 256;
-export declare const unmemoized: (transport: Transport) => Transport;
-export declare function memoized(inner: Transport): Transport;
-export declare function rpcTransport(rpc: RpcLike, wait?: (ms: number) => Promise<void>, watch?: SignatureWatch): Transport;
-export type IntentChanges = {
-    wait(seconds: number): Promise<ProgramAccount[] | null>;
-    close(): void;
-};
-export type Notifications = (signal: AbortSignal) => Promise<AsyncIterable<unknown>>;
-export declare function socketUrl(url: string): string;
-export declare function intentNotifications(url: string): Notifications;
-export declare function changedAccount(note: unknown): ProgramAccount | null;
-export declare const RECONNECT_MS: readonly number[];
-export declare function changesFrom(notifications: Notifications, reconnect?: readonly number[]): IntentChanges;
-export {};

package/dist/src/transport.js

@@ -1,441 +0,0 @@
-import { inspect } from "node:util";
-import { appendTransactionMessageInstructions, createSolanaRpcSubscriptions, createTransactionMessage, getBase64EncodedWireTransaction, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, getBase58Decoder, getBase58Encoder, } from "@solana/kit";
-import { getIntentDiscriminatorBytes, getIntentSize, INTENT_ENGINE_PROGRAM_ADDRESS } from "@intent-engine/core";
-export const MEMO_PROGRAM_ADDRESS = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
-export const POLL_MS = 500;
-export const CONFIRM_POLLS = 360;
-const INTENT_OWNER_OFFSET = 8n;
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-export const RATE_LIMIT_ATTEMPTS = 6;
-export function rateLimited(error) {
-    return error instanceof Error && !(error instanceof Charged) && /\b429\b/.test(error.message);
-}
-export async function patiently(call, wait = sleep) {
-    for (let attempt = 1;; attempt++) {
-        try {
-            return await call();
-        }
-        catch (error) {
-            if (!rateLimited(error) || attempt >= RATE_LIMIT_ATTEMPTS) {
-                throw error;
-            }
-            await wait(POLL_MS * 2 ** attempt);
-        }
-    }
-}
-export class Charged extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "Charged";
-    }
-}
-export class FailedOnChain extends Charged {
-}
-export class BlockhashExpired extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "BlockhashExpired";
-    }
-}
-const withoutMark = ({ complete: _, ...found }) => found;
-export const neverLanded = (error) => error instanceof FailedOnChain || error instanceof BlockhashExpired;
-export function signatureWatch(url) {
-    const subscriptions = createSolanaRpcSubscriptions(socketUrl(url));
-    return async (signature, abortSignal) => {
-        const notes = await subscriptions.signatureNotifications(signature, { commitment: "confirmed" }).subscribe({ abortSignal });
-        const iterator = notes[Symbol.asyncIterator]();
-        const next = await iterator.next();
-        if (next.done === true) {
-            throw new Error(`the signature subscription for ${signature} ended without a notification`);
-        }
-        const err = next.value.value?.err ?? null;
-        if (err !== null) {
-            throw new FailedOnChain(`transaction ${signature} failed: ${inspect(err)}`);
-        }
-    };
-}
-const never = new Promise(() => undefined);
-export async function confirm(rpc, signature, lastValidBlockHeight, wait = sleep, watch) {
-    if (watch === undefined) {
-        return polled(rpc, signature, lastValidBlockHeight, wait);
-    }
-    const controller = new AbortController();
-    const heard = watch(signature, controller.signal).catch((error) => {
-        if (error instanceof Charged) {
-            throw error;
-        }
-        return never;
-    });
-    try {
-        await Promise.race([heard, polled(rpc, signature, lastValidBlockHeight, wait, controller.signal)]);
-    }
-    finally {
-        controller.abort();
-    }
-}
-function settled(signature, status) {
-    if (!status || (status.confirmationStatus !== "confirmed" && status.confirmationStatus !== "finalized")) {
-        return false;
-    }
-    if (status.err !== null) {
-        throw new FailedOnChain(`transaction ${signature} failed: ${inspect(status.err)}`);
-    }
-    return true;
-}
-export async function confirmSent(rpc, signature, lastValidBlockHeight, wait = sleep, watch) {
-    try {
-        await confirm(rpc, signature, lastValidBlockHeight, wait, watch);
-    }
-    catch (error) {
-        if (error instanceof Charged || error instanceof BlockhashExpired) {
-            throw error;
-        }
-        throw new Charged(`transaction ${signature} was sent but its confirmation could not be read (${error instanceof Error ? error.message : String(error)}); look the signature up before sending again`);
-    }
-}
-async function polled(rpc, signature, lastValidBlockHeight, wait, stop) {
-    for (let poll = 1; stop?.aborted !== true; poll++) {
-        const [status] = (await patiently(() => rpc.getSignatureStatuses([signature]).send(), wait)).value;
-        if (settled(signature, status)) {
-            return;
-        }
-        const epoch = await patiently(() => rpc.getEpochInfo().send(), wait);
-        if (epoch.blockHeight > lastValidBlockHeight) {
-            const late = await patiently(() => rpc.getSignatureStatuses([signature], { searchTransactionHistory: true }).send(), wait);
-            const [found] = late.value;
-            if (settled(signature, found)) {
-                return;
-            }
-            if (found) {
-                throw new Charged(`transaction ${signature} landed but is not confirmed yet; look the signature up before sending again`);
-            }
-            if (late.context.slot >= epoch.absoluteSlot) {
-                throw new BlockhashExpired(`transaction ${signature} expired before confirmation`);
-            }
-        }
-        if (poll >= CONFIRM_POLLS) {
-            throw new Charged(`transaction ${signature} was neither confirmed nor expired after ${CONFIRM_POLLS} checks; the node may be stuck, so look the signature up before sending again`);
-        }
-        await wait(POLL_MS);
-    }
-}
-export const MULTIPLE_ACCOUNTS_LIMIT = 100;
-function viewOf(value) {
-    return value === null
-        ? null
-        : { owner: value.owner, data: new Uint8Array(Buffer.from(value.data[0], "base64")), lamports: value.lamports, executable: value.executable };
-}
-export const TRANSACTION_FETCHES = 4;
-export const KEPT_TRANSACTIONS = 256;
-const MEMOIZED = Symbol("memoized");
-const UNDERLYING = Symbol("underlying");
-export const unmemoized = (transport) => transport[UNDERLYING] ?? transport;
-export function memoized(inner) {
-    if (inner[MEMOIZED] === true) {
-        return inner;
-    }
-    const seen = new Map();
-    const keep = (address, pending) => {
-        seen.set(address, pending);
-        pending.catch(() => {
-            if (seen.get(address) === pending) {
-                seen.delete(address);
-            }
-        });
-        return pending;
-    };
-    const getAccount = (address) => seen.get(address) ?? keep(address, inner.getAccount(address));
-    const warm = async (addresses) => {
-        const missing = [...new Set(addresses)].filter((address) => !seen.has(address));
-        if (missing.length === 0) {
-            return;
-        }
-        const fetched = inner.getAccounts(missing);
-        missing.forEach((address, i) => keep(address, fetched.then((views) => views[i] ?? null)));
-        await fetched;
-    };
-    const writing = (write) => async (...args) => {
-        try {
-            return await write(...args);
-        }
-        finally {
-            seen.clear();
-        }
-    };
-    return {
-        ...inner,
-        [MEMOIZED]: true,
-        [UNDERLYING]: inner,
-        getAccount,
-        send: writing(inner.send),
-        sendWire: writing(inner.sendWire),
-        submitWire: writing(inner.submitWire),
-        airdrop: writing(inner.airdrop),
-        getAccounts: async (addresses) => {
-            await warm(addresses);
-            return Promise.all(addresses.map(getAccount));
-        },
-        warm,
-    };
-}
-export function rpcTransport(rpc, wait, watch) {
-    const fetched = new Map();
-    return {
-        async getAccount(address) {
-            const { value } = await patiently(() => rpc.getAccountInfo(address, { encoding: "base64" }).send(), wait);
-            return viewOf(value);
-        },
-        async getAccounts(addresses) {
-            const found = [];
-            for (let at = 0; at < addresses.length; at += MULTIPLE_ACCOUNTS_LIMIT) {
-                const chunk = addresses.slice(at, at + MULTIPLE_ACCOUNTS_LIMIT);
-                const { value } = await patiently(() => rpc.getMultipleAccounts([...chunk], { encoding: "base64" }).send(), wait);
-                found.push(...chunk.map((_, i) => viewOf(value[i] ?? null)));
-            }
-            return found;
-        },
-        async send(instructions, payer) {
-            const { value: latest } = await patiently(() => rpc.getLatestBlockhash().send(), wait);
-            const message = pipe(createTransactionMessage({ version: 0 }), (m) => setTransactionMessageFeePayerSigner(payer, m), (m) => setTransactionMessageLifetimeUsingBlockhash(latest, m), (m) => appendTransactionMessageInstructions(instructions, m));
-            const signed = await signTransactionMessageWithSigners(message);
-            const wire = getBase64EncodedWireTransaction(signed);
-            const signature = await patiently(() => rpc.sendTransaction(wire, { encoding: "base64" }).send(), wait);
-            await confirmSent(rpc, signature, latest.lastValidBlockHeight, wait, watch);
-            return signature;
-        },
-        async airdrop(address, lamports) {
-            const { value: latest } = await patiently(() => rpc.getLatestBlockhash().send(), wait);
-            const signature = await rpc.requestAirdrop(address, lamports).send();
-            await confirmSent(rpc, signature, latest.lastValidBlockHeight, wait, watch);
-            return signature;
-        },
-        async latestBlockhash() {
-            const { value } = await patiently(() => rpc.getLatestBlockhash().send(), wait);
-            return value;
-        },
-        async sendWire(wire, latest) {
-            const signature = await patiently(() => rpc.sendTransaction(wire, { encoding: "base64" }).send(), wait);
-            await confirmSent(rpc, signature, latest.lastValidBlockHeight, wait, watch);
-            return signature;
-        },
-        async submitWire(wire) {
-            return patiently(() => rpc.sendTransaction(wire, { encoding: "base64", skipPreflight: true }).send(), wait);
-        },
-        async simulate(wire, watch = []) {
-            const { value } = await patiently(() => rpc
-                .simulateTransaction(wire, {
-                encoding: "base64",
-                sigVerify: false,
-                replaceRecentBlockhash: true,
-                ...(watch.length === 0 ? {} : { accounts: { addresses: [...watch], encoding: "base64" } }),
-            })
-                .send(), wait);
-            return {
-                err: value.err === null ? null : inspect(value.err, { depth: null, breakLength: Infinity }),
-                logs: [...(value.logs ?? [])],
-                unitsConsumed: value.unitsConsumed ?? null,
-                accounts: watch.map((_, i) => {
-                    const found = value.accounts?.[i];
-                    return found === null || found === undefined ? null : new Uint8Array(Buffer.from(found.data[0], "base64"));
-                }),
-            };
-        },
-        async genesisHash() {
-            return patiently(() => rpc.getGenesisHash().send(), wait);
-        },
-        async recentFees(accounts) {
-            const fees = await patiently(() => rpc.getRecentPrioritizationFees(accounts).send(), wait);
-            return fees.map((f) => f.prioritizationFee);
-        },
-        async budget(instructions) {
-            return [...instructions];
-        },
-        async engineTransactions(limit, of) {
-            const signatures = await patiently(() => rpc.getSignaturesForAddress(of ?? INTENT_ENGINE_PROGRAM_ADDRESS, { limit }).send(), wait);
-            const fetchOne = (entry) => {
-                const known = fetched.get(entry.signature);
-                if (known !== undefined) {
-                    fetched.delete(entry.signature);
-                    fetched.set(entry.signature, known);
-                    return known.then(withoutMark);
-                }
-                const pending = load(entry);
-                fetched.set(entry.signature, pending);
-                pending.then((found) => {
-                    if (!found.complete && fetched.get(entry.signature) === pending) {
-                        fetched.delete(entry.signature);
-                    }
-                }, () => {
-                    if (fetched.get(entry.signature) === pending) {
-                        fetched.delete(entry.signature);
-                    }
-                });
-                return pending.then(withoutMark);
-            };
-            const load = async (entry) => {
-                const tx = await patiently(() => rpc
-                    .getTransaction(entry.signature, {
-                    encoding: "json",
-                    maxSupportedTransactionVersion: 0,
-                    commitment: "confirmed",
-                })
-                    .send(), wait);
-                const keys = [
-                    ...(tx?.transaction.message.accountKeys ?? []),
-                    ...(tx?.meta?.loadedAddresses?.writable ?? []),
-                    ...(tx?.meta?.loadedAddresses?.readonly ?? []),
-                ];
-                const emitted = (tx?.meta?.innerInstructions ?? [])
-                    .flatMap((group) => group.instructions)
-                    .filter((ix) => keys[ix.programIdIndex] === INTENT_ENGINE_PROGRAM_ADDRESS)
-                    .map((ix) => Uint8Array.from(getBase58Encoder().encode(ix.data)));
-                const memos = (tx?.transaction.message.instructions ?? [])
-                    .filter((ix) => keys[ix.programIdIndex] === MEMO_PROGRAM_ADDRESS)
-                    .map((ix) => new TextDecoder().decode(Uint8Array.from(getBase58Encoder().encode(ix.data))));
-                return {
-                    signature: entry.signature,
-                    slot: entry.slot,
-                    blockTime: entry.blockTime,
-                    failed: entry.err !== null,
-                    emitted,
-                    ...(memos.length === 0 ? {} : { memos }),
-                    ...(tx?.meta === null || tx?.meta === undefined ? { unread: true } : {}),
-                    complete: tx?.meta !== null && tx?.meta !== undefined && entry.blockTime !== null,
-                };
-            };
-            const found = [];
-            for (let i = 0; i < signatures.length; i += TRANSACTION_FETCHES) {
-                found.push(...(await Promise.all(signatures.slice(i, i + TRANSACTION_FETCHES).map(fetchOne))));
-            }
-            for (const old of fetched.keys()) {
-                if (fetched.size <= KEPT_TRANSACTIONS) {
-                    break;
-                }
-                fetched.delete(old);
-            }
-            return found;
-        },
-        async intents(owner) {
-            const found = await patiently(() => rpc
-                .getProgramAccounts(INTENT_ENGINE_PROGRAM_ADDRESS, {
-                encoding: "base64",
-                filters: [
-                    { dataSize: BigInt(getIntentSize()) },
-                    {
-                        memcmp: {
-                            offset: 0n,
-                            bytes: getBase58Decoder().decode(getIntentDiscriminatorBytes()),
-                            encoding: "base58",
-                        },
-                    },
-                    ...(owner === undefined
-                        ? []
-                        : [{ memcmp: { offset: INTENT_OWNER_OFFSET, bytes: owner, encoding: "base58" } }]),
-                ],
-            })
-                .send(), wait);
-            return found.map(({ pubkey, account }) => ({
-                address: pubkey,
-                data: new Uint8Array(Buffer.from(account.data[0], "base64")),
-            }));
-        },
-    };
-}
-export function socketUrl(url) {
-    const parsed = new URL(url);
-    parsed.protocol = parsed.protocol === "http:" ? "ws:" : "wss:";
-    if (parsed.port === "8899") {
-        parsed.port = "8900";
-    }
-    return parsed.toString();
-}
-export function intentNotifications(url) {
-    const subscriptions = createSolanaRpcSubscriptions(socketUrl(url));
-    return (abortSignal) => subscriptions
-        .programNotifications(INTENT_ENGINE_PROGRAM_ADDRESS, {
-        commitment: "confirmed",
-        encoding: "base64",
-        filters: [
-            { dataSize: BigInt(getIntentSize()) },
-            { memcmp: { offset: 0n, bytes: getBase58Decoder().decode(getIntentDiscriminatorBytes()), encoding: "base58" } },
-        ],
-    })
-        .subscribe({ abortSignal });
-}
-export function changedAccount(note) {
-    const value = note?.value;
-    const data = value?.account?.data;
-    if (typeof value?.pubkey !== "string" || !Array.isArray(data) || typeof data[0] !== "string") {
-        return null;
-    }
-    return { address: value.pubkey, data: new Uint8Array(Buffer.from(data[0], "base64")) };
-}
-export const RECONNECT_MS = [1_000, 2_000, 5_000, 10_000, 30_000];
-function pause(ms, signal) {
-    return new Promise((resolve) => {
-        const stop = () => {
-            clearTimeout(timer);
-            resolve();
-        };
-        const timer = setTimeout(() => {
-            signal.removeEventListener("abort", stop);
-            resolve();
-        }, ms);
-        signal.addEventListener("abort", stop, { once: true });
-    });
-}
-export function changesFrom(notifications, reconnect = RECONNECT_MS) {
-    const controller = new AbortController();
-    const pending = new Map();
-    let wake;
-    const drain = () => {
-        const changed = [...pending].map(([address, data]) => ({ address, data }));
-        pending.clear();
-        return changed;
-    };
-    let failures = 0;
-    const consume = async () => {
-        const iterator = (await notifications(controller.signal))[Symbol.asyncIterator]();
-        for (let next = await iterator.next(); next.done !== true; next = await iterator.next()) {
-            failures = 0;
-            const changed = changedAccount(next.value);
-            if (changed !== null) {
-                pending.set(changed.address, changed.data);
-                wake?.();
-            }
-        }
-    };
-    const listen = async () => {
-        while (!controller.signal.aborted) {
-            await consume().catch(() => undefined);
-            if (controller.signal.aborted) {
-                return;
-            }
-            await pause(reconnect[Math.min(failures, reconnect.length - 1)] ?? 0, controller.signal);
-            failures++;
-        }
-    };
-    void listen();
-    return {
-        wait: (seconds) => new Promise((resolve) => {
-            if (pending.size > 0) {
-                resolve(drain());
-                return;
-            }
-            const timer = setTimeout(() => {
-                wake = undefined;
-                resolve([]);
-            }, seconds * 1000);
-            wake = () => {
-                clearTimeout(timer);
-                wake = undefined;
-                resolve(drain());
-            };
-        }),
-        close: () => {
-            wake?.();
-            controller.abort();
-        },
-    };
-}
-//# sourceMappingURL=transport.js.map