crypto-aio 0.0.2 → 0.1.0

package/dist/testing/fake-clock.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeClock = void 0;
+exports.settle = settle;
+exports.drive = drive;
+const clock_1 = require("../core/util/clock");
+/** Lets pending promise chains and I/O callbacks run. */
+async function settle(rounds = 5) {
+    for (let i = 0; i < rounds; i++)
+        await new Promise((r) => setImmediate(r));
+}
+/** Deterministic clock for tests: time moves only when `advance` is called. */
+class FakeClock {
+    #now;
+    #seq = 0;
+    #timers = [];
+    constructor(start = 1_700_000_000_000) {
+        this.#now = start;
+    }
+    now() {
+        return this.#now;
+    }
+    get pending() {
+        return this.#timers.length;
+    }
+    sleep(ms, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                reject((0, clock_1.abortReason)(signal));
+                return;
+            }
+            const onAbort = () => {
+                this.#timers = this.#timers.filter((t) => t !== timer);
+                reject((0, clock_1.abortReason)(signal));
+            };
+            const timer = {
+                at: this.#now + Math.max(0, ms),
+                seq: this.#seq++,
+                wake: () => {
+                    signal?.removeEventListener('abort', onAbort);
+                    resolve();
+                },
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
+            this.#timers.push(timer);
+        });
+    }
+    /** Moves time forward, waking due sleepers in order and settling async work between them. */
+    async advance(ms) {
+        const target = this.#now + ms;
+        await settle();
+        for (;;) {
+            const due = this.#timers
+                .filter((t) => t.at <= target)
+                .sort((a, b) => a.at - b.at || a.seq - b.seq)[0];
+            if (!due)
+                break;
+            this.#timers = this.#timers.filter((t) => t !== due);
+            this.#now = Math.max(this.#now, due.at);
+            due.wake();
+            await settle();
+        }
+        this.#now = target;
+        await settle();
+    }
+}
+exports.FakeClock = FakeClock;
+/** Advances `clock` in steps until `promise` settles, then returns its value or rethrows. */
+async function drive(clock, promise, stepMs = 10, maxSteps = 10_000) {
+    let settled = false;
+    const tracked = promise.then((value) => {
+        settled = true;
+        return value;
+    }, (error) => {
+        settled = true;
+        throw error;
+    });
+    tracked.catch(() => undefined);
+    await settle();
+    for (let i = 0; i < maxSteps && !settled; i++)
+        await clock.advance(stepMs);
+    if (!settled)
+        throw new Error(`promise did not settle within ${maxSteps * stepMs}ms of fake time`);
+    return tracked;
+}
+//# sourceMappingURL=fake-clock.js.map

