crypto-aio 0.0.3 → 0.1.0

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

package/dist/testing/generation.js.map

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

package/dist/testing/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `crypto-aio/testing`: a deterministic, network-free test kit (fake chain, fetch and clock,
+ * a crash-injecting store, a ready-made environment) and the store contract suites that any
+ * `OperationStore`, `LockManager`, `SequenceStore` or `CursorStore` implementation must pass.
+ *
+ * @module crypto-aio/testing
+ */
+export { FakeClock, drive, settle } from './fake-clock';
+export { FakeFetch, hang, rpcError, rpcResult } from './fake-fetch';
+export type { FakeHandler, FakeReply, FakeRequest, RecordedCall } from './fake-fetch';
+export { FakeChain, REVERT_ADDRESS, decodeEnvelope, encodeEnvelope, fakeAddress, fakeDigest, fakeTxId, isFakeAddress, signFake, } from './fake-chain';
+export type { FakeChainOptions, FakeEndpointOptions, FakeEnvelope, FakeOrdering, FakeReceipt, FakeUnsigned, FakeWireBlock, FakeWireTx, } from './fake-chain';
+export { fakeManifest, fakePlugin } from './fake-plugin';
+export type { FakeExt, FakeNativeClient } from './fake-driver';
+export { createFakeEnv } from './env';
+export type { FakeChainId, FakeEnv, FakeEnvOptions } from './env';
+export { CrashError, FaultyOperationStore } from './faulty-store';
+export type { FaultPoint } from './faulty-store';
+export { rejectsWithCode } from './contracts/api';
+export type { ContractTestApi } from './contracts/api';
+export { describeLockManagerContract } from './contracts/locks';
+export type { LockHarness } from './contracts/locks';
+export { describeSequenceStoreContract } from './contracts/sequences';
+export type { SequenceHarness } from './contracts/sequences';
+export { describeCursorStoreContract } from './contracts/cursors';
+export type { CursorHarness } from './contracts/cursors';
+export { SAMPLE_ORDERINGS, describeOperationStoreContract, sampleAttempt, sampleOperation, } from './contracts/operations';
+export type { OperationHarness } from './contracts/operations';

