crypto-aio 0.0.3 → 0.1.0

package/dist/core/store/memory.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryOperationStore = exports.MemoryCursorStore = exports.MemorySequenceStore = exports.MemoryLockManager = void 0;
+exports.createMemoryStores = createMemoryStores;
+const error_1 = require("../errors/error");
+const clock_1 = require("../util/clock");
+const clone_1 = require("./clone");
+const types_1 = require("./types");
+class MemoryLockManager {
+    clock;
+    #held = new Map();
+    #tokens = new Map();
+    constructor(clock = clock_1.systemClock) {
+        this.clock = clock;
+    }
+    async acquire(key, owner, ttlMs) {
+        const now = this.clock.now();
+        const current = this.#held.get(key);
+        if (current && current.expiresAt > now)
+            return null;
+        const token = (this.#tokens.get(key) ?? 0n) + 1n;
+        this.#tokens.set(key, token);
+        const lease = Object.freeze({ key, owner, token, expiresAt: now + ttlMs });
+        this.#held.set(key, lease);
+        return lease;
+    }
+    async renew(lease, ttlMs) {
+        const now = this.clock.now();
+        const current = this.#held.get(lease.key);
+        if (!current || current.token !== lease.token || current.owner !== lease.owner)
+            return null;
+        if (current.expiresAt <= now)
+            return null;
+        const renewed = Object.freeze({ ...current, expiresAt: now + ttlMs });
+        this.#held.set(lease.key, renewed);
+        return renewed;
+    }
+    async release(lease) {
+        const current = this.#held.get(lease.key);
+        if (current && current.token === lease.token && current.owner === lease.owner) {
+            this.#held.delete(lease.key);
+        }
+    }
+}
+exports.MemoryLockManager = MemoryLockManager;
+// Sequence and cursor error messages omit the key: it embeds a wallet address, and
+// error messages reach logs.
+class MemorySequenceStore {
+    #states = new Map();
+    async get(key) {
+        const state = this.#states.get(key);
+        return state ? (0, clone_1.clone)(state) : null;
+    }
+    async put(key, state, expectedVersion) {
+        const current = this.#states.get(key);
+        if ((current?.version ?? null) !== expectedVersion) {
+            throw new error_1.StateError('VERSION_CONFLICT', 'the sequence was modified concurrently');
+        }
+        if (current && state.fence < current.fence) {
+            throw new error_1.StateError('FENCING', 'stale fencing token for the sequence');
+        }
+        this.#states.set(key, (0, clone_1.clone)({ ...state, version: (current?.version ?? 0) + 1 }));
+    }
+}
+exports.MemorySequenceStore = MemorySequenceStore;
+class MemoryCursorStore {
+    #cursors = new Map();
+    async get(key) {
+        const stored = this.#cursors.get(key);
+        return stored ? (0, clone_1.clone)(stored) : null;
+    }
+    async put(key, cursor, expectedVersion) {
+        const current = this.#cursors.get(key);
+        if ((current?.version ?? null) !== expectedVersion) {
+            throw new error_1.StateError('VERSION_CONFLICT', 'the cursor was modified concurrently');
+        }
+        const version = (current?.version ?? 0) + 1;
+        this.#cursors.set(key, (0, clone_1.clone)({ cursor, version }));
+        return version;
+    }
+}
+exports.MemoryCursorStore = MemoryCursorStore;
+const compositeKey = (namespace, id) => `${namespace}\u0000${id}`;
+const OPERATION_PATCH_KEY_SET = new Set(types_1.OPERATION_PATCH_KEYS);
+const CLEARABLE_FIELD_SET = new Set(types_1.CLEARABLE_FIELDS);
+/**
+ * Validates a pre-read snapshot of a patch's own keys, so a spread-typed patch (e.g.
+ * `{ ...record, state }` forced through `as unknown as OperationPatch`) cannot write
+ * or clear a field outside the writable whitelist — `attempts`, `claim`, `id`,
+ * `namespace`, `idempotencyKey`, `intentHash`, `context`, `kind`, `version`,
+ * `createdAt` and `updatedAt` are never reachable through `update`/`appendAttempt`.
+ */
+function assertValidPatch(entries, clearList) {
+    for (const [key] of entries) {
+        if (key !== 'clear' && !OPERATION_PATCH_KEY_SET.has(key)) {
+            throw new error_1.StateError('INVALID_TRANSITION', `unsupported patch field '${key}'`);
+        }
+    }
+    for (const key of clearList) {
+        if (!CLEARABLE_FIELD_SET.has(key)) {
+            throw new error_1.StateError('INVALID_TRANSITION', `unsupported patch field '${key}'`);
+        }
+    }
+}
+function applyPatch(current, patch, now) {
+    // Read the patch's own keys exactly once: the same snapshot is both validated and
+    // applied, so an accessor (a getter or Proxy trap) on the patch object can't change
+    // what keys are visible between validation and application.
+    const entries = Object.entries(patch);
+    // The caller's `clear` list is read once too, so what is validated is what is cleared.
+    // Only an array is a list; a number, an object or a Set would not survive a serialized
+    // store as a list either, so it is refused rather than read as `[]`.
+    const clear = entries.find(([key]) => key === 'clear')?.[1];
+    if (clear !== undefined && !Array.isArray(clear)) {
+        throw new error_1.StateError('INVALID_TRANSITION', "unsupported patch field 'clear'");
+    }
+    const clearList = clear === undefined ? [] : Array.from(clear);
+    assertValidPatch(entries, clearList);
+    const next = { ...current };
+    for (const [key, value] of entries) {
+        if (key === 'clear')
+            continue;
+        if (value !== undefined)
+            next[key] = (0, clone_1.clone)(value);
+    }
+    for (const key of clearList)
+        delete next[key];
+    next.version = current.version + 1;
+    next.updatedAt = now;
+    return next;
+}
+function matches(record, filter) {
+    return (record.namespace === filter.namespace &&
+        (filter.chain === undefined || record.context.chain === filter.chain) &&
+        (filter.network === undefined || record.context.network === filter.network) &&
+        (filter.from === undefined || record.intent.from === filter.from) &&
+        (filter.states === undefined || filter.states.includes(record.state)));
+}
+class MemoryOperationStore {
+    clock;
+    #records = new Map();
+    #keys = new Map();
+    #observations = new Map();
+    #claims = 0n;
+    constructor(clock = clock_1.systemClock) {
+        this.clock = clock;
+    }
+    async create(operation) {
+        for (const key of ['claim', 'version', 'createdAt', 'updatedAt']) {
+            if (Object.prototype.hasOwnProperty.call(operation, key)) {
+                throw new error_1.StateError('INVALID_TRANSITION', `unsupported operation field '${key}'`);
+            }
+        }
+        const keyIndex = compositeKey(operation.namespace, operation.idempotencyKey);
+        const existingId = this.#keys.get(keyIndex);
+        if (existingId !== undefined) {
+            return {
+                created: false,
+                record: (0, clone_1.clone)(this.#require(operation.namespace, existingId)),
+            };
+        }
+        const recordKey = compositeKey(operation.namespace, operation.id);
+        if (this.#records.has(recordKey)) {
+            throw new error_1.StateError('INVALID_TRANSITION', `operation '${operation.id}' already exists`);
+        }
+        const now = this.clock.now();
+        const record = {
+            ...(0, clone_1.clone)(operation),
+            version: 1,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.#records.set(recordKey, record);
+        this.#keys.set(keyIndex, operation.id);
+        return { created: true, record: (0, clone_1.clone)(record) };
+    }
+    async get(namespace, id) {
+        const record = this.#records.get(compositeKey(namespace, id));
+        return record ? (0, clone_1.clone)(record) : null;
+    }
+    async getByKey(namespace, idempotencyKey) {
+        const id = this.#keys.get(compositeKey(namespace, idempotencyKey));
+        return id !== undefined ? this.get(namespace, id) : null;
+    }
+    async findByRef(namespace, refOrTxHash) {
+        for (const record of this.#records.values()) {
+            if (record.namespace === namespace &&
+                record.attempts.some((a) => a.ref.id === refOrTxHash)) {
+                return (0, clone_1.clone)(record);
+            }
+        }
+        for (const observation of this.#observations.values()) {
+            if (observation.txHash !== refOrTxHash)
+                continue;
+            const record = this.#records.get(compositeKey(namespace, observation.operationId));
+            // The observed attempt must actually belong to this record: two namespaces can
+            // otherwise share an operation id and resolve the tx hash to the wrong operation.
+            if (record && record.attempts.some((a) => a.id === observation.attemptId)) {
+                return (0, clone_1.clone)(record);
+            }
+        }
+        return null;
+    }
+    async update(namespace, id, patch, expectedVersion, fence) {
+        const current = this.#check(namespace, id, expectedVersion, fence);
+        const next = applyPatch(current, patch, this.clock.now());
+        this.#records.set(compositeKey(namespace, id), next);
+        return (0, clone_1.clone)(next);
+    }
+    async appendAttempt(namespace, id, attempt, patch, expectedVersion, fence) {
+        const current = this.#check(namespace, id, expectedVersion, fence);
+        if (current.attempts.some((a) => a.id === attempt.id)) {
+            throw new error_1.StateError('INVALID_TRANSITION', `attempt '${attempt.id}' already exists`);
+        }
+        const withAttempt = {
+            ...current,
+            attempts: [...current.attempts, (0, clone_1.clone)(attempt)],
+            activeAttemptId: attempt.id,
+        };
+        const next = applyPatch(withAttempt, patch, this.clock.now());
+        this.#records.set(compositeKey(namespace, id), next);
+        return (0, clone_1.clone)(next);
+    }
+    async getObservation(attemptId) {
+        const observation = this.#observations.get(attemptId);
+        return observation ? (0, clone_1.clone)(observation) : null;
+    }
+    async putObservation(observation, expectedVersion) {
+        const current = this.#observations.get(observation.attemptId);
+        if ((current?.version ?? null) !== expectedVersion) {
+            throw new error_1.StateError('VERSION_CONFLICT', `observation '${observation.attemptId}' was modified concurrently`);
+        }
+        const next = {
+            ...(0, clone_1.clone)(observation),
+            version: (current?.version ?? 0) + 1,
+        };
+        this.#observations.set(observation.attemptId, next);
+        return (0, clone_1.clone)(next);
+    }
+    async claimDue(namespace, workerId, now, leaseMs, limit) {
+        if (limit <= 0)
+            return [];
+        const due = [...this.#records.values()]
+            .filter((r) => r.namespace === namespace &&
+            !(0, types_1.isTerminal)(r.state) &&
+            r.nextCheckAt !== undefined &&
+            r.nextCheckAt <= now &&
+            (!r.claim || r.claim.until <= now))
+            .sort((a, b) => a.nextCheckAt - b.nextCheckAt ||
+            a.createdAt - b.createdAt)
+            .slice(0, limit);
+        return due.map((record) => {
+            this.#claims += 1n;
+            const next = {
+                ...record,
+                claim: { workerId, token: this.#claims.toString(), until: now + leaseMs },
+                version: record.version + 1,
+                updatedAt: this.clock.now(),
+            };
+            this.#records.set(compositeKey(namespace, record.id), next);
+            return (0, clone_1.clone)(next);
+        });
+    }
+    async releaseClaim(namespace, id, fence) {
+        const current = this.#require(namespace, id);
+        if (current.claim?.token !== fence.claimToken) {
+            throw new error_1.StateError('FENCING', `claim on operation '${id}' is no longer held`);
+        }
+        const { claim: _claim, ...rest } = current;
+        this.#records.set(compositeKey(namespace, id), {
+            ...rest,
+            version: current.version + 1,
+            updatedAt: this.clock.now(),
+        });
+    }
+    async list(filter) {
+        const found = [...this.#records.values()]
+            .filter((r) => matches(r, filter))
+            .sort((a, b) => a.createdAt - b.createdAt);
+        return (0, clone_1.clone)(filter.limit === undefined ? found : found.slice(0, filter.limit));
+    }
+    async purge(filter) {
+        // As `list` does: the oldest matches first, and at most `limit` of them.
+        const found = [...this.#records.values()]
+            .filter((r) => matches(r, filter))
+            .sort((a, b) => a.createdAt - b.createdAt);
+        let removed = 0;
+        for (const record of filter.limit === undefined
+            ? found
+            : found.slice(0, filter.limit)) {
+            this.#records.delete(compositeKey(record.namespace, record.id));
+            this.#keys.delete(compositeKey(record.namespace, record.idempotencyKey));
+            for (const attempt of record.attempts)
+                this.#observations.delete(attempt.id);
+            removed += 1;
+        }
+        return removed;
+    }
+    #require(namespace, id) {
+        const record = this.#records.get(compositeKey(namespace, id));
+        if (!record)
+            throw new error_1.StateError('NOT_FOUND', `operation '${id}' not found`);
+        return record;
+    }
+    #check(namespace, id, expectedVersion, fence) {
+        const record = this.#require(namespace, id);
+        if (record.version !== expectedVersion) {
+            throw new error_1.StateError('VERSION_CONFLICT', `operation '${id}' was modified concurrently (expected v${expectedVersion}, found v${record.version})`);
+        }
+        if (fence && record.claim?.token !== fence.claimToken) {
+            throw new error_1.StateError('FENCING', `claim on operation '${id}' is no longer held`);
+        }
+        return record;
+    }
+}
+exports.MemoryOperationStore = MemoryOperationStore;
+function createMemoryStores(clock = clock_1.systemClock) {
+    return {
+        operations: new MemoryOperationStore(clock),
+        locks: new MemoryLockManager(clock),
+        sequences: new MemorySequenceStore(),
+        cursors: new MemoryCursorStore(),
+    };
+}
+//# sourceMappingURL=memory.js.map

package/dist/core/store/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../../src/core/store/memory.ts"],"names":[],"mappings":"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","sourcesContent":["import { StateError } from '../errors/error';\nimport { systemClock, type Clock } from '../util/clock';\nimport { clone } from './clone';\nimport { CLEARABLE_FIELDS, isTerminal, OPERATION_PATCH_KEYS } from './types';\nimport type {\n  AttemptObservation,\n  AttemptRecord,\n  CreateResult,\n  CursorStore,\n  Fence,\n  Lease,\n  LockManager,\n  NewOperation,\n  OperationFilter,\n  OperationPatch,\n  OperationRecord,\n  OperationStore,\n  ScanCursor,\n  SequenceState,\n  SequenceStore,\n  Stores,\n  StoredCursor,\n} from './types';\n\nexport class MemoryLockManager implements LockManager {\n  readonly #held = new Map<string, Lease>();\n  readonly #tokens = new Map<string, bigint>();\n\n  constructor(private readonly clock: Clock = systemClock) {}\n\n  async acquire(key: string, owner: string, ttlMs: number): Promise<Lease | null> {\n    const now = this.clock.now();\n    const current = this.#held.get(key);\n    if (current && current.expiresAt > now) return null;\n    const token = (this.#tokens.get(key) ?? 0n) + 1n;\n    this.#tokens.set(key, token);\n    const lease: Lease = Object.freeze({ key, owner, token, expiresAt: now + ttlMs });\n    this.#held.set(key, lease);\n    return lease;\n  }\n\n  async renew(lease: Lease, ttlMs: number): Promise<Lease | null> {\n    const now = this.clock.now();\n    const current = this.#held.get(lease.key);\n    if (!current || current.token !== lease.token || current.owner !== lease.owner)\n      return null;\n    if (current.expiresAt <= now) return null;\n    const renewed: Lease = Object.freeze({ ...current, expiresAt: now + ttlMs });\n    this.#held.set(lease.key, renewed);\n    return renewed;\n  }\n\n  async release(lease: Lease): Promise<void> {\n    const current = this.#held.get(lease.key);\n    if (current && current.token === lease.token && current.owner === lease.owner) {\n      this.#held.delete(lease.key);\n    }\n  }\n}\n\n// Sequence and cursor error messages omit the key: it embeds a wallet address, and\n// error messages reach logs.\nexport class MemorySequenceStore implements SequenceStore {\n  readonly #states = new Map<string, SequenceState>();\n\n  async get(key: string): Promise<SequenceState | null> {\n    const state = this.#states.get(key);\n    return state ? clone(state) : null;\n  }\n\n  async put(\n    key: string,\n    state: Omit<SequenceState, 'version'>,\n    expectedVersion: number | null,\n  ): Promise<void> {\n    const current = this.#states.get(key);\n    if ((current?.version ?? null) !== expectedVersion) {\n      throw new StateError('VERSION_CONFLICT', 'the sequence was modified concurrently');\n    }\n    if (current && state.fence < current.fence) {\n      throw new StateError('FENCING', 'stale fencing token for the sequence');\n    }\n    this.#states.set(key, clone({ ...state, version: (current?.version ?? 0) + 1 }));\n  }\n}\n\nexport class MemoryCursorStore implements CursorStore {\n  readonly #cursors = new Map<string, StoredCursor>();\n\n  async get(key: string): Promise<StoredCursor | null> {\n    const stored = this.#cursors.get(key);\n    return stored ? clone(stored) : null;\n  }\n\n  async put(\n    key: string,\n    cursor: ScanCursor,\n    expectedVersion: number | null,\n  ): Promise<number> {\n    const current = this.#cursors.get(key);\n    if ((current?.version ?? null) !== expectedVersion) {\n      throw new StateError('VERSION_CONFLICT', 'the cursor was modified concurrently');\n    }\n    const version = (current?.version ?? 0) + 1;\n    this.#cursors.set(key, clone({ cursor, version }));\n    return version;\n  }\n}\n\nconst compositeKey = (namespace: string, id: string): string => `${namespace}\\u0000${id}`;\n\nconst OPERATION_PATCH_KEY_SET: ReadonlySet<string> = new Set(OPERATION_PATCH_KEYS);\nconst CLEARABLE_FIELD_SET: ReadonlySet<string> = new Set(CLEARABLE_FIELDS);\n\n/**\n * Validates a pre-read snapshot of a patch's own keys, so a spread-typed patch (e.g.\n * `{ ...record, state }` forced through `as unknown as OperationPatch`) cannot write\n * or clear a field outside the writable whitelist — `attempts`, `claim`, `id`,\n * `namespace`, `idempotencyKey`, `intentHash`, `context`, `kind`, `version`,\n * `createdAt` and `updatedAt` are never reachable through `update`/`appendAttempt`.\n */\nfunction assertValidPatch(\n  entries: readonly (readonly [string, unknown])[],\n  clearList: readonly string[],\n): void {\n  for (const [key] of entries) {\n    if (key !== 'clear' && !OPERATION_PATCH_KEY_SET.has(key)) {\n      throw new StateError('INVALID_TRANSITION', `unsupported patch field '${key}'`);\n    }\n  }\n  for (const key of clearList) {\n    if (!CLEARABLE_FIELD_SET.has(key)) {\n      throw new StateError('INVALID_TRANSITION', `unsupported patch field '${key}'`);\n    }\n  }\n}\n\nfunction applyPatch(\n  current: OperationRecord,\n  patch: OperationPatch,\n  now: number,\n): OperationRecord {\n  // Read the patch's own keys exactly once: the same snapshot is both validated and\n  // applied, so an accessor (a getter or Proxy trap) on the patch object can't change\n  // what keys are visible between validation and application.\n  const entries = Object.entries(patch) as readonly (readonly [string, unknown])[];\n  // The caller's `clear` list is read once too, so what is validated is what is cleared.\n  // Only an array is a list; a number, an object or a Set would not survive a serialized\n  // store as a list either, so it is refused rather than read as `[]`.\n  const clear = entries.find(([key]) => key === 'clear')?.[1];\n  if (clear !== undefined && !Array.isArray(clear)) {\n    throw new StateError('INVALID_TRANSITION', \"unsupported patch field 'clear'\");\n  }\n  const clearList: readonly string[] = clear === undefined ? [] : Array.from(clear);\n  assertValidPatch(entries, clearList);\n  const next: Record<string, unknown> = { ...current };\n  for (const [key, value] of entries) {\n    if (key === 'clear') continue;\n    if (value !== undefined) next[key] = clone(value);\n  }\n  for (const key of clearList) delete next[key];\n  next.version = current.version + 1;\n  next.updatedAt = now;\n  return next as unknown as OperationRecord;\n}\n\nfunction matches(record: OperationRecord, filter: OperationFilter): boolean {\n  return (\n    record.namespace === filter.namespace &&\n    (filter.chain === undefined || record.context.chain === filter.chain) &&\n    (filter.network === undefined || record.context.network === filter.network) &&\n    (filter.from === undefined || record.intent.from === filter.from) &&\n    (filter.states === undefined || filter.states.includes(record.state))\n  );\n}\n\nexport class MemoryOperationStore implements OperationStore {\n  readonly #records = new Map<string, OperationRecord>();\n  readonly #keys = new Map<string, string>();\n  readonly #observations = new Map<string, AttemptObservation>();\n  #claims = 0n;\n\n  constructor(private readonly clock: Clock = systemClock) {}\n\n  async create(operation: NewOperation): Promise<CreateResult> {\n    for (const key of ['claim', 'version', 'createdAt', 'updatedAt']) {\n      if (Object.prototype.hasOwnProperty.call(operation, key)) {\n        throw new StateError(\n          'INVALID_TRANSITION',\n          `unsupported operation field '${key}'`,\n        );\n      }\n    }\n    const keyIndex = compositeKey(operation.namespace, operation.idempotencyKey);\n    const existingId = this.#keys.get(keyIndex);\n    if (existingId !== undefined) {\n      return {\n        created: false,\n        record: clone(this.#require(operation.namespace, existingId)),\n      };\n    }\n    const recordKey = compositeKey(operation.namespace, operation.id);\n    if (this.#records.has(recordKey)) {\n      throw new StateError(\n        'INVALID_TRANSITION',\n        `operation '${operation.id}' already exists`,\n      );\n    }\n    const now = this.clock.now();\n    const record = {\n      ...clone(operation),\n      version: 1,\n      createdAt: now,\n      updatedAt: now,\n    } as OperationRecord;\n    this.#records.set(recordKey, record);\n    this.#keys.set(keyIndex, operation.id);\n    return { created: true, record: clone(record) };\n  }\n\n  async get(namespace: string, id: string): Promise<OperationRecord | null> {\n    const record = this.#records.get(compositeKey(namespace, id));\n    return record ? clone(record) : null;\n  }\n\n  async getByKey(\n    namespace: string,\n    idempotencyKey: string,\n  ): Promise<OperationRecord | null> {\n    const id = this.#keys.get(compositeKey(namespace, idempotencyKey));\n    return id !== undefined ? this.get(namespace, id) : null;\n  }\n\n  async findByRef(\n    namespace: string,\n    refOrTxHash: string,\n  ): Promise<OperationRecord | null> {\n    for (const record of this.#records.values()) {\n      if (\n        record.namespace === namespace &&\n        record.attempts.some((a) => a.ref.id === refOrTxHash)\n      ) {\n        return clone(record);\n      }\n    }\n    for (const observation of this.#observations.values()) {\n      if (observation.txHash !== refOrTxHash) continue;\n      const record = this.#records.get(compositeKey(namespace, observation.operationId));\n      // The observed attempt must actually belong to this record: two namespaces can\n      // otherwise share an operation id and resolve the tx hash to the wrong operation.\n      if (record && record.attempts.some((a) => a.id === observation.attemptId)) {\n        return clone(record);\n      }\n    }\n    return null;\n  }\n\n  async update(\n    namespace: string,\n    id: string,\n    patch: OperationPatch,\n    expectedVersion: number,\n    fence?: Fence,\n  ): Promise<OperationRecord> {\n    const current = this.#check(namespace, id, expectedVersion, fence);\n    const next = applyPatch(current, patch, this.clock.now());\n    this.#records.set(compositeKey(namespace, id), next);\n    return clone(next);\n  }\n\n  async appendAttempt(\n    namespace: string,\n    id: string,\n    attempt: AttemptRecord,\n    patch: OperationPatch,\n    expectedVersion: number,\n    fence?: Fence,\n  ): Promise<OperationRecord> {\n    const current = this.#check(namespace, id, expectedVersion, fence);\n    if (current.attempts.some((a) => a.id === attempt.id)) {\n      throw new StateError(\n        'INVALID_TRANSITION',\n        `attempt '${attempt.id}' already exists`,\n      );\n    }\n    const withAttempt: OperationRecord = {\n      ...current,\n      attempts: [...current.attempts, clone(attempt)],\n      activeAttemptId: attempt.id,\n    };\n    const next = applyPatch(withAttempt, patch, this.clock.now());\n    this.#records.set(compositeKey(namespace, id), next);\n    return clone(next);\n  }\n\n  async getObservation(attemptId: string): Promise<AttemptObservation | null> {\n    const observation = this.#observations.get(attemptId);\n    return observation ? clone(observation) : null;\n  }\n\n  async putObservation(\n    observation: Omit<AttemptObservation, 'version'>,\n    expectedVersion: number | null,\n  ): Promise<AttemptObservation> {\n    const current = this.#observations.get(observation.attemptId);\n    if ((current?.version ?? null) !== expectedVersion) {\n      throw new StateError(\n        'VERSION_CONFLICT',\n        `observation '${observation.attemptId}' was modified concurrently`,\n      );\n    }\n    const next: AttemptObservation = {\n      ...clone(observation),\n      version: (current?.version ?? 0) + 1,\n    };\n    this.#observations.set(observation.attemptId, next);\n    return clone(next);\n  }\n\n  async claimDue(\n    namespace: string,\n    workerId: string,\n    now: number,\n    leaseMs: number,\n    limit: number,\n  ): Promise<OperationRecord[]> {\n    if (limit <= 0) return [];\n    const due = [...this.#records.values()]\n      .filter(\n        (r) =>\n          r.namespace === namespace &&\n          !isTerminal(r.state) &&\n          r.nextCheckAt !== undefined &&\n          r.nextCheckAt <= now &&\n          (!r.claim || r.claim.until <= now),\n      )\n      .sort(\n        (a, b) =>\n          (a.nextCheckAt as number) - (b.nextCheckAt as number) ||\n          a.createdAt - b.createdAt,\n      )\n      .slice(0, limit);\n    return due.map((record) => {\n      this.#claims += 1n;\n      const next: OperationRecord = {\n        ...record,\n        claim: { workerId, token: this.#claims.toString(), until: now + leaseMs },\n        version: record.version + 1,\n        updatedAt: this.clock.now(),\n      };\n      this.#records.set(compositeKey(namespace, record.id), next);\n      return clone(next);\n    });\n  }\n\n  async releaseClaim(namespace: string, id: string, fence: Fence): Promise<void> {\n    const current = this.#require(namespace, id);\n    if (current.claim?.token !== fence.claimToken) {\n      throw new StateError('FENCING', `claim on operation '${id}' is no longer held`);\n    }\n    const { claim: _claim, ...rest } = current;\n    this.#records.set(compositeKey(namespace, id), {\n      ...rest,\n      version: current.version + 1,\n      updatedAt: this.clock.now(),\n    });\n  }\n\n  async list(filter: OperationFilter): Promise<OperationRecord[]> {\n    const found = [...this.#records.values()]\n      .filter((r) => matches(r, filter))\n      .sort((a, b) => a.createdAt - b.createdAt);\n    return clone(filter.limit === undefined ? found : found.slice(0, filter.limit));\n  }\n\n  async purge(filter: OperationFilter): Promise<number> {\n    // As `list` does: the oldest matches first, and at most `limit` of them.\n    const found = [...this.#records.values()]\n      .filter((r) => matches(r, filter))\n      .sort((a, b) => a.createdAt - b.createdAt);\n    let removed = 0;\n    for (const record of filter.limit === undefined\n      ? found\n      : found.slice(0, filter.limit)) {\n      this.#records.delete(compositeKey(record.namespace, record.id));\n      this.#keys.delete(compositeKey(record.namespace, record.idempotencyKey));\n      for (const attempt of record.attempts) this.#observations.delete(attempt.id);\n      removed += 1;\n    }\n    return removed;\n  }\n\n  #require(namespace: string, id: string): OperationRecord {\n    const record = this.#records.get(compositeKey(namespace, id));\n    if (!record) throw new StateError('NOT_FOUND', `operation '${id}' not found`);\n    return record;\n  }\n\n  #check(\n    namespace: string,\n    id: string,\n    expectedVersion: number,\n    fence?: Fence,\n  ): OperationRecord {\n    const record = this.#require(namespace, id);\n    if (record.version !== expectedVersion) {\n      throw new StateError(\n        'VERSION_CONFLICT',\n        `operation '${id}' was modified concurrently (expected v${expectedVersion}, found v${record.version})`,\n      );\n    }\n    if (fence && record.claim?.token !== fence.claimToken) {\n      throw new StateError('FENCING', `claim on operation '${id}' is no longer held`);\n    }\n    return record;\n  }\n}\n\nexport function createMemoryStores(clock: Clock = systemClock): Stores {\n  return {\n    operations: new MemoryOperationStore(clock),\n    locks: new MemoryLockManager(clock),\n    sequences: new MemorySequenceStore(),\n    cursors: new MemoryCursorStore(),\n  };\n}\n"]}

package/dist/core/store/types.d.ts

@@ -0,0 +1,246 @@
+import type { SerializedError } from '../errors/error';
+import type { FeeEstimateDraft } from '../model/fee';
+import type { StoredIntent } from '../model/intent';
+import type { OrderingData } from '../model/ordering';
+import type { AttemptRef, Evidence, RawTx, TxState, UnsignedTx } from '../model/transaction';
+import type { SignatureBundle, SignerTicket } from '../signing/types';
+export type OperationState = 'created' | 'prepared' | 'awaiting-signature' | 'signed' | 'submitted' | 'stalled' | 'included' | 'final' | 'failed' | 'expired' | 'abandoned';
+export declare const TERMINAL_STATES: readonly OperationState[];
+export declare const NON_TERMINAL_STATES: readonly OperationState[];
+export declare function isTerminal(state: OperationState): boolean;
+/** Frozen at Operation creation; later handle or config changes never affect it. */
+export interface ExecutionContext {
+    readonly chain: string;
+    readonly network: string;
+    readonly library: string;
+    /** Provider names, or `inline:<hash>` for inline configs (never secrets). */
+    readonly providers: readonly string[];
+    readonly indexers: readonly string[];
+    readonly wallet: string;
+    readonly signer?: string;
+    readonly configHash: string;
+}
+export type AttemptPurpose = 'original' | 'replacement' | 'cancel' | 'rebuild';
+/** One concrete signed transaction. Immutable after insertion. */
+export interface AttemptRecord {
+    readonly id: string;
+    readonly ref: AttemptRef;
+    readonly raw: RawTx;
+    readonly ordering: OrderingData;
+    readonly fee: FeeEstimateDraft;
+    readonly unsigned: UnsignedTx;
+    readonly purpose: AttemptPurpose;
+    readonly supersedes?: string;
+    readonly createdAt: number;
+}
+/** Mutable, versioned view of what the chain says about an Attempt. */
+export interface AttemptObservation {
+    readonly attemptId: string;
+    readonly operationId: string;
+    readonly state: TxState;
+    readonly evidence: Evidence;
+    readonly txHash?: string;
+    readonly blockHash?: string;
+    readonly blockHeight?: bigint;
+    readonly confirmations: number;
+    readonly firstSeenAt?: number;
+    readonly lastSeenAt?: number;
+    readonly lastBroadcastAt?: number;
+    readonly reason?: string;
+    readonly replacedBy?: string;
+    readonly version: number;
+}
+export interface OperationClaim {
+    readonly workerId: string;
+    /** Strictly increasing per store (decimal string of a bigint). */
+    readonly token: string;
+    readonly until: number;
+}
+export interface OperationRecord {
+    readonly id: string;
+    readonly namespace: string;
+    readonly idempotencyKey: string;
+    readonly intentHash: string;
+    readonly context: ExecutionContext;
+    readonly kind: 'transfer';
+    readonly state: OperationState;
+    readonly outcome?: 'executed' | 'cancelled';
+    readonly intent: StoredIntent;
+    readonly unsigned?: UnsignedTx;
+    readonly reservation?: OrderingData;
+    readonly signerTickets?: readonly SignerTicket[];
+    readonly partialSignatures?: readonly SignatureBundle[];
+    readonly attempts: readonly AttemptRecord[];
+    readonly activeAttemptId?: string;
+    readonly ambiguous?: boolean;
+    readonly version: number;
+    readonly claim?: OperationClaim;
+    readonly error?: SerializedError;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly nextCheckAt?: number;
+}
+export type NewOperation = Omit<OperationRecord, 'version' | 'createdAt' | 'updatedAt' | 'claim'>;
+export declare const CLEARABLE_FIELDS: readonly ["outcome", "unsigned", "reservation", "signerTickets", "partialSignatures", "activeAttemptId", "ambiguous", "error", "nextCheckAt"];
+/** The only fields an `OperationPatch` may `clear`; never store-owned state or `state`. */
+export type ClearableField = (typeof CLEARABLE_FIELDS)[number];
+export interface OperationPatch {
+    readonly state?: OperationState;
+    readonly outcome?: 'executed' | 'cancelled';
+    readonly unsigned?: UnsignedTx;
+    readonly reservation?: OrderingData;
+    readonly signerTickets?: readonly SignerTicket[];
+    readonly partialSignatures?: readonly SignatureBundle[];
+    readonly activeAttemptId?: string;
+    readonly ambiguous?: boolean;
+    readonly error?: SerializedError;
+    readonly nextCheckAt?: number;
+    /** Fields to delete; applied after the values above. */
+    readonly clear?: readonly ClearableField[];
+}
+/** Runtime whitelist of writable `OperationPatch` fields (everything but `clear`). */
+export declare const OPERATION_PATCH_KEYS: readonly ["state", "outcome", "unsigned", "reservation", "signerTickets", "partialSignatures", "activeAttemptId", "ambiguous", "error", "nextCheckAt"];
+export interface Fence {
+    readonly claimToken: string;
+}
+export interface OperationFilter {
+    readonly namespace: string;
+    readonly chain?: string;
+    readonly network?: string;
+    readonly from?: string;
+    readonly states?: readonly OperationState[];
+    readonly limit?: number;
+}
+export interface CreateResult {
+    readonly created: boolean;
+    readonly record: OperationRecord;
+}
+/**
+ * Durable Operation storage. Required guarantees (verified by the contract suite),
+ * binding on every implementation (memory, Redis, Postgres, ...):
+ * - `create` is create-if-absent on `(namespace, idempotencyKey)`: a second `create`
+ *   for an existing key returns the stored record unchanged, regardless of
+ *   `intentHash` — this store never performs the idempotency-conflict check itself;
+ *   the calling engine does.
+ * - `update`/`appendAttempt` are version-checked (compare-and-set on
+ *   `expectedVersion`) and optionally fenced by a claim token. Both are restricted to
+ *   the same runtime patch whitelist (`OPERATION_PATCH_KEYS`), and `clear` may only
+ *   name `CLEARABLE_FIELDS`; any other key anywhere in the patch rejects the whole
+ *   call with `INVALID_TRANSITION` before any mutation. An explicit `undefined` value
+ *   for a writable field is a no-op (the stored value survives); only `clear` removes
+ *   a field.
+ * - `appendAttempt` is atomic with its accompanying patch, never rewrites a
+ *   previously stored `AttemptRecord`, and rejects a duplicate attempt id. Attempt ids
+ *   are globally unique across every Operation and namespace (observations are keyed
+ *   by attempt id alone).
+ * - `claimDue` and `list` are scoped by namespace: they never return a record of another
+ *   namespace, even one with the same id.
+ * - `claimDue` returns only non-terminal operations with `nextCheckAt` set and `<=
+ *   now`, ordered by `(nextCheckAt, createdAt)` with a stable tie-break for equal
+ *   values, and returns `[]` for `limit <= 0`. A claimed Operation is excluded until
+ *   its `claim.until <= now`; then another worker may take it over. Claim tokens are
+ *   strictly increasing per store; fenced writes are rejected after a takeover.
+ * - `list` returns matches in creation order.
+ * - `ClearableField` is restricted on purpose: `clear` can never remove store-owned or
+ *   identity fields (`attempts`, `claim`, `version`, `id`, ...) or `state`. An
+ *   implementation reads the caller's `clear` list once, so the list it validates is
+ *   the list it applies.
+ * - A key set to `undefined`, in an observation or a patch, is never persisted as a value
+ *   such as `null`. In a patch, the stored field keeps its value. In an
+ *   observation, which replaces the whole record, the field reads back `undefined` (never
+ *   `null`).
+ */
+export interface OperationStore {
+    create(operation: NewOperation): Promise<CreateResult>;
+    get(namespace: string, id: string): Promise<OperationRecord | null>;
+    getByKey(namespace: string, idempotencyKey: string): Promise<OperationRecord | null>;
+    /**
+     * Finds by an Attempt ref id or by an observed canonical tx hash. The engine's
+     * AttemptRef guard, which refuses an Attempt whose ref another Operation of the
+     * namespace holds, relies on this read being read-your-writes consistent across every
+     * process that shares the store: it must see any `appendAttempt` that another store
+     * instance committed before it was called (no read replica, no eventually consistent
+     * index).
+     */
+    findByRef(namespace: string, refOrTxHash: string): Promise<OperationRecord | null>;
+    /**
+     * Compare-and-set on `expectedVersion`, optionally fenced. Every successful update bumps
+     * version, even when the patch changes no field (the engine fences stale writers
+     * with such a no-effect update).
+     */
+    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>;
+    /**
+     * Stores `observation` as the whole new record, version-checked. An optional field left
+     * out of it or set to `undefined` (a cleared `reason`, `blockHash` or `blockHeight`)
+     * reads back `undefined` (never `null`) afterwards. A store must replace the record, never
+     * merge fields into the old one. The monitor relies on this to clear stale values.
+     */
+    putObservation(observation: Omit<AttemptObservation, 'version'>, expectedVersion: number | null): Promise<AttemptObservation>;
+    /** Claims non-terminal operations whose `nextCheckAt` is set and <= now (unscheduled ones are never due). */
+    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[]>;
+    purge?(filter: OperationFilter): Promise<number>;
+}
+export interface Lease {
+    readonly key: string;
+    readonly owner: string;
+    /** Strictly increasing per key across all acquisitions. */
+    readonly token: bigint;
+    readonly expiresAt: number;
+}
+export interface LockManager {
+    acquire(key: string, owner: string, ttlMs: number): Promise<Lease | null>;
+    renew(lease: Lease, ttlMs: number): Promise<Lease | null>;
+    release(lease: Lease): Promise<void>;
+}
+export interface SequenceState {
+    readonly next: bigint;
+    readonly released: readonly bigint[];
+    readonly fence: bigint;
+    readonly version: number;
+}
+export interface SequenceStore {
+    get(key: string): Promise<SequenceState | null>;
+    /** Rejects on version mismatch (`VERSION_CONFLICT`) or when `fence` < stored fence (`FENCING`). */
+    put(key: string, state: Omit<SequenceState, 'version'>, expectedVersion: number | null): Promise<void>;
+}
+export interface ScanCursor {
+    readonly height: bigint;
+    readonly hash: string;
+    readonly recent: readonly {
+        readonly height: bigint;
+        readonly hash: string;
+    }[];
+}
+export interface StoredCursor {
+    readonly cursor: ScanCursor;
+    readonly version: number;
+}
+export interface CursorStore {
+    get(key: string): Promise<StoredCursor | null>;
+    /** Returns the new version. */
+    put(key: string, cursor: ScanCursor, expectedVersion: number | null): Promise<number>;
+}
+export interface Stores {
+    readonly operations: OperationStore;
+    readonly locks: LockManager;
+    readonly sequences: SequenceStore;
+    readonly cursors: CursorStore;
+}
+export type DataClass = 'secret' | 'sensitive' | 'sensitive-until-broadcast' | 'operational';
+/**
+ * Field classification so backing stores can apply encryption and retention per field.
+ *
+ * `operation.reservation` and `attempt.ordering` are `sensitive` because an `inputs`
+ * ordering lists UTXO outpoints, which tie a wallet to its coins. A nonce or seqno value
+ * on its own is an operational identifier, like an Operation id: the `nonce.allocated`
+ * and `nonce.gap` events carry it, and logs may too.
+ */
+export declare const DATA_CLASSIFICATION: {
+    readonly operation: Readonly<Record<keyof OperationRecord, DataClass>>;
+    readonly attempt: Readonly<Record<keyof AttemptRecord, DataClass>>;
+    readonly observation: Readonly<Record<keyof AttemptObservation, DataClass>>;
+};