crypto-aio 0.0.3 → 0.2.0

package/dist/testing/fake-fetch.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeFetch = void 0;
+exports.hang = hang;
+exports.rpcResult = rpcResult;
+exports.rpcError = rpcError;
+/** Scripted fetch: routes by longest URL prefix; unknown hosts fail like a DNS error. */
+class FakeFetch {
+    calls = [];
+    #routes = [];
+    route(prefix, handler) {
+        this.#routes.push({ prefix, handler });
+        this.#routes.sort((a, b) => b.prefix.length - a.prefix.length);
+        return this;
+    }
+    callsTo(prefix) {
+        return this.calls.filter((call) => call.url.startsWith(prefix));
+    }
+    fetch = (async (input, init) => {
+        const url = new URL(typeof input === 'string' ? input : input instanceof URL ? input.href : input.url);
+        const headers = new Headers(init?.headers);
+        const rawBody = init?.body;
+        const body = typeof rawBody === 'string'
+            ? rawBody
+            : rawBody instanceof Uint8Array
+                ? new TextDecoder().decode(rawBody)
+                : undefined;
+        const method = init?.method ?? 'GET';
+        this.calls.push({
+            url: url.href,
+            method,
+            headers: Object.fromEntries(headers.entries()),
+            ...(body !== undefined ? { body } : {}),
+        });
+        const route = this.#routes.find((r) => url.href.startsWith(r.prefix));
+        if (!route) {
+            throw new TypeError('fetch failed', {
+                cause: new Error(`getaddrinfo ENOTFOUND ${url.host}`),
+            });
+        }
+        const signal = init?.signal ?? undefined;
+        if (signal?.aborted)
+            throw signal.reason;
+        const reply = await route.handler({ url, method, headers, body, json: () => JSON.parse(body ?? 'null') }, signal);
+        if (reply instanceof Response)
+            return reply;
+        const text = reply.text ?? (reply.json === undefined ? '' : JSON.stringify(reply.json));
+        return new Response(text, {
+            status: reply.status ?? 200,
+            headers: {
+                'content-type': reply.text !== undefined ? 'text/plain' : 'application/json',
+                'content-length': String(new TextEncoder().encode(text).length),
+                ...reply.headers,
+            },
+        });
+    });
+}
+exports.FakeFetch = FakeFetch;
+/** A reply that never arrives; rejects with the abort reason when the request is aborted. */
+function hang(signal) {
+    return new Promise((_resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        signal?.addEventListener('abort', () => reject(signal.reason), { once: true });
+    });
+}
+function rpcResult(request, result) {
+    return { json: { jsonrpc: '2.0', id: request.json().id, result } };
+}
+function rpcError(request, code, message) {
+    return {
+        json: {
+            jsonrpc: '2.0',
+            id: request.json().id,
+            error: { code, message },
+        },
+    };
+}
+//# sourceMappingURL=fake-fetch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fake-fetch.js","sourceRoot":"","sources":["../../src/testing/fake-fetch.ts"],"names":[],"mappings":"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","sourcesContent":["export interface FakeRequest {\n  readonly url: URL;\n  readonly method: string;\n  readonly headers: Headers;\n  readonly body: string | undefined;\n  json<T = Record<string, unknown>>(): T;\n}\n\nexport type FakeReply =\n  | Response\n  | {\n      readonly status?: number;\n      readonly json?: unknown;\n      readonly text?: string;\n      readonly headers?: Readonly<Record<string, string>>;\n    };\n\nexport type FakeHandler = (\n  request: FakeRequest,\n  signal: AbortSignal | undefined,\n) => FakeReply | Promise<FakeReply>;\n\nexport interface RecordedCall {\n  readonly url: string;\n  readonly method: string;\n  readonly headers: Readonly<Record<string, string>>;\n  readonly body?: string;\n}\n\n/** Scripted fetch: routes by longest URL prefix; unknown hosts fail like a DNS error. */\nexport class FakeFetch {\n  readonly calls: RecordedCall[] = [];\n  readonly #routes: { prefix: string; handler: FakeHandler }[] = [];\n\n  route(prefix: string, handler: FakeHandler): this {\n    this.#routes.push({ prefix, handler });\n    this.#routes.sort((a, b) => b.prefix.length - a.prefix.length);\n    return this;\n  }\n\n  callsTo(prefix: string): RecordedCall[] {\n    return this.calls.filter((call) => call.url.startsWith(prefix));\n  }\n\n  readonly fetch = (async (\n    input: string | URL | Request,\n    init?: RequestInit,\n  ): Promise<Response> => {\n    const url = new URL(\n      typeof input === 'string' ? input : input instanceof URL ? input.href : input.url,\n    );\n    const headers = new Headers(init?.headers);\n    const rawBody = init?.body;\n    const body =\n      typeof rawBody === 'string'\n        ? rawBody\n        : rawBody instanceof Uint8Array\n          ? new TextDecoder().decode(rawBody)\n          : undefined;\n    const method = init?.method ?? 'GET';\n    this.calls.push({\n      url: url.href,\n      method,\n      headers: Object.fromEntries(headers.entries()),\n      ...(body !== undefined ? { body } : {}),\n    });\n    const route = this.#routes.find((r) => url.href.startsWith(r.prefix));\n    if (!route) {\n      throw new TypeError('fetch failed', {\n        cause: new Error(`getaddrinfo ENOTFOUND ${url.host}`),\n      });\n    }\n    const signal = init?.signal ?? undefined;\n    if (signal?.aborted) throw signal.reason;\n    const reply = await route.handler(\n      { url, method, headers, body, json: <T>() => JSON.parse(body ?? 'null') as T },\n      signal,\n    );\n    if (reply instanceof Response) return reply;\n    const text =\n      reply.text ?? (reply.json === undefined ? '' : JSON.stringify(reply.json));\n    return new Response(text, {\n      status: reply.status ?? 200,\n      headers: {\n        'content-type': reply.text !== undefined ? 'text/plain' : 'application/json',\n        'content-length': String(new TextEncoder().encode(text).length),\n        ...reply.headers,\n      },\n    });\n  }) as typeof fetch;\n}\n\n/** A reply that never arrives; rejects with the abort reason when the request is aborted. */\nexport function hang(signal: AbortSignal | undefined): Promise<never> {\n  return new Promise<never>((_resolve, reject) => {\n    if (signal?.aborted) {\n      reject(signal.reason);\n      return;\n    }\n    signal?.addEventListener('abort', () => reject(signal.reason), { once: true });\n  });\n}\n\nexport function rpcResult(request: FakeRequest, result: unknown): FakeReply {\n  return { json: { jsonrpc: '2.0', id: request.json<{ id: unknown }>().id, result } };\n}\n\nexport function rpcError(request: FakeRequest, code: number, message: string): FakeReply {\n  return {\n    json: {\n      jsonrpc: '2.0',\n      id: request.json<{ id: unknown }>().id,\n      error: { code, message },\n    },\n  };\n}\n"]}

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