package/dist/testing/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sampleOperation = exports.sampleAttempt = exports.describeOperationStoreContract = exports.SAMPLE_ORDERINGS = exports.describeCursorStoreContract = exports.describeSequenceStoreContract = exports.describeLockManagerContract = exports.rejectsWithCode = exports.FaultyOperationStore = exports.CrashError = exports.createFakeEnv = exports.fakePlugin = exports.fakeManifest = exports.signFake = exports.isFakeAddress = exports.fakeTxId = exports.fakeDigest = exports.fakeAddress = exports.encodeEnvelope = exports.decodeEnvelope = exports.REVERT_ADDRESS = exports.FakeChain = exports.rpcResult = exports.rpcError = exports.hang = exports.FakeFetch = exports.settle = exports.drive = exports.FakeClock = void 0;
+/**
+ * `crypto-aio/testing`: a deterministic, network-free test kit (fake chain, fetch and clock,
+ * a crash-injecting store, a ready-made environment) and the store contract suites that any
+ * `OperationStore`, `LockManager`, `SequenceStore` or `CursorStore` implementation must pass.
+ *
+ * @module crypto-aio/testing
+ */
+var fake_clock_1 = require("./fake-clock");
+Object.defineProperty(exports, "FakeClock", { enumerable: true, get: function () { return fake_clock_1.FakeClock; } });
+Object.defineProperty(exports, "drive", { enumerable: true, get: function () { return fake_clock_1.drive; } });
+Object.defineProperty(exports, "settle", { enumerable: true, get: function () { return fake_clock_1.settle; } });
+var fake_fetch_1 = require("./fake-fetch");
+Object.defineProperty(exports, "FakeFetch", { enumerable: true, get: function () { return fake_fetch_1.FakeFetch; } });
+Object.defineProperty(exports, "hang", { enumerable: true, get: function () { return fake_fetch_1.hang; } });
+Object.defineProperty(exports, "rpcError", { enumerable: true, get: function () { return fake_fetch_1.rpcError; } });
+Object.defineProperty(exports, "rpcResult", { enumerable: true, get: function () { return fake_fetch_1.rpcResult; } });
+var fake_chain_1 = require("./fake-chain");
+Object.defineProperty(exports, "FakeChain", { enumerable: true, get: function () { return fake_chain_1.FakeChain; } });
+Object.defineProperty(exports, "REVERT_ADDRESS", { enumerable: true, get: function () { return fake_chain_1.REVERT_ADDRESS; } });
+Object.defineProperty(exports, "decodeEnvelope", { enumerable: true, get: function () { return fake_chain_1.decodeEnvelope; } });
+Object.defineProperty(exports, "encodeEnvelope", { enumerable: true, get: function () { return fake_chain_1.encodeEnvelope; } });
+Object.defineProperty(exports, "fakeAddress", { enumerable: true, get: function () { return fake_chain_1.fakeAddress; } });
+Object.defineProperty(exports, "fakeDigest", { enumerable: true, get: function () { return fake_chain_1.fakeDigest; } });
+Object.defineProperty(exports, "fakeTxId", { enumerable: true, get: function () { return fake_chain_1.fakeTxId; } });
+Object.defineProperty(exports, "isFakeAddress", { enumerable: true, get: function () { return fake_chain_1.isFakeAddress; } });
+Object.defineProperty(exports, "signFake", { enumerable: true, get: function () { return fake_chain_1.signFake; } });
+var fake_plugin_1 = require("./fake-plugin");
+Object.defineProperty(exports, "fakeManifest", { enumerable: true, get: function () { return fake_plugin_1.fakeManifest; } });
+Object.defineProperty(exports, "fakePlugin", { enumerable: true, get: function () { return fake_plugin_1.fakePlugin; } });
+var env_1 = require("./env");
+Object.defineProperty(exports, "createFakeEnv", { enumerable: true, get: function () { return env_1.createFakeEnv; } });
+var faulty_store_1 = require("./faulty-store");
+Object.defineProperty(exports, "CrashError", { enumerable: true, get: function () { return faulty_store_1.CrashError; } });
+Object.defineProperty(exports, "FaultyOperationStore", { enumerable: true, get: function () { return faulty_store_1.FaultyOperationStore; } });
+var api_1 = require("./contracts/api");
+Object.defineProperty(exports, "rejectsWithCode", { enumerable: true, get: function () { return api_1.rejectsWithCode; } });
+var locks_1 = require("./contracts/locks");
+Object.defineProperty(exports, "describeLockManagerContract", { enumerable: true, get: function () { return locks_1.describeLockManagerContract; } });
+var sequences_1 = require("./contracts/sequences");
+Object.defineProperty(exports, "describeSequenceStoreContract", { enumerable: true, get: function () { return sequences_1.describeSequenceStoreContract; } });
+var cursors_1 = require("./contracts/cursors");
+Object.defineProperty(exports, "describeCursorStoreContract", { enumerable: true, get: function () { return cursors_1.describeCursorStoreContract; } });
+var operations_1 = require("./contracts/operations");
+Object.defineProperty(exports, "SAMPLE_ORDERINGS", { enumerable: true, get: function () { return operations_1.SAMPLE_ORDERINGS; } });
+Object.defineProperty(exports, "describeOperationStoreContract", { enumerable: true, get: function () { return operations_1.describeOperationStoreContract; } });
+Object.defineProperty(exports, "sampleAttempt", { enumerable: true, get: function () { return operations_1.sampleAttempt; } });
+Object.defineProperty(exports, "sampleOperation", { enumerable: true, get: function () { return operations_1.sampleOperation; } });
+//# sourceMappingURL=index.js.map