package/dist/testing/fake-clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-clock.js","sourceRoot":"","sources":["../../src/testing/fake-clock.ts"],"names":[],"mappings":"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","sourcesContent":["import { abortReason, type Clock } from '../core/util/clock';\n\ninterface Timer {\n  readonly at: number;\n  readonly seq: number;\n  readonly wake: () => void;\n}\n\n/** Lets pending promise chains and I/O callbacks run. */\nexport async function settle(rounds = 5): Promise<void> {\n  for (let i = 0; i < rounds; i++) await new Promise<void>((r) => setImmediate(r));\n}\n\n/** Deterministic clock for tests: time moves only when `advance` is called. */\nexport class FakeClock implements Clock {\n  #now: number;\n  #seq = 0;\n  #timers: Timer[] = [];\n\n  constructor(start = 1_700_000_000_000) {\n    this.#now = start;\n  }\n\n  now(): number {\n    return this.#now;\n  }\n\n  get pending(): number {\n    return this.#timers.length;\n  }\n\n  sleep(ms: number, signal?: AbortSignal): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      if (signal?.aborted) {\n        reject(abortReason(signal));\n        return;\n      }\n      const onAbort = () => {\n        this.#timers = this.#timers.filter((t) => t !== timer);\n        reject(abortReason(signal as AbortSignal));\n      };\n      const timer: Timer = {\n        at: this.#now + Math.max(0, ms),\n        seq: this.#seq++,\n        wake: () => {\n          signal?.removeEventListener('abort', onAbort);\n          resolve();\n        },\n      };\n      signal?.addEventListener('abort', onAbort, { once: true });\n      this.#timers.push(timer);\n    });\n  }\n\n  /** Moves time forward, waking due sleepers in order and settling async work between them. */\n  async advance(ms: number): Promise<void> {\n    const target = this.#now + ms;\n    await settle();\n    for (;;) {\n      const due = this.#timers\n        .filter((t) => t.at <= target)\n        .sort((a, b) => a.at - b.at || a.seq - b.seq)[0];\n      if (!due) break;\n      this.#timers = this.#timers.filter((t) => t !== due);\n      this.#now = Math.max(this.#now, due.at);\n      due.wake();\n      await settle();\n    }\n    this.#now = target;\n    await settle();\n  }\n}\n\n/** Advances `clock` in steps until `promise` settles, then returns its value or rethrows. */\nexport async function drive<T>(\n  clock: FakeClock,\n  promise: Promise<T>,\n  stepMs = 10,\n  maxSteps = 10_000,\n): Promise<T> {\n  let settled = false;\n  const tracked = promise.then(\n    (value) => {\n      settled = true;\n      return value;\n    },\n    (error: unknown) => {\n      settled = true;\n      throw error;\n    },\n  );\n  tracked.catch(() => undefined);\n  await settle();\n  for (let i = 0; i < maxSteps && !settled; i++) await clock.advance(stepMs);\n  if (!settled)\n    throw new Error(`promise did not settle within ${maxSteps * stepMs}ms of fake time`);\n  return tracked;\n}\n"]}

package/dist/testing/fake-driver.d.ts

@@ -0,0 +1,15 @@
+import type { DriverFactory } from '../core/driver/types';
+export interface FakeExt {
+    readonly fake: {
+        nonceOf(address: string): Promise<bigint>;
+        head(): Promise<bigint>;
+    };
+}
+export interface FakeNativeClient {
+    readonly id: number;
+    readonly settings: Record<string, unknown>;
+    /** How many times the driver's `close` for this client ran. */
+    readonly closes: number;
+    rpc<T = unknown>(method: string, params?: unknown[]): Promise<T>;
+}
+export declare const fakeDriverFactory: DriverFactory;

package/dist/testing/fake-driver.js

@@ -0,0 +1,458 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fakeDriverFactory = void 0;
+const error_1 = require("../core/errors/error");
+const asset_1 = require("../core/model/asset");
+const bytes_1 = require("../core/util/bytes");
+const json_1 = require("../core/util/json");
+const fake_chain_1 = require("./fake-chain");
+let nativeClients = 0;
+const REJECTED = /malformed transaction|invalid chain id|invalid sender|invalid signature/;
+function classify(message) {
+    if (/already known|already processed/.test(message))
+        return { kind: 'already-known' };
+    if (REJECTED.test(message))
+        return { kind: 'rejected', reason: message };
+    if (/insufficient funds/.test(message))
+        return { kind: 'refused', code: 'INSUFFICIENT_FUNDS', reason: message };
+    if (/underpriced|fee too low/.test(message))
+        return { kind: 'refused', code: 'FEE_TOO_LOW', reason: message };
+    if (/nonce too low|seqno mismatch/.test(message))
+        return { kind: 'refused', code: 'NONCE_CONFLICT', reason: message };
+    if (/expired/.test(message))
+        return { kind: 'refused', code: 'TX_EXPIRED', reason: message };
+    return { kind: 'refused', code: 'TX_REFUSED', reason: message };
+}
+function toDriverBlock(wire) {
+    return {
+        height: BigInt(wire.height),
+        hash: wire.hash,
+        parentHash: wire.parentHash,
+        timestamp: wire.timestamp,
+        transactionIds: wire.txIds,
+    };
+}
+function toDriverTx(wire) {
+    const included = wire.blockHeight !== undefined && wire.blockHash !== undefined;
+    return {
+        id: wire.id,
+        observation: included
+            ? {
+                seen: 'block',
+                txHash: wire.id,
+                blockHeight: BigInt(wire.blockHeight),
+                blockHash: wire.blockHash,
+                success: wire.success ?? true,
+            }
+            : { seen: wire.pending ? 'mempool' : 'none' },
+        fee: [{ asset: 'native', amount: BigInt(wire.fee) }],
+        transfers: wire.success === false
+            ? []
+            : [
+                {
+                    locator: 'native',
+                    from: [wire.from],
+                    to: wire.to,
+                    asset: 'native',
+                    amount: BigInt(wire.amount),
+                    source: 'native',
+                    ...(wire.memo !== undefined ? { memo: wire.memo } : {}),
+                },
+            ],
+        decoding: 'complete',
+        details: wire.nonce !== undefined ? { nonce: wire.nonce } : {},
+    };
+}
+/**
+ * The proof contract (`ProofSource`): a JSON-RPC error answer is no negative
+ * proof. Every `RPC_ERROR` on a proof path becomes a retryable `PROVIDER_UNAVAILABLE` that
+ * carries it as its cause, so the core decides nothing and looks again later; every other
+ * error passes unchanged. The EVM driver's proofs keep the same boundary.
+ */
+async function undecided(proof) {
+    try {
+        return await proof();
+    }
+    catch (error) {
+        if (!(0, error_1.isCryptoAioError)(error, 'RPC_ERROR'))
+            throw error;
+        throw new error_1.ProviderError('PROVIDER_UNAVAILABLE', 'the endpoints gave no answer', {
+            cause: error,
+        });
+    }
+}
+exports.fakeDriverFactory = {
+    async create(ctx) {
+        const { transport, chain, network, clock } = ctx;
+        const ordering = chain.ordering;
+        const expiryBlocks = BigInt(typeof ctx.options.expiryBlocks === 'number' ? ctx.options.expiryBlocks : 5);
+        const minBump = BigInt(network.replacement?.minBumpPercent ?? 10);
+        const nativeAsset = (0, asset_1.assetId)(chain.id, network.id, 'native');
+        transport.setProbes({
+            identity: (call) => call.rpc('fake_identity'),
+            ...(network.identity !== undefined ? { expectedIdentity: network.identity } : {}),
+            height: async (call) => BigInt(await call.rpc('fake_blockNumber')),
+        });
+        const call = (method, params = [], options = {}) => transport.rpc(method, params, options);
+        const read = (method, params = []) => call(method, params);
+        const monitor = (method, params = []) => call(method, params, { purpose: 'monitor' });
+        const proof = (method, params = []) => call(method, params, { quorum: 'proof' });
+        const assertNative = (asset) => {
+            if (asset !== 'native') {
+                throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', 'the fake chain has no tokens');
+            }
+        };
+        const address = {
+            validate: (value) => (0, fake_chain_1.isFakeAddress)(value),
+            normalize: (value) => {
+                if (!(0, fake_chain_1.isFakeAddress)(value))
+                    throw new error_1.ValidationError('INVALID_ADDRESS', 'not a fake-chain address');
+                const canonical = value.toLowerCase();
+                return { canonical, display: canonical };
+            },
+            fromPublicKey: (publicKey) => {
+                const canonical = (0, fake_chain_1.fakeAddress)(publicKey);
+                return { canonical, display: canonical };
+            },
+        };
+        const feeFor = async (fee) => {
+            if (typeof fee === 'object') {
+                const amount = fee.fee;
+                if (typeof amount !== 'bigint') {
+                    throw new error_1.ValidationError('INVALID_INTENT', 'fake fee overrides look like { fee: bigint }');
+                }
+                return {
+                    kind: 'fake',
+                    speed: 'custom',
+                    charges: [{ asset: 'native', amount, label: 'network' }],
+                    bound: 'exact',
+                    details: { fee: amount },
+                };
+            }
+            const rate = BigInt(await read('fake_feeRate'));
+            const amount = rate * (fee === 'slow' ? 1n : fee === 'normal' ? 2n : 3n);
+            return {
+                kind: 'fake',
+                speed: fee,
+                charges: [{ asset: 'native', amount, label: 'network' }],
+                bound: 'exact',
+                details: { fee: amount },
+            };
+        };
+        const buildUnsigned = async (intent, fee, build, fixedOrdering) => {
+            assertNative(intent.asset);
+            const output = intent.outputs[0];
+            if (!output || intent.outputs.length !== 1) {
+                throw new error_1.ValidationError('INVALID_INTENT', 'the fake chain supports exactly one output');
+            }
+            const key = build.keys[0];
+            if (!key)
+                throw new error_1.SigningError('SIGNER_UNAVAILABLE', 'no public key for the sending wallet');
+            let order;
+            if (ordering === 'expiry') {
+                const head = BigInt(await read('fake_blockNumber'));
+                order = fixedOrdering ?? { kind: 'expiry', lastValidHeight: head + expiryBlocks };
+            }
+            else {
+                const allocated = fixedOrdering ?? build.ordering;
+                if (!allocated || allocated.kind !== ordering) {
+                    throw new error_1.StateError('INVALID_TRANSITION', `missing ${ordering} allocation for the fake chain`);
+                }
+                order =
+                    ordering === 'seqno' && allocated.kind === 'seqno'
+                        ? { kind: 'seqno', seqno: allocated.seqno, validUntil: clock.now() + 60_000 }
+                        : allocated;
+            }
+            const feeAmount = fee.charges.reduce((sum, c) => sum + c.amount, 0n);
+            const slot = order.kind === 'nonce'
+                ? { nonce: order.nonce.toString() }
+                : order.kind === 'seqno'
+                    ? { nonce: order.seqno.toString() }
+                    : order.kind === 'expiry' && order.lastValidHeight !== undefined
+                        ? { lastValidHeight: order.lastValidHeight.toString() }
+                        : {};
+            const tx = {
+                chainId: network.identity ?? 'fake-local',
+                from: intent.from,
+                to: output.to,
+                amount: output.amount.toString(),
+                fee: feeAmount.toString(),
+                ...slot,
+                ...(intent.memo !== undefined ? { memo: intent.memo } : {}),
+            };
+            return {
+                payload: { encoding: 'json', data: (0, json_1.canonicalJson)(tx) },
+                signingRequests: [
+                    {
+                        id: 'r0',
+                        scheme: 'secp256k1-ecdsa',
+                        payload: (0, fake_chain_1.fakeDigest)(tx),
+                        payloadKind: 'digest',
+                        publicKey: key.publicKey,
+                        ...(key.keyRef ? { keyRef: key.keyRef } : {}),
+                    },
+                ],
+                ordering: order,
+                fee,
+                summary: {
+                    asset: nativeAsset,
+                    outputs: [{ to: output.to, amount: output.amount.toString() }],
+                    ...(intent.memo !== undefined ? { memo: intent.memo } : {}),
+                },
+            };
+        };
+        const builder = {
+            estimateFee: async (intent) => {
+                assertNative(intent.asset);
+                return feeFor(intent.fee);
+            },
+            checkFunds: async (intent, fee) => {
+                const available = BigInt(await read('fake_getBalance', [intent.from, 'latest']));
+                const required = intent.outputs.reduce((sum, o) => sum + o.amount, 0n) +
+                    fee.charges.reduce((sum, c) => sum + c.amount, 0n);
+                return available >= required
+                    ? { ok: true }
+                    : { ok: false, asset: 'native', required, available };
+            },
+            build: (intent, fee, build) => buildUnsigned(intent, fee, build),
+            assemble: async (unsigned, signatures) => {
+                const request = unsigned.signingRequests[0];
+                const signature = signatures.find((s) => s.requestId === 'r0');
+                if (!request || !signature || signature.recovery === undefined) {
+                    throw new error_1.SigningError('SIGNING_FAILED', 'missing signature for request r0');
+                }
+                const tx = JSON.parse(unsigned.payload.data);
+                const raw = (0, fake_chain_1.encodeEnvelope)({
+                    tx,
+                    sig: (0, bytes_1.toHex)(signature.bytes),
+                    recovery: signature.recovery,
+                    pub: (0, bytes_1.toHex)(request.publicKey),
+                });
+                return {
+                    raw: { encoding: 'base64', data: raw },
+                    ref: { id: (0, fake_chain_1.fakeTxId)(raw), idKind: 'tx-hash', canonical: true },
+                };
+            },
+        };
+        const broadcaster = {
+            async broadcast(signed, options = {}) {
+                try {
+                    await call('fake_sendRawTransaction', [signed.raw.data], {
+                        retry: 'ambiguous-on-failure',
+                        purpose: 'broadcast',
+                        ...(options.fanout !== undefined ? { fanout: options.fanout } : {}),
+                        ...(options.signal ? { signal: options.signal } : {}),
+                    });
+                    return { kind: 'accepted' };
+                }
+                catch (error) {
+                    // The transport tags a definitive RPC_ERROR as ambiguous when an earlier
+                    // attempt for this same call may already have reached the node (e.g. it timed out
+                    // after being delivered, and the retry then sees "nonce too low"). Classifying that
+                    // as a normal refusal would let a caller release or reuse a nonce/seqno slot whose
+                    // transaction may actually be live — so an ambiguous error is rethrown unclassified
+                    // instead of being turned into a resolved BroadcastResult.
+                    if ((0, error_1.isCryptoAioError)(error, 'RPC_ERROR') && !error.ambiguous) {
+                        return classify(String(error.details?.rpcMessage ?? error.message));
+                    }
+                    throw error;
+                }
+            },
+        };
+        const reader = {
+            getBalance: async (value, asset) => {
+                assertNative(asset);
+                return BigInt(await read('fake_getBalance', [value, 'latest']));
+            },
+            getBlockHeight: async () => BigInt(await monitor('fake_blockNumber')),
+            getFinalizedHeight: async () => BigInt((await monitor('fake_finalizedBlock')).height),
+            getBlock: async (ref) => {
+                const wire = await read('fake_getBlock', [
+                    typeof ref === 'bigint' ? ref.toString() : ref,
+                    false,
+                ]);
+                return wire ? toDriverBlock(wire) : null;
+            },
+            getTransaction: async (id) => {
+                const wire = await read('fake_getTransaction', [id]);
+                return wire ? toDriverTx(wire) : null;
+            },
+            observe: async (ref) => {
+                const wire = await monitor('fake_getTransaction', [ref.id]);
+                return wire ? toDriverTx(wire).observation : { seen: 'none' };
+            },
+        };
+        const finalizedHead = () => undecided(async () => {
+            const head = await proof('fake_finalizedBlock');
+            return {
+                height: BigInt(head.height),
+                hash: head.hash,
+                timestamp: head.timestamp,
+            };
+        });
+        const proofs = {
+            finalizedHead,
+            includedFinal: (ref) => undecided(async () => {
+                const wire = await proof('fake_getFinalizedTransaction', [
+                    ref.id,
+                ]);
+                if (!wire || wire.blockHeight === undefined || wire.blockHash === undefined)
+                    return { included: false };
+                return {
+                    included: true,
+                    success: wire.success ?? true,
+                    blockHeight: BigInt(wire.blockHeight),
+                    blockHash: wire.blockHash,
+                    txHash: wire.id,
+                };
+            }),
+            slotConsumed: (order, from, level) => undecided(async () => {
+                if (order.kind !== 'nonce' && order.kind !== 'seqno')
+                    return false;
+                const slot = order.kind === 'nonce' ? order.nonce : order.seqno;
+                const fetchNonce = level === 'finalized' ? proof : monitor;
+                const next = BigInt(await fetchNonce('fake_getNonce', [
+                    from,
+                    level === 'finalized' ? 'finalized' : 'latest',
+                ]));
+                return next > slot;
+            }),
+            expired: async (order) => {
+                if (order.kind !== 'expiry' || order.lastValidHeight === undefined)
+                    return false;
+                return (await finalizedHead()).height >= order.lastValidHeight;
+            },
+            blockHash: (height, level) => undecided(() => proof('fake_getBlockHash', [height.toString(), level])),
+        };
+        const sequence = ordering === 'expiry'
+            ? undefined
+            : {
+                pending: async (value) => BigInt(await monitor('fake_getNonce', [value, 'pending'])),
+                latest: async (value) => BigInt(await monitor('fake_getNonce', [value, 'latest'])),
+            };
+        const previousTx = (previous) => JSON.parse(previous.payload.data);
+        const previousFee = (previous) => previous.fee.charges.reduce((sum, c) => sum + c.amount, 0n);
+        const replacement = ordering === 'nonce'
+            ? {
+                replace: true,
+                cancel: true,
+                async buildReplacement(previous, fee, build) {
+                    const next = await feeFor(fee);
+                    const nextFee = next.charges.reduce((sum, c) => sum + c.amount, 0n);
+                    if (nextFee * 100n < previousFee(previous) * (100n + minBump)) {
+                        throw new error_1.ChainError('FEE_TOO_LOW', `replacement fee must be at least ${minBump}% higher`);
+                    }
+                    const tx = previousTx(previous);
+                    return buildUnsigned({
+                        asset: 'native',
+                        outputs: [{ to: tx.to, amount: BigInt(tx.amount) }],
+                        from: tx.from,
+                        fee,
+                        ...(tx.memo !== undefined ? { memo: tx.memo } : {}),
+                    }, next, build, previous.ordering);
+                },
+                async buildCancel(previous, build, requested) {
+                    const bumped = (previousFee(previous) * (100n + minBump) + 99n) / 100n;
+                    const fee = requested === undefined
+                        ? {
+                            kind: 'fake',
+                            speed: 'custom',
+                            charges: [{ asset: 'native', amount: bumped, label: 'network' }],
+                            bound: 'exact',
+                            details: { fee: bumped },
+                        }
+                        : await feeFor(requested);
+                    const amount = fee.charges.reduce((sum, c) => sum + c.amount, 0n);
+                    if (amount * 100n < previousFee(previous) * (100n + minBump)) {
+                        throw new error_1.ChainError('FEE_TOO_LOW', `a cancel's fee must be at least ${minBump}% higher`);
+                    }
+                    const tx = previousTx(previous);
+                    return buildUnsigned({
+                        asset: 'native',
+                        outputs: [{ to: tx.from, amount: 0n }],
+                        from: tx.from,
+                        fee: requested ?? { fee: amount },
+                    }, fee, build, previous.ordering);
+                },
+            }
+            : undefined;
+        const blocks = {
+            header: async (height) => {
+                const wire = await monitor('fake_getBlock', [
+                    height.toString(),
+                    false,
+                ]);
+                return wire ? toDriverBlock(wire) : null;
+            },
+            transactions: async (block, filter) => {
+                const wire = await monitor('fake_getBlock', [
+                    block.height.toString(),
+                    true,
+                ]);
+                if (!wire || wire.hash !== block.hash) {
+                    throw new error_1.ProviderError('PROVIDER_INCONSISTENT', `block ${block.height} changed while scanning`, { retryable: true });
+                }
+                const txs = (wire.txs ?? []).map(toDriverTx);
+                if (!filter?.addresses?.length)
+                    return txs;
+                const wanted = new Set(filter.addresses.map((a) => a.toLowerCase()));
+                return txs.filter((t) => t.transfers.some((tr) => wanted.has(tr.to) || tr.from.some((f) => wanted.has(f))));
+            },
+        };
+        const capabilities = new Set([
+            'memo',
+            'block-scan',
+            'finality-tag',
+            'hd-public-derivation',
+        ]);
+        if (ordering === 'nonce') {
+            capabilities.add('replace-fee');
+            capabilities.add('cancel');
+        }
+        if (ordering === 'expiry')
+            capabilities.add('expiry');
+        return {
+            ordering,
+            capabilities,
+            address,
+            reader,
+            builder,
+            broadcaster,
+            proofs,
+            ...(sequence ? { sequence } : {}),
+            ...(replacement ? { replacement } : {}),
+            blocks,
+            // Written as a fresh literal here (not a separately-typed `const ext: FakeExt = ...`):
+            // `ChainDriver.ext` is a generic `Record<string, Record<string, (...args) => Promise<unknown>>>`,
+            // and a named interface like `FakeExt` has no index signature, so passing it through a
+            // typed intermediate fails TS2322 ("index signature missing"). A fresh object literal at
+            // the assignment site is checked structurally instead and satisfies both `ChainDriver.ext`
+            // and, via the `fake` module augmentation, `FakeExt`.
+            ext: {
+                fake: {
+                    nonceOf: async (value) => BigInt(await read('fake_getNonce', [value, 'latest'])),
+                    head: async () => BigInt(await read('fake_blockNumber')),
+                },
+            },
+            limits: () => ({ maxOutputs: 1 }),
+            createNativeClient: () => {
+                let closes = 0;
+                const client = {
+                    id: ++nativeClients,
+                    settings: {},
+                    get closes() {
+                        return closes;
+                    },
+                    rpc: (method, params = []) => transport.rpc(method, params),
+                };
+                return {
+                    client,
+                    close: () => {
+                        closes += 1;
+                    },
+                };
+            },
+        };
+    },
+};
+//# sourceMappingURL=fake-driver.js.map