@@ -0,0 +1,30 @@
+import type { AdapterManifest } from '../core/driver/types';
+import type { Plugin } from '../core/registry/plugin';
+import type { FakeExt, FakeNativeClient } from './fake-driver';
+declare module '../index' {
+    interface ChainRegistry {
+        fakechain: {
+            family: 'fake';
+            network: 'local';
+        };
+        fakeexpiry: {
+            family: 'fake';
+            network: 'local';
+        };
+        fakeseqno: {
+            family: 'fake';
+            network: 'local';
+        };
+    }
+    interface FamilyRegistry {
+        fake: {
+            library: 'fake-sdk';
+            ext: FakeExt;
+        };
+    }
+    interface NativeClientMap {
+        'fake-sdk': FakeNativeClient;
+    }
+}
+export declare const fakeManifest: AdapterManifest;
+export declare function fakePlugin(): Plugin;

package/dist/testing/fake-plugin.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fakeManifest = void 0;
+exports.fakePlugin = fakePlugin;
+const network = (extra = {}) => ({
+    id: 'local',
+    identity: 'fake-local',
+    testnet: true,
+    feeModel: 'fake',
+    finality: { kind: 'tag', tag: 'finalized', fallbackConfirmations: 3 },
+    defaultConfirmations: 2,
+    reorgWindow: 16,
+    maxLagBlocks: 2,
+    replacement: { minBumpPercent: 10 },
+    explorer: {
+        tx: 'https://explorer.fake/tx/{id}',
+        address: 'https://explorer.fake/address/{address}',
+    },
+    ...extra,
+});
+const chain = (id, ordering, extra = {}) => ({
+    id,
+    family: 'fake',
+    model: 'account',
+    ordering,
+    schemes: ['secp256k1-ecdsa'],
+    nativeAsset: { symbol: 'FAKE', decimals: 8, name: 'Fake coin' },
+    defaultNetwork: 'local',
+    networks: { local: network(extra) },
+});
+exports.fakeManifest = {
+    family: 'fake',
+    library: 'fake-sdk',
+    chains: ['fakechain', 'fakeexpiry', 'fakeseqno'],
+    capabilities: [
+        'memo',
+        'block-scan',
+        'replace-fee',
+        'cancel',
+        'finality-tag',
+        'hd-public-derivation',
+    ],
+    peerDependencies: [],
+    load: async () => {
+        // Mirrors real adapters: the driver module is only loaded on first use.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const mod = require('./fake-driver');
+        return mod.fakeDriverFactory;
+    },
+};
+function fakePlugin() {
+    return {
+        name: 'fake',
+        chains: [
+            chain('fakechain', 'nonce'),
+            chain('fakeexpiry', 'expiry', {
+                capabilities: { add: ['expiry'], remove: ['replace-fee', 'cancel'] },
+            }),
+            chain('fakeseqno', 'seqno', {
+                capabilities: { remove: ['replace-fee', 'cancel'] },
+            }),
+        ],
+        adapters: [exports.fakeManifest],
+    };
+}
+//# sourceMappingURL=fake-plugin.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fake-plugin.js","sourceRoot":"","sources":["../../src/testing/fake-plugin.ts"],"names":[],"mappings":";;;AA2EA,gCAcC;AAnED,MAAM,OAAO,GAAG,CAAC,QAA8B,EAAE,EAAe,EAAE,CAAC,CAAC;IAClE,EAAE,EAAE,OAAO;IACX,QAAQ,EAAE,YAAY;IACtB,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,MAAM;IAChB,QAAQ,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,qBAAqB,EAAE,CAAC,EAAE;IACrE,oBAAoB,EAAE,CAAC;IACvB,WAAW,EAAE,EAAE;IACf,YAAY,EAAE,CAAC;IACf,WAAW,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE;IACnC,QAAQ,EAAE;QACR,EAAE,EAAE,+BAA+B;QACnC,OAAO,EAAE,yCAAyC;KACnD;IACD,GAAG,KAAK;CACT,CAAC,CAAC;AAEH,MAAM,KAAK,GAAG,CACZ,EAAU,EACV,QAA+B,EAC/B,QAA8B,EAAE,EACrB,EAAE,CAAC,CAAC;IACf,EAAE;IACF,MAAM,EAAE,MAAM;IACd,KAAK,EAAE,SAAS;IAChB,QAAQ;IACR,OAAO,EAAE,CAAC,iBAAiB,CAAC;IAC5B,WAAW,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE;IAC/D,cAAc,EAAE,OAAO;IACvB,QAAQ,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE;CACpC,CAAC,CAAC;AAEU,QAAA,YAAY,GAAoB;IAC3C,MAAM,EAAE,MAAM;IACd,OAAO,EAAE,UAAU;IACnB,MAAM,EAAE,CAAC,WAAW,EAAE,YAAY,EAAE,WAAW,CAAC;IAChD,YAAY,EAAE;QACZ,MAAM;QACN,YAAY;QACZ,aAAa;QACb,QAAQ;QACR,cAAc;QACd,sBAAsB;KACvB;IACD,gBAAgB,EAAE,EAAE;IACpB,IAAI,EAAE,KAAK,IAA4B,EAAE;QACvC,wEAAwE;QACxE,iEAAiE;QACjE,MAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAmC,CAAC;QACvE,OAAO,GAAG,CAAC,iBAAiB,CAAC;IAC/B,CAAC;CACF,CAAC;AAEF,SAAgB,UAAU;IACxB,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE;YACN,KAAK,CAAC,WAAW,EAAE,OAAO,CAAC;YAC3B,KAAK,CAAC,YAAY,EAAE,QAAQ,EAAE;gBAC5B,YAAY,EAAE,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC,aAAa,EAAE,QAAQ,CAAC,EAAE;aACrE,CAAC;YACF,KAAK,CAAC,WAAW,EAAE,OAAO,EAAE;gBAC1B,YAAY,EAAE,EAAE,MAAM,EAAE,CAAC,aAAa,EAAE,QAAQ,CAAC,EAAE;aACpD,CAAC;SACH;QACD,QAAQ,EAAE,CAAC,oBAAY,CAAC;KACzB,CAAC;AACJ,CAAC","sourcesContent":["import type { AdapterManifest, DriverFactory } from '../core/driver/types';\nimport type { ChainInfo, NetworkInfo } from '../core/model/chain';\nimport type { Plugin } from '../core/registry/plugin';\nimport type { FakeExt, FakeNativeClient } from './fake-driver';\n\n// Augment the registries through the public entry module, as users do with\n// 'crypto-aio'. Augmenting core/model/ids directly makes a user's own augmentation depend on\n// the order in which the compiler reads files.\ndeclare module '../index' {\n  interface ChainRegistry {\n    fakechain: { family: 'fake'; network: 'local' };\n    fakeexpiry: { family: 'fake'; network: 'local' };\n    fakeseqno: { family: 'fake'; network: 'local' };\n  }\n  interface FamilyRegistry {\n    fake: { library: 'fake-sdk'; ext: FakeExt };\n  }\n  interface NativeClientMap {\n    'fake-sdk': FakeNativeClient;\n  }\n}\n\nconst network = (extra: Partial<NetworkInfo> = {}): NetworkInfo => ({\n  id: 'local',\n  identity: 'fake-local',\n  testnet: true,\n  feeModel: 'fake',\n  finality: { kind: 'tag', tag: 'finalized', fallbackConfirmations: 3 },\n  defaultConfirmations: 2,\n  reorgWindow: 16,\n  maxLagBlocks: 2,\n  replacement: { minBumpPercent: 10 },\n  explorer: {\n    tx: 'https://explorer.fake/tx/{id}',\n    address: 'https://explorer.fake/address/{address}',\n  },\n  ...extra,\n});\n\nconst chain = (\n  id: string,\n  ordering: ChainInfo['ordering'],\n  extra: Partial<NetworkInfo> = {},\n): ChainInfo => ({\n  id,\n  family: 'fake',\n  model: 'account',\n  ordering,\n  schemes: ['secp256k1-ecdsa'],\n  nativeAsset: { symbol: 'FAKE', decimals: 8, name: 'Fake coin' },\n  defaultNetwork: 'local',\n  networks: { local: network(extra) },\n});\n\nexport const fakeManifest: AdapterManifest = {\n  family: 'fake',\n  library: 'fake-sdk',\n  chains: ['fakechain', 'fakeexpiry', 'fakeseqno'],\n  capabilities: [\n    'memo',\n    'block-scan',\n    'replace-fee',\n    'cancel',\n    'finality-tag',\n    'hd-public-derivation',\n  ],\n  peerDependencies: [],\n  load: async (): Promise<DriverFactory> => {\n    // Mirrors real adapters: the driver module is only loaded on first use.\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const mod = require('./fake-driver') as typeof import('./fake-driver');\n    return mod.fakeDriverFactory;\n  },\n};\n\nexport function fakePlugin(): Plugin {\n  return {\n    name: 'fake',\n    chains: [\n      chain('fakechain', 'nonce'),\n      chain('fakeexpiry', 'expiry', {\n        capabilities: { add: ['expiry'], remove: ['replace-fee', 'cancel'] },\n      }),\n      chain('fakeseqno', 'seqno', {\n        capabilities: { remove: ['replace-fee', 'cancel'] },\n      }),\n    ],\n    adapters: [fakeManifest],\n  };\n}\n"]}