package/dist/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACH,2CAAwD;AAA/C,uGAAA,SAAS,OAAA;AAAE,mGAAA,KAAK,OAAA;AAAE,oGAAA,MAAM,OAAA;AACjC,2CAAoE;AAA3D,uGAAA,SAAS,OAAA;AAAE,kGAAA,IAAI,OAAA;AAAE,sGAAA,QAAQ,OAAA;AAAE,uGAAA,SAAS,OAAA;AAE7C,2CAUsB;AATpB,uGAAA,SAAS,OAAA;AACT,4GAAA,cAAc,OAAA;AACd,4GAAA,cAAc,OAAA;AACd,4GAAA,cAAc,OAAA;AACd,yGAAA,WAAW,OAAA;AACX,wGAAA,UAAU,OAAA;AACV,sGAAA,QAAQ,OAAA;AACR,2GAAA,aAAa,OAAA;AACb,sGAAA,QAAQ,OAAA;AAYV,6CAAyD;AAAhD,2GAAA,YAAY,OAAA;AAAE,yGAAA,UAAU,OAAA;AAEjC,6BAAsC;AAA7B,oGAAA,aAAa,OAAA;AAEtB,+CAAkE;AAAzD,0GAAA,UAAU,OAAA;AAAE,oHAAA,oBAAoB,OAAA;AAEzC,uCAAkD;AAAzC,sGAAA,eAAe,OAAA;AAExB,2CAAgE;AAAvD,oHAAA,2BAA2B,OAAA;AAEpC,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+CAAkE;AAAzD,sHAAA,2BAA2B,OAAA;AAEpC,qDAKgC;AAJ9B,8GAAA,gBAAgB,OAAA;AAChB,4HAAA,8BAA8B,OAAA;AAC9B,2GAAA,aAAa,OAAA;AACb,6GAAA,eAAe,OAAA","sourcesContent":["/**\n * `crypto-aio/testing`: a deterministic, network-free test kit (fake chain, fetch and clock,\n * a crash-injecting store, a ready-made environment) and the store contract suites that any\n * `OperationStore`, `LockManager`, `SequenceStore` or `CursorStore` implementation must pass.\n *\n * @module crypto-aio/testing\n */\nexport { FakeClock, drive, settle } from './fake-clock';\nexport { FakeFetch, hang, rpcError, rpcResult } from './fake-fetch';\nexport type { FakeHandler, FakeReply, FakeRequest, RecordedCall } from './fake-fetch';\nexport {\n  FakeChain,\n  REVERT_ADDRESS,\n  decodeEnvelope,\n  encodeEnvelope,\n  fakeAddress,\n  fakeDigest,\n  fakeTxId,\n  isFakeAddress,\n  signFake,\n} from './fake-chain';\nexport type {\n  FakeChainOptions,\n  FakeEndpointOptions,\n  FakeEnvelope,\n  FakeOrdering,\n  FakeReceipt,\n  FakeUnsigned,\n  FakeWireBlock,\n  FakeWireTx,\n} from './fake-chain';\nexport { fakeManifest, fakePlugin } from './fake-plugin';\nexport type { FakeExt, FakeNativeClient } from './fake-driver';\nexport { createFakeEnv } from './env';\nexport type { FakeChainId, FakeEnv, FakeEnvOptions } from './env';\nexport { CrashError, FaultyOperationStore } from './faulty-store';\nexport type { FaultPoint } from './faulty-store';\nexport { rejectsWithCode } from './contracts/api';\nexport type { ContractTestApi } from './contracts/api';\nexport { describeLockManagerContract } from './contracts/locks';\nexport type { LockHarness } from './contracts/locks';\nexport { describeSequenceStoreContract } from './contracts/sequences';\nexport type { SequenceHarness } from './contracts/sequences';\nexport { describeCursorStoreContract } from './contracts/cursors';\nexport type { CursorHarness } from './contracts/cursors';\nexport {\n  SAMPLE_ORDERINGS,\n  describeOperationStoreContract,\n  sampleAttempt,\n  sampleOperation,\n} from './contracts/operations';\nexport type { OperationHarness } from './contracts/operations';\n"]}

package/package.json