package/dist/testing/faulty-store.d.ts

@@ -0,0 +1,38 @@
+import type { AttemptObservation, AttemptRecord, CreateResult, Fence, NewOperation, OperationFilter, OperationPatch, OperationRecord, OperationStore } from '../core/store/types';
+export declare class CrashError extends Error {
+    constructor();
+}
+export interface FaultPoint {
+    readonly method: 'create' | 'update' | 'appendAttempt' | 'putObservation';
+    /**
+     * Receives the method's arguments, which differ by method; defaults to "always".
+     * - `create`: `[operation]`
+     * - `update`: `[namespace, id, patch, expectedVersion]` (the patch is `args[2]`)
+     * - `appendAttempt`: `[namespace, id, attempt, patch]`, without `expectedVersion`, so the
+     *   patch is `args[3]` and `args[2]` is the Attempt
+     * - `putObservation`: `[observation]`
+     */
+    readonly when?: (args: readonly unknown[]) => boolean;
+    /** `before`: the write never happens. `after`: the write happens, then the process "dies". */
+    readonly timing: 'before' | 'after';
+}
+/** Wraps a store and throws `CrashError` at chosen write boundaries (one-shot faults). */
+export declare class FaultyOperationStore implements OperationStore {
+    #private;
+    private readonly inner;
+    /** The inner store's `purge`, when it has one. */
+    readonly purge?: (filter: OperationFilter) => Promise<number>;
+    constructor(inner: OperationStore);
+    crashOn(fault: FaultPoint): void;
+    create(operation: NewOperation): Promise<CreateResult>;
+    get(namespace: string, id: string): Promise<OperationRecord | null>;
+    getByKey(namespace: string, key: string): Promise<OperationRecord | null>;
+    findByRef(namespace: string, ref: string): Promise<OperationRecord | null>;
+    update(namespace: string, id: string, patch: OperationPatch, expectedVersion: number, fence?: Fence): Promise<OperationRecord>;
+    appendAttempt(namespace: string, id: string, attempt: AttemptRecord, patch: OperationPatch, expectedVersion: number, fence?: Fence): Promise<OperationRecord>;
+    getObservation(attemptId: string): Promise<AttemptObservation | null>;
+    putObservation(observation: Omit<AttemptObservation, 'version'>, expectedVersion: number | null): Promise<AttemptObservation>;
+    claimDue(namespace: string, workerId: string, now: number, leaseMs: number, limit: number): Promise<OperationRecord[]>;
+    releaseClaim(namespace: string, id: string, fence: Fence): Promise<void>;
+    list(filter: OperationFilter): Promise<OperationRecord[]>;
+}