@@ -1,70 +1,213 @@
 {
   "name": "crypto-aio",
-  "version": "0.0.3",
-  "description": "All-In-One Crypto-Currency for Backend",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "debug": "jest --watch",
-    "prebuild": "rimraf dist",
-    "doc": "typedoc --out docs src/",
-    "build": "tsc -p ./tsconfig.json",
-    "clean": "rm -rf ./dist && rm -rf ./docs",
-    "lint": "eslint . '*/**/*.{js,ts}' --quiet --fix",
-    "fresh": "npm run clean && npm run doc && npm run test",
-    "format": "prettier --write \"(src|test)/**/*.(ts|js)\"",
-    "start:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register src/index.ts",
-    "test": "jest && make-coverage-badge --report-path docs/coverage/coverage-summary.json --output-path docs/coverage.svg"
-  },
+  "version": "0.1.0",
+  "description": "Blockchain abstraction layer for exchanges, wallets and payment infrastructure: one consistent API over EVM, Tron, Bitcoin, Solana, TON and Avalanche SDKs",
+  "license": "MIT",
+  "author": "Vahid V. <vhid.vz@gmail.com>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vhidvz/crypto-aio.git"
   },
-  "author": "Vahid V. <vhid.vz@gmail.com>",
-  "license": "MIT",
   "bugs": {
     "url": "https://github.com/vhidvz/crypto-aio/issues"
   },
   "keywords": [
-    "bitcoin",
+    "blockchain",
+    "crypto",
+    "exchange",
+    "wallet",
     "ethereum",
-    "solana",
+    "bitcoin",
     "tron",
-    "ton"
+    "solana",
+    "ton",
+    "avalanche",
+    "evm"
   ],
   "homepage": "https://github.com/vhidvz/crypto-aio#readme",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint .",