package/dist/testing/faulty-store.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaultyOperationStore = exports.CrashError = void 0;
+class CrashError extends Error {
+    constructor() {
+        super('injected crash');
+        this.name = 'CrashError';
+    }
+}
+exports.CrashError = CrashError;
+/** Wraps a store and throws `CrashError` at chosen write boundaries (one-shot faults). */
+class FaultyOperationStore {
+    inner;
+    #faults = [];
+    /** The inner store's `purge`, when it has one. */
+    purge;
+    constructor(inner) {
+        this.inner = inner;
+        const purge = inner.purge?.bind(inner);
+        if (purge)
+            this.purge = (filter) => purge(filter);
+    }
+    crashOn(fault) {
+        this.#faults.push(fault);
+    }
+    create(operation) {
+        return this.#guard('create', [operation], () => this.inner.create(operation));
+    }
+    get(namespace, id) {
+        return this.inner.get(namespace, id);
+    }
+    getByKey(namespace, key) {
+        return this.inner.getByKey(namespace, key);
+    }
+    findByRef(namespace, ref) {
+        return this.inner.findByRef(namespace, ref);
+    }
+    update(namespace, id, patch, expectedVersion, fence) {
+        return this.#guard('update', [namespace, id, patch, expectedVersion], () => this.inner.update(namespace, id, patch, expectedVersion, fence));
+    }
+    appendAttempt(namespace, id, attempt, patch, expectedVersion, fence) {
+        return this.#guard('appendAttempt', [namespace, id, attempt, patch], () => this.inner.appendAttempt(namespace, id, attempt, patch, expectedVersion, fence));
+    }
+    getObservation(attemptId) {
+        return this.inner.getObservation(attemptId);
+    }
+    putObservation(observation, expectedVersion) {
+        return this.#guard('putObservation', [observation], () => this.inner.putObservation(observation, expectedVersion));
+    }
+    claimDue(namespace, workerId, now, leaseMs, limit) {
+        return this.inner.claimDue(namespace, workerId, now, leaseMs, limit);
+    }
+    releaseClaim(namespace, id, fence) {
+        return this.inner.releaseClaim(namespace, id, fence);
+    }
+    list(filter) {
+        return this.inner.list(filter);
+    }
+    async #guard(method, args, run) {
+        const index = this.#faults.findIndex((f) => f.method === method && (f.when?.(args) ?? true));
+        if (index < 0)
+            return run();
+        const [fault] = this.#faults.splice(index, 1);
+        if (fault?.timing === 'before')
+            throw new CrashError();
+        await run();
+        throw new CrashError();
+    }
+}
+exports.FaultyOperationStore = FaultyOperationStore;
+//# sourceMappingURL=faulty-store.js.map

package/dist/testing/faulty-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"faulty-store.js","sourceRoot":"","sources":["../../src/testing/faulty-store.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  AttemptObservation,\n  AttemptRecord,\n  CreateResult,\n  Fence,\n  NewOperation,\n  OperationFilter,\n  OperationPatch,\n  OperationRecord,\n  OperationStore,\n} from '../core/store/types';\n\nexport class CrashError extends Error {\n  constructor() {\n    super('injected crash');\n    this.name = 'CrashError';\n  }\n}\n\nexport interface FaultPoint {\n  readonly method: 'create' | 'update' | 'appendAttempt' | 'putObservation';\n  /**\n   * Receives the method's arguments, which differ by method; defaults to \"always\".\n   * - `create`: `[operation]`\n   * - `update`: `[namespace, id, patch, expectedVersion]` (the patch is `args[2]`)\n   * - `appendAttempt`: `[namespace, id, attempt, patch]`, without `expectedVersion`, so the\n   *   patch is `args[3]` and `args[2]` is the Attempt\n   * - `putObservation`: `[observation]`\n   */\n  readonly when?: (args: readonly unknown[]) => boolean;\n  /** `before`: the write never happens. `after`: the write happens, then the process \"dies\". */\n  readonly timing: 'before' | 'after';\n}\n\n/** Wraps a store and throws `CrashError` at chosen write boundaries (one-shot faults). */\nexport class FaultyOperationStore implements OperationStore {\n  readonly #faults: FaultPoint[] = [];\n\n  /** The inner store's `purge`, when it has one. */\n  readonly purge?: (filter: OperationFilter) => Promise<number>;\n\n  constructor(private readonly inner: OperationStore) {\n    const purge = inner.purge?.bind(inner);\n    if (purge) this.purge = (filter) => purge(filter);\n  }\n\n  crashOn(fault: FaultPoint): void {\n    this.#faults.push(fault);\n  }\n\n  create(operation: NewOperation): Promise<CreateResult> {\n    return this.#guard('create', [operation], () => this.inner.create(operation));\n  }\n\n  get(namespace: string, id: string): Promise<OperationRecord | null> {\n    return this.inner.get(namespace, id);\n  }\n\n  getByKey(namespace: string, key: string): Promise<OperationRecord | null> {\n    return this.inner.getByKey(namespace, key);\n  }\n\n  findByRef(namespace: string, ref: string): Promise<OperationRecord | null> {\n    return this.inner.findByRef(namespace, ref);\n  }\n\n  update(\n    namespace: string,\n    id: string,\n    patch: OperationPatch,\n    expectedVersion: number,\n    fence?: Fence,\n  ): Promise<OperationRecord> {\n    return this.#guard('update', [namespace, id, patch, expectedVersion], () =>\n      this.inner.update(namespace, id, patch, expectedVersion, fence),\n    );\n  }\n\n  appendAttempt(\n    namespace: string,\n    id: string,\n    attempt: AttemptRecord,\n    patch: OperationPatch,\n    expectedVersion: number,\n    fence?: Fence,\n  ): Promise<OperationRecord> {\n    return this.#guard('appendAttempt', [namespace, id, attempt, patch], () =>\n      this.inner.appendAttempt(namespace, id, attempt, patch, expectedVersion, fence),\n    );\n  }\n\n  getObservation(attemptId: string): Promise<AttemptObservation | null> {\n    return this.inner.getObservation(attemptId);\n  }\n\n  putObservation(\n    observation: Omit<AttemptObservation, 'version'>,\n    expectedVersion: number | null,\n  ): Promise<AttemptObservation> {\n    return this.#guard('putObservation', [observation], () =>\n      this.inner.putObservation(observation, expectedVersion),\n    );\n  }\n\n  claimDue(\n    namespace: string,\n    workerId: string,\n    now: number,\n    leaseMs: number,\n    limit: number,\n  ): Promise<OperationRecord[]> {\n    return this.inner.claimDue(namespace, workerId, now, leaseMs, limit);\n  }\n\n  releaseClaim(namespace: string, id: string, fence: Fence): Promise<void> {\n    return this.inner.releaseClaim(namespace, id, fence);\n  }\n\n  list(filter: OperationFilter): Promise<OperationRecord[]> {\n    return this.inner.list(filter);\n  }\n\n  async #guard<T>(\n    method: FaultPoint['method'],\n    args: readonly unknown[],\n    run: () => Promise<T>,\n  ): Promise<T> {\n    const index = this.#faults.findIndex(\n      (f) => f.method === method && (f.when?.(args) ?? true),\n    );\n    if (index < 0) return run();\n    const [fault] = this.#faults.splice(index, 1);\n    if (fault?.timing === 'before') throw new CrashError();\n    await run();\n    throw new CrashError();\n  }\n}\n"]}