+    "prepare": "echo -e prepare for development by: pnpm run husky",
+    "format": "prettier --write \"{src,test}/**/*.ts\" \"*.{js,mjs}\" \"scripts/*.mjs\" \"docs/.vitepress/**/*.{mts,ts,vue,css}\"",
+    "format:check": "prettier --check \"{src,test}/**/*.ts\" \"*.{js,mjs}\" \"scripts/*.mjs\" \"docs/.vitepress/**/*.{mts,ts,vue,css}\"",
+    "test": "jest",
+    "husky": "husky",
+    "test:coverage": "jest --coverage && pnpm run make-coverage-badge",
+    "test:pack": "pnpm run build && node scripts/pack-check.mjs",
+    "doc": "typedoc",
+    "docs:dev": "pnpm doc && vitepress dev docs",
+    "docs:build": "pnpm doc && vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "check": "pnpm run lint && pnpm run typecheck && pnpm test",
+    "make-coverage-badge": "make-coverage-badge --report-path coverage/coverage-summary.json --output-path coverage-badge.svg"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "pnpm run format",
+      "pnpm run lint"
+    ]
+  },
   "dependencies": {
-    "debug": "^4.3.7",
-    "ethers": "^6.13.4",
-    "tronweb": "^6.0.0",
-    "web3": "^4.14.0"
+    "@noble/curves": "^1.9.7",
+    "@noble/hashes": "^1.8.0",
+    "@scure/base": "^1.2.6",
+    "@scure/bip32": "^1.7.0",
+    "@scure/bip39": "^1.6.0",
+    "debug": "^4.4.3"
   },
   "devDependencies": {
-    "@types/debug": "^4.1.12",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^20.12.11",
-    "@typescript-eslint/eslint-plugin": "^7.8.0",
-    "@typescript-eslint/parser": "^7.8.0",
-    "dotenv": "^16.4.5",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "jest": "^29.7.0",
-    "jshint": "^2.13.6",
+    "@avalabs/avalanchejs": "5.2.0",
+    "@eslint/js": "^9.39.5",
+    "@solana/web3.js": "1.99.0",
+    "@ton/core": "0.63.1",
+    "@ton/crypto": "3.3.0",
+    "@ton/ton": "16.3.0",
+    "@types/debug": "^4.1.13",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.20.4",
+    "bitcoinjs-lib": "7.0.2",
+    "eslint": "^9.39.5",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.6",
+    "ethers": "6.17.0",
+    "husky": "^9.1.7",
+    "jest": "^30.5.2",
+    "lint-staged": "^17.6.0",
     "make-coverage-badge": "^1.2.0",
-    "prettier": "^3.2.5",
-    "rimraf": "^5.0.5",
-    "ts-jest": "^29.1.2",
-    "ts-node": "^10.9.2",
-    "tsconfig-paths": "^4.2.0",
-    "typedoc": "^0.25.13",
-    "typescript": "^5.4.5"
+    "mermaid": "^11.17.2",
+    "prettier": "^3.9.8",
+    "rimraf": "^6.1.3",
+    "tronweb": "6.5.1",
+    "ts-jest": "29.4.12",
+    "typedoc": "^0.28.20",
+    "typedoc-plugin-markdown": "^4.13.1",
+    "typescript": "5.9.3",
+    "typescript-eslint": "^8.70.1",
+    "vitepress": "^1.6.4",
+    "web3": "4.16.0"
+  },
+  "peerDependencies": {
+    "@avalabs/avalanchejs": "^5.2.0",
+    "@solana/web3.js": "^1.99.0",
+    "@ton/core": "^0.63.1",
+    "@ton/crypto": "^3.3.0",
+    "@ton/ton": "^16.3.0",
+    "bitcoinjs-lib": "^7.0.2",
+    "ethers": "^6.17.0",
+    "tronweb": "^6.5.1",
+    "web3": "^4.16.0"
+  },
+  "peerDependenciesMeta": {
+    "@avalabs/avalanchejs": {
+      "optional": true
+    },
+    "@solana/web3.js": {
+      "optional": true
+    },
+    "@ton/core": {
+      "optional": true
+    },
+    "@ton/crypto": {
+      "optional": true
+    },
+    "@ton/ton": {
+      "optional": true
+    },
+    "bitcoinjs-lib": {
+      "optional": true
+    },
+    "ethers": {
+      "optional": true
+    },
+    "tronweb": {
+      "optional": true
+    },
+    "web3": {
+      "optional": true
+    }
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "files": [
-    "/dist"
-  ]
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./avalanche": {
+      "types": "./dist/adapters/avalanche/index.d.ts",
+      "default": "./dist/adapters/avalanche/index.js"
+    },
+    "./evm": {
+      "types": "./dist/adapters/evm/index.d.ts",
+      "default": "./dist/adapters/evm/index.js"
+    },
+    "./native": {
+      "types": "./dist/native.d.ts",
+      "default": "./dist/native.js"
+    },
+    "./solana": {
+      "types": "./dist/adapters/solana/index.d.ts",
+      "default": "./dist/adapters/solana/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "default": "./dist/testing/index.js"
+    },
+    "./ton": {
+      "types": "./dist/adapters/ton/index.d.ts",
+      "default": "./dist/adapters/ton/index.js"
+    },
+    "./tron": {
+      "types": "./dist/adapters/tron/index.d.ts",
+      "default": "./dist/adapters/tron/index.js"
+    },
+    "./utxo": {
+      "types": "./dist/adapters/utxo/index.d.ts",
+      "default": "./dist/adapters/utxo/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "avalanche": [
+        "dist/adapters/avalanche/index.d.ts"
+      ],
+      "evm": [
+        "dist/adapters/evm/index.d.ts"
+      ],
+      "native": [
+        "dist/native.d.ts"
+      ],
+      "solana": [
+        "dist/adapters/solana/index.d.ts"
+      ],
+      "testing": [
+        "dist/testing/index.d.ts"
+      ],
+      "ton": [
+        "dist/adapters/ton/index.d.ts"
+      ],
+      "tron": [
+        "dist/adapters/tron/index.d.ts"
+      ],
+      "utxo": [
+        "dist/adapters/utxo/index.d.ts"
+      ]
+    }
+  },
+  "engines": {
+    "node": ">=22.x.x <28",
+    "npm": "~10.9.2"
+  },
+  "packageManager": "pnpm@10.5.2"
 }