package/dist/testing/generation.d.ts

@@ -0,0 +1,60 @@
+import type { Signer } from '../core/signing/types';
+import type { Stores } from '../core/store/types';
+import type { Clock } from '../core/util/clock';
+import type { FakeClock } from './fake-clock';
+/**
+ * Flipped to `false` by `restart({ killPrevious: true })`; every wrapper built for this
+ * generation (clock, fetch, the fetched Response's body readers, the shared signer, the store
+ * proxies) checks it both when invoked and when the real call underneath settles, so a dead
+ * generation can neither start nor finish any of them.
+ *
+ * The fence only becomes complete once the microtask queue has drained past the point
+ * where `generation.alive` was flipped. Code from the old generation that was already past a
+ * *settled* fenced call (holding a plain value, not awaiting anything) keeps running
+ * synchronously — nothing here can interrupt a synchronous continuation mid-expression — right
+ * up until it reaches its *next* fenced call, which then never lets it proceed further (or, for
+ * a synchronous wrapped call, throws instead — see `generationProxy`).
+ */
+export interface Generation {
+    alive: boolean;
+}
+/**
+ * Fences one generation's view of the parts every generation shares. A family env builds
+ * each container from the result, never from `parts` directly, and keeps `generation` so a
+ * restart can kill it:
+ *
+ * ```ts
+ * const generation = { alive: true };
+ * const fenced = fenceGeneration(
+ *   { clock, fetch: node.fetch.fetch, stores, signers: { [signer.id]: signer } },
+ *   generation,
+ * );
+ * const aio = new CryptoAio({
+ *   clock: fenced.clock,
+ *   stores: fenced.stores,
+ *   signers: fenced.signers,
+ *   transport: { fetch: fenced.fetch },
+ *   // ...providers, wallets, chains
+ * });
+ * // restart({ killPrevious: true }): kill this generation, then fence a new one over the
+ * // same parts (same clock, node, stores and signer objects).
+ * generation.alive = false;
+ * ```
+ *
+ * Once `generation.alive` is `false`, every clock sleep, fetch (and body read), store call
+ * and signer call of this generation, in flight or issued later, never settles; a
+ * synchronous port method throws `StateError`. `clock.now()` stays live. Keep the raw
+ * `clock` for driving time (`drive`, `advance`, `pending`) and the raw `stores` for test
+ * assertions: they belong to no generation.
+ */
+export declare function fenceGeneration(parts: {
+    readonly clock: FakeClock;
+    readonly fetch: typeof fetch;
+    readonly stores: Stores;
+    readonly signers: Readonly<Record<string, Signer>>;
+}, generation: Generation): {
+    readonly clock: Clock;
+    readonly fetch: typeof fetch;
+    readonly stores: Stores;
+    readonly signers: Readonly<Record<string, Signer>>;
+};

package/dist/testing/generation.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fenceGeneration = fenceGeneration;
+/**
+ * The restart generation fence: `restart({ killPrevious: true })` simulates a
+ * process that died, so nothing the old generation started may make further progress or
+ * write to shared state. `createFakeEnv` uses it, and so does every family's end-to-end env
+ * built on its own scripted node. Test-only: not part of `crypto-aio/testing`.
+ */
+const error_1 = require("../core/errors/error");
+/** Runs `start` unless the generation is already dead, and settles like its result only while
+ * the generation is still alive; otherwise the returned promise never settles. */
+function fenced(generation, start) {
+    return new Promise((resolve, reject) => {
+        if (!generation.alive)
+            return; // never settles: already dead at call time.
+        Promise.resolve(start()).then((value) => {
+            if (generation.alive)
+                resolve(value); // else: never settles, dead before it settled.
+        }, (error) => {
+            if (generation.alive)
+                reject(error);
+        });
+    });
+}
+/** Per-generation clock: `now()` stays live (harmless to read); `sleep()` is fenced. */
+function generationClock(shared, generation) {
+    return {
+        now: () => shared.now(),
+        sleep: (ms, signal) => fenced(generation, () => shared.sleep(ms, signal)),
+    };
+}
+/** Body-reading methods fenced on a fetched Response (`bytes` only where the runtime
+ * has it). `clone()` and `body` are fenced separately; everything else (status, ok, headers,
+ * ...) passes straight through. */
+const FENCED_RESPONSE_READERS = new Set([
+    'text',
+    'json',
+    'arrayBuffer',
+    'blob',
+    'bytes',
+    'formData',
+]);
+/**
+ * A stand-in for `response.body` whose every chunk is pulled from the real body through
+ * the fence, so a `read()` (via `getReader()`, async iteration, `pipeTo`, `tee`, ...) never
+ * settles once the generation is dead. `highWaterMark: 0` means nothing is pulled — and the
+ * real body isn't even locked — until a consumer actually reads, so merely touching `.body`
+ * (e.g. `if (res.body) await res.text()`) still leaves the real body readable by `text()`.
+ */
+function generationBody(body, generation) {
+    let reader;
+    return new ReadableStream({
+        pull: (controller) => fenced(generation, () => (reader ??= body.getReader()).read()).then((chunk) => {
+            if (chunk.done)
+                controller.close();
+            else
+                controller.enqueue(chunk.value);
+        }),
+        cancel: (reason) => (reader ? reader.cancel(reason) : body.cancel(reason)),
+    }, { highWaterMark: 0 });
+}
+/**
+ * Wraps a fetched Response so reading its body is fenced too — once a generation is
+ * dead, every body reader (`text()`, `json()`, `blob()`, ...), a read of the `body` stream,
+ * and the same on any `clone()` of it (itself a fenced Response) must never settle either,
+ * exactly like the fetch call that produced it (a caller may have obtained the Response while
+ * still alive and only read its body afterwards). Every other property or method is bound to
+ * the real `target` (never invoked through the Proxy itself), so a native accessor like
+ * `.ok`/`.status` still sees a genuine `Response` as `this`.
+ */
+function generationResponse(response, generation) {
+    let body;
+    return new Proxy(response, {
+        get(target, prop) {
+            if (prop === 'body') {
+                // Memoized: like the real getter, every access returns the same stream.
+                if (body === undefined)
+                    body = target.body === null ? null : generationBody(target.body, generation);
+                return body;
+            }
+            const value = Reflect.get(target, prop); // no receiver: see generationProxy.
+            if (typeof value !== 'function')
+                return value;
+            const bound = value.bind(target);
+            if (prop === 'clone')
+                return () => generationResponse(target.clone(), generation);
+            if (typeof prop !== 'string' || !FENCED_RESPONSE_READERS.has(prop))
+                return bound;
+            return (...args) => fenced(generation, () => bound(...args));
+        },
+    });
+}
+/** Per-generation fetch, fenced the same way as the clock; the Response it resolves with is
+ * itself fenced, so a body read issued on it after the kill never settles either. */
+function generationFetch(shared, generation) {
+    return ((...args) => fenced(generation, () => shared(...args).then((response) => generationResponse(response, generation))));
+}
+/**
+ * Every async method of the `Stores` ports and of `Signer`. Exhaustive at compile time (a
+ * port method added later fails the build until it's listed here), and independent of how an
+ * implementation spells the method — a non-`async` function returning a Promise counts too.
+ */
+const ASYNC_PORT_METHODS = {
+    create: true,
+    get: true,
+    getByKey: true,
+    findByRef: true,
+    update: true,
+    appendAttempt: true,
+    getObservation: true,
+    putObservation: true,
+    claimDue: true,
+    releaseClaim: true,
+    list: true,
+    purge: true,
+    acquire: true,
+    renew: true,
+    release: true,
+    put: true,
+    getPublicKey: true,
+    sign: true,
+    cancelRequest: true,
+    exportKey: true,
+};
+/**
+ * Diagnostics that must keep working on a dead proxy (`JSON.stringify`, `util.inspect`).
+ */
+const PASSTHROUGH = new Set([
+    'toJSON',
+    'inspect',
+    Symbol.for('nodejs.util.inspect.custom'),
+]);
+function isAsyncMethod(prop, fn) {
+    return ((typeof prop === 'string' && Object.hasOwn(ASYNC_PORT_METHODS, prop)) ||
+        Object.prototype.toString.call(fn) === '[object AsyncFunction]');
+}
+/**
+ * Wraps every method of `target` so a generation's death fences it, and generalizes the
+ * old `generationStore` to any shared object with async methods (`Stores`, `Signer`). An async
+ * method (a port method named in `ASYNC_PORT_METHODS`, or a native `async` function) is
+ * fenced the way `sleep`/`fetch` are: once the generation is dead it never settles and never
+ * throws, whether it was already in flight or is only called afterwards. A genuinely
+ * synchronous method throws `StateError` when called on an already-dead generation — there's
+ * no "never resolve" for a call that must return synchronously. `toJSON`/`inspect` pass
+ * through unfenced.
+ */
+function generationProxy(target, generation) {
+    // The Proxy wraps an empty, extensible stand-in, never `target` itself: a frozen target
+    // (e.g. a `callbackSigner`) has non-configurable read-only properties, and the Proxy
+    // invariants would then forbid returning the fenced wrapper instead of the real value.
+    // Every read is forwarded to the real object; descriptors are reported configurable.
+    // Writes are refused loudly: they would otherwise land silently on the stand-in.
+    const refuse = (trap) => {
+        throw new TypeError(`crypto-aio/testing: '${trap}' is not supported on a fenced object`);
+    };
+    return new Proxy({}, {
+        set: () => refuse('set'),
+        defineProperty: () => refuse('defineProperty'),
+        deleteProperty: () => refuse('deleteProperty'),
+        has: (_stand, prop) => Reflect.has(target, prop),
+        ownKeys: () => Reflect.ownKeys(target),
+        getPrototypeOf: () => Reflect.getPrototypeOf(target),
+        getOwnPropertyDescriptor: (_stand, prop) => {
+            const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+            return descriptor ? { ...descriptor, configurable: true } : undefined;
+        },
+        get(_stand, prop) {
+            // No receiver, so a native/data getter runs with the real target as `this`.
+            const value = Reflect.get(target, prop);
+            if (typeof value !== 'function')
+                return value;
+            const fn = value;
+            if (PASSTHROUGH.has(prop))
+                return fn.bind(target);
+            const isAsync = isAsyncMethod(prop, fn);
+            return (...args) => {
+                if (!generation.alive) {
+                    // A call issued once the generation is already dead never invokes the real method
+                    // (no side effect from a dead continuation). An async one just never settles; a
+                    // synchronous one can't be left "hanging", so it fails fast instead.
+                    if (isAsync)
+                        return new Promise(() => undefined);
+                    throw new error_1.StateError('INVALID_TRANSITION', 'crypto-aio/testing: this generation was killed by restart({ killPrevious: true })');
+                }
+                const result = fn.apply(target, args);
+                const thenable = typeof result === 'object' &&
+                    result !== null &&
+                    typeof result.then === 'function';
+                if (!thenable)
+                    return result; // A synchronous result passes straight through.
+                return fenced(generation, () => result);
+            };
+        },
+    });
+}
+function generationStores(stores, generation) {
+    return {
+        operations: generationProxy(stores.operations, generation),
+        locks: generationProxy(stores.locks, generation),
+        sequences: generationProxy(stores.sequences, generation),
+        cursors: generationProxy(stores.cursors, generation),
+    };
+}
+/** The shared signer (see the doc comment on `signers` in `assemble`, `env.ts` — it's
+ * stateless and never rebuilt across generations) still has its `sign`/`getPublicKey` calls
+ * fenced per generation, the same as any other in-flight call; the underlying `Signer`
+ * instance is unchanged, just wrapped. */
+function generationSigner(shared, generation) {
+    return generationProxy(shared, generation);
+}
+/**
+ * Fences one generation's view of the parts every generation shares. A family env builds
+ * each container from the result, never from `parts` directly, and keeps `generation` so a
+ * restart can kill it:
+ *
+ * ```ts
+ * const generation = { alive: true };
+ * const fenced = fenceGeneration(
+ *   { clock, fetch: node.fetch.fetch, stores, signers: { [signer.id]: signer } },
+ *   generation,
+ * );
+ * const aio = new CryptoAio({
+ *   clock: fenced.clock,
+ *   stores: fenced.stores,
+ *   signers: fenced.signers,
+ *   transport: { fetch: fenced.fetch },
+ *   // ...providers, wallets, chains
+ * });
+ * // restart({ killPrevious: true }): kill this generation, then fence a new one over the
+ * // same parts (same clock, node, stores and signer objects).
+ * generation.alive = false;
+ * ```
+ *
+ * Once `generation.alive` is `false`, every clock sleep, fetch (and body read), store call
+ * and signer call of this generation, in flight or issued later, never settles; a
+ * synchronous port method throws `StateError`. `clock.now()` stays live. Keep the raw
+ * `clock` for driving time (`drive`, `advance`, `pending`) and the raw `stores` for test
+ * assertions: they belong to no generation.
+ */
+function fenceGeneration(parts, generation) {
+    return {
+        clock: generationClock(parts.clock, generation),
+        fetch: generationFetch(parts.fetch, generation),
+        stores: generationStores(parts.stores, generation),
+        signers: Object.fromEntries(Object.entries(parts.signers).map(([id, signer]) => [
+            id,
+            generationSigner(signer, generation),
+        ])),
+    };
+}
+//# sourceMappingURL=generation.js.map