@totemsdk/omnia-host 0.10.0 → 0.11.0

package/dist/pairing.d.ts

@@ -0,0 +1,109 @@
+/**
+ * RFC-062 — local node/extension pairing MVP.
+ *
+ * A loopback HTTP service issues one-time pairing codes, verifies the extension
+ * origin, binds a device key and returns a scoped bearer token plus the node
+ * identity/fingerprint and advertised capabilities (chain RPC, P2P hub, lease).
+ */
+import type { AddressInfo } from 'node:net';
+export interface PairingCapabilities {
+    chain?: {
+        rpcUrl: string;
+        network: string;
+        genesisHash?: string;
+    };
+    lease?: {
+        modes: Array<'local' | 'hybrid'>;
+        onchainWatermarkUrl?: string;
+    };
+    omnia?: {
+        relayUrl?: string;
+        hostControlUrl?: string;
+        transportPubkey?: string;
+    };
+    p2p?: {
+        hubUrl: string;
+        token?: string;
+        scopes: Array<'p2p.pubsub'>;
+        topicPrefixes?: string[];
+    };
+}
+export interface LinkedClient {
+    clientId: string;
+    origin: string;
+    devicePublicKey: string;
+    scopes: string[];
+    tokenHash: string;
+    createdAt: number;
+    lastUsedAt: number;
+    revokedAt?: number;
+}
+export interface PairingInvitation {
+    endpoint: string;
+    code: string;
+    nodeId: string;
+    fingerprint: string;
+    network: string;
+    scopes: string[];
+    capabilities: PairingCapabilities;
+    expiresAt: number;
+}
+export interface PairingServiceOptions {
+    storePath: string;
+    endpoint?: string;
+    network?: string;
+    ttlMs?: number;
+    allowedOrigins?: string[];
+    scopes?: string[];
+    capabilities?: PairingCapabilities;
+    now?: () => number;
+}
+export interface PairingService {
+    readonly nodeId: string;
+    readonly fingerprint: string;
+    readonly network: string;
+    readonly scopes: string[];
+    readonly capabilities: PairingCapabilities;
+    createInvitation(): PairingInvitation;
+    info(code: string): Omit<PairingInvitation, 'code' | 'endpoint'>;
+    complete(input: {
+        code: string;
+        devicePublicKey: string;
+        origin: string;
+        scopes?: string[];
+    }): {
+        token: string;
+        clientId: string;
+        node: {
+            nodeId: string;
+            fingerprint: string;
+            network: string;
+        };
+        capabilities: PairingCapabilities;
+    };
+    identity(): {
+        nodeId: string;
+        fingerprint: string;
+        publicKey: string;
+        network: string;
+        capabilities: PairingCapabilities;
+    };
+    listClients(): LinkedClient[];
+    revoke(clientId: string): boolean;
+    allowsOrigin(origin?: string): boolean;
+}
+export declare function createPairingService(options: PairingServiceOptions): PairingService;
+export interface PairingHttpServerOptions {
+    host?: string;
+    port: number;
+    maxBodyBytes?: number;
+}
+export interface PairingHttpServer {
+    listen(): Promise<{
+        host: string;
+        port: number;
+    }>;
+    close(): Promise<void>;
+    readonly address?: AddressInfo;
+}
+export declare function createPairingHttpServer(service: PairingService, options: PairingHttpServerOptions): PairingHttpServer;

package/dist/pairing.js

@@ -0,0 +1,231 @@
+"use strict";
+/**
+ * RFC-062 — local node/extension pairing MVP.
+ *
+ * A loopback HTTP service issues one-time pairing codes, verifies the extension
+ * origin, binds a device key and returns a scoped bearer token plus the node
+ * identity/fingerprint and advertised capabilities (chain RPC, P2P hub, lease).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPairingService = createPairingService;
+exports.createPairingHttpServer = createPairingHttpServer;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_path_1 = __importDefault(require("node:path"));
+function sha256(value) {
+    return node_crypto_1.default.createHash('sha256').update(value).digest('hex');
+}
+function loadStore(storePath) {
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(storePath, 'utf8'));
+        if (parsed.identity?.publicKey && parsed.identity?.privateKey) {
+            return { identity: parsed.identity, clients: parsed.clients ?? {} };
+        }
+    }
+    catch {
+        // Create a new identity below.
+    }
+    const pair = node_crypto_1.default.generateKeyPairSync('ed25519');
+    const identity = {
+        publicKey: pair.publicKey.export({ type: 'spki', format: 'der' }).toString('base64'),
+        privateKey: pair.privateKey.export({ type: 'pkcs8', format: 'der' }).toString('base64'),
+        createdAt: Date.now(),
+    };
+    const store = { identity, clients: {} };
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(storePath), { recursive: true });
+    node_fs_1.default.writeFileSync(storePath, JSON.stringify(store, null, 2), { mode: 0o600 });
+    return store;
+}
+function createPairingService(options) {
+    const now = options.now ?? (() => Date.now());
+    const ttlMs = options.ttlMs ?? 5 * 60_000;
+    const endpoint = options.endpoint ?? 'http://127.0.0.1:7789';
+    const network = options.network ?? 'minima';
+    const scopes = options.scopes ?? ['chain.read', 'chain.submit', 'p2p.pubsub'];
+    const capabilities = options.capabilities ?? {};
+    const store = loadStore(options.storePath);
+    const sessions = new Map();
+    const publicKeyBytes = Buffer.from(store.identity.publicKey, 'base64');
+    const fingerprint = sha256(publicKeyBytes);
+    const nodeId = fingerprint.slice(0, 16);
+    const persist = () => {
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(options.storePath), { recursive: true });
+        node_fs_1.default.writeFileSync(options.storePath, JSON.stringify(store, null, 2), { mode: 0o600 });
+    };
+    const allowsOrigin = (origin) => {
+        if (!origin)
+            return true;
+        if (!options.allowedOrigins || options.allowedOrigins.length === 0)
+            return true;
+        return options.allowedOrigins.includes(origin);
+    };
+    const baseInfo = () => ({
+        nodeId,
+        fingerprint,
+        network,
+        scopes,
+        capabilities,
+    });
+    return {
+        nodeId,
+        fingerprint,
+        network,
+        scopes,
+        capabilities,
+        createInvitation() {
+            const code = node_crypto_1.default.randomBytes(18).toString('base64url');
+            const hash = sha256(code);
+            const expiresAt = now() + ttlMs;
+            sessions.set(hash, { hash, expiresAt, attempts: 0 });
+            // Opportunistic cleanup; expired sessions cannot be completed.
+            for (const [key, session] of sessions) {
+                if (session.expiresAt <= now())
+                    sessions.delete(key);
+            }
+            return { endpoint, code, ...baseInfo(), expiresAt };
+        },
+        info(code) {
+            const session = sessions.get(sha256(code));
+            if (!session || session.expiresAt <= now())
+                throw new Error('Invalid or expired pairing code');
+            return { ...baseInfo(), expiresAt: session.expiresAt };
+        },
+        complete({ code, devicePublicKey, origin, scopes: requested }) {
+            const hash = sha256(code);
+            const session = sessions.get(hash);
+            if (!session || session.expiresAt <= now())
+                throw new Error('Invalid or expired pairing code');
+            if (!allowsOrigin(origin))
+                throw new Error('Origin not allowed for pairing');
+            const granted = requested ?? scopes;
+            if (granted.some((scope) => !scopes.includes(scope)))
+                throw new Error('Requested scope is not offered');
+            const token = node_crypto_1.default.randomBytes(32).toString('base64url');
+            const clientId = `pair-${node_crypto_1.default.randomBytes(8).toString('hex')}`;
+            store.clients[clientId] = {
+                clientId,
+                origin,
+                devicePublicKey,
+                scopes: granted,
+                tokenHash: sha256(token),
+                createdAt: now(),
+                lastUsedAt: now(),
+            };
+            persist();
+            sessions.delete(hash);
+            return {
+                token,
+                clientId,
+                node: { nodeId, fingerprint, network },
+                capabilities,
+            };
+        },
+        identity() {
+            return {
+                nodeId,
+                fingerprint,
+                publicKey: store.identity.publicKey,
+                network,
+                capabilities,
+            };
+        },
+        listClients() {
+            return Object.values(store.clients);
+        },
+        revoke(clientId) {
+            const client = store.clients[clientId];
+            if (!client)
+                return false;
+            client.revokedAt = now();
+            persist();
+            return true;
+        },
+        allowsOrigin,
+    };
+}
+function createPairingHttpServer(service, options) {
+    const maxBodyBytes = options.maxBodyBytes ?? 16 * 1024;
+    const server = node_http_1.default.createServer(async (req, res) => {
+        const origin = typeof req.headers.origin === 'string' ? req.headers.origin : undefined;
+        const cors = () => {
+            if (origin && service.allowsOrigin(origin)) {
+                res.setHeader('access-control-allow-origin', origin);
+                res.setHeader('vary', 'Origin');
+            }
+            res.setHeader('access-control-allow-methods', 'GET,POST,OPTIONS');
+            res.setHeader('access-control-allow-headers', 'content-type');
+        };
+        cors();
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204).end();
+            return;
+        }
+        const send = (status, body) => {
+            const payload = JSON.stringify(body);
+            res.writeHead(status, { 'content-type': 'application/json', 'content-length': Buffer.byteLength(payload) });
+            res.end(payload);
+        };
+        const url = new URL(req.url ?? '/', 'http://localhost');
+        try {
+            if (req.method === 'GET' && url.pathname === '/healthz')
+                return send(200, { ok: true });
+            if (req.method === 'GET' && url.pathname === '/node/v1/identity')
+                return send(200, service.identity());
+            if (req.method === 'GET' && url.pathname === '/pair/v1/info') {
+                const code = url.searchParams.get('code');
+                if (!code)
+                    return send(400, { error: 'code is required' });
+                if (origin && !service.allowsOrigin(origin))
+                    return send(403, { error: 'Origin not allowed' });
+                return send(200, service.info(code));
+            }
+            if (req.method === 'POST' && url.pathname === '/pair/v1/complete') {
+                const body = await readBody(req, maxBodyBytes);
+                const parsed = JSON.parse(body);
+                if (!parsed.code || !parsed.devicePublicKey)
+                    return send(400, { error: 'code and devicePublicKey are required' });
+                return send(200, service.complete({
+                    code: parsed.code,
+                    devicePublicKey: parsed.devicePublicKey,
+                    origin: parsed.origin ?? origin ?? '',
+                    scopes: parsed.scopes,
+                }));
+            }
+            send(404, { error: 'Not found' });
+        }
+        catch (error) {
+            send(400, { error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    let address;
+    return {
+        get address() { return address; },
+        listen: () => new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(options.port, options.host ?? '127.0.0.1', () => {
+                server.off('error', reject);
+                address = server.address();
+                resolve({ host: address.address, port: address.port });
+            });
+        }),
+        close: () => new Promise((resolve, reject) => {
+            server.close((error) => error ? reject(error) : resolve());
+        }),
+    };
+}
+async function readBody(req, limit) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buffer.length;
+        if (total > limit)
+            throw new Error('Request body too large');
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}

package/dist/signer-port.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Local signer port (RFC-058 P1).
+ *
+ * Adapts the host's unified TreeKey signer + WOTS lease to the SDK `SignerPort`
+ * contract. A hosted deployment supplies its own `SignerPort` (KMS/HSM/MPC +
+ * policy) instead; the host code is agnostic.
+ */
+import { type CustodyMode, type SignDomain, type SignRequest, type SignerPort } from '@totemsdk/omnia';
+import type { HostSigning } from './signing.js';
+export declare function createLocalSignerPort(signing: HostSigning): SignerPort;
+/** Hosted/KMS policy checks applied before delegating to the underlying port. */
+export interface SignerPolicy {
+    allowedDomains?: SignDomain[];
+    allowedModes?: CustodyMode[];
+    /** Reject requests whose declared amount exceeds this value (base units). */
+    maxAmount?: bigint;
+    /** Require a disclosure hash/version on the custody context. */
+    requireDisclosure?: boolean;
+    /** Additional operator approval hook (KMS/HSM/MPC or quorum). */
+    authorize?: (request: SignRequest) => void | Promise<void>;
+}
+/**
+ * Wrap a signer port with policy checks. The underlying port may be a local
+ * signer, KMS/HSM/MPC adapter, or hosted policy engine; this wrapper only
+ * enforces the deployment policy and disclosure requirements.
+ */
+export declare function createPolicySignerPort(base: SignerPort, policy?: SignerPolicy): SignerPort;

package/dist/signer-port.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Local signer port (RFC-058 P1).
+ *
+ * Adapts the host's unified TreeKey signer + WOTS lease to the SDK `SignerPort`
+ * contract. A hosted deployment supplies its own `SignerPort` (KMS/HSM/MPC +
+ * policy) instead; the host code is agnostic.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalSignerPort = createLocalSignerPort;
+exports.createPolicySignerPort = createPolicySignerPort;
+const core_1 = require("@totemsdk/core");
+const omnia_1 = require("@totemsdk/omnia");
+function createLocalSignerPort(signing) {
+    return {
+        publicKeyDigest: signing.publicKeyDigest,
+        async sign(request) {
+            (0, omnia_1.assertSignRequest)(request);
+            if (!request.signers.includes(signing.publicKeyDigest)) {
+                throw new Error(`local signer ${signing.publicKeyDigest} is not a required signer for ${request.requestId}`);
+            }
+            const payload = (0, omnia_1.signRequestPayload)(request);
+            if (request.signingIndices) {
+                // Caller owns the lease (channel/factory tx signing); sign the exact leaf.
+                return signing.signer.sign(payload, request.signingIndices);
+            }
+            const reservation = await signing.leaseProvider.reserveKeyUse({
+                treeId: 'omnia-sign-request',
+                purpose: `sign-request:${request.domain}`,
+                payloadHash: (0, core_1.bytesToHex)(payload),
+            });
+            try {
+                const signature = await signing.signer.sign(payload, reservation.indices);
+                await signing.leaseProvider.commitKeyUse(reservation.reservationId, `sign-request:${request.domain}`);
+                return signature;
+            }
+            catch (err) {
+                await signing.leaseProvider
+                    .burnReservation(reservation.reservationId, 'sign-request-failed')
+                    .catch(() => { });
+                throw err;
+            }
+        },
+    };
+}
+/**
+ * Wrap a signer port with policy checks. The underlying port may be a local
+ * signer, KMS/HSM/MPC adapter, or hosted policy engine; this wrapper only
+ * enforces the deployment policy and disclosure requirements.
+ */
+function createPolicySignerPort(base, policy = {}) {
+    return {
+        publicKeyDigest: base.publicKeyDigest,
+        async sign(request) {
+            (0, omnia_1.assertSignRequest)(request);
+            if (!request.signers.includes(base.publicKeyDigest)) {
+                throw new Error(`signer ${base.publicKeyDigest} is not a required signer for ${request.requestId}`);
+            }
+            if (policy.allowedDomains && !policy.allowedDomains.includes(request.domain)) {
+                throw new Error(`domain ${request.domain} is not allowed by policy`);
+            }
+            if (policy.allowedModes && !policy.allowedModes.includes(request.custody.mode)) {
+                throw new Error(`custody mode ${request.custody.mode} is not allowed by policy`);
+            }
+            if (policy.requireDisclosure && (!request.custody.disclosureHash || !request.custody.disclosureVersion)) {
+                throw new Error('policy requires a disclosure hash and version');
+            }
+            const amount = request.context.amount;
+            if (policy.maxAmount !== undefined && amount !== undefined) {
+                const parsed = BigInt(amount);
+                if (parsed > policy.maxAmount) {
+                    throw new Error(`request amount ${parsed} exceeds policy limit ${policy.maxAmount}`);
+                }
+            }
+            await policy.authorize?.(request);
+            return base.sign(request);
+        },
+    };
+}

package/dist/stores/operations.d.ts

@@ -9,10 +9,11 @@ export interface OperationRecord {
     result?: unknown;
     error?: string;
 }
-/** Durable operation journal with atomic status transitions. */
+/** Durable operation journal with atomic status transitions, via storage SDK. */
 export declare class OperationStore {
-    private readonly db;
+    private readonly kv;
     constructor(dbPath: string);
+    private migrateLegacy;
     get(operationId: string): OperationRecord | undefined;
     create(operationId: string, request?: unknown, now?: number): OperationRecord;
     verifyRequest(operationId: string, request: unknown): boolean;

package/dist/stores/operations.js

@@ -1,120 +1,133 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationStore = void 0;
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const node_crypto_1 = require("node:crypto");
+const sqlite_sync_1 = require("@totemsdk/storage/sqlite-sync");
+const PREFIX = 'omnia:operation:';
+const FORMAT_KEY = 'omnia:store:operation:format';
+const STORE_FORMAT = 1;
 /**
- * CAN-001: operation requests/results can carry `bigint` amounts (e.g. a
- * multi-hop route's hop amounts). `JSON.stringify` throws on bigint, so encode
- * with a reversible tag and decode it back — the journal never sees a raw
- * primitive it cannot persist.
+ * CAN-001: operation requests/results can carry `bigint` amounts. The storage
+ * codec tags bigints natively, so the record is persisted as-is. Legacy
+ * `omnia_operations` rows (JSON with `{$bigint}` tags) are migrated on open.
  */
-function bigintReplacer(_key, value) {
-    return typeof value === 'bigint' ? { $bigint: value.toString() } : value;
-}
-function bigintReviver(_key, value) {
-    if (value !== null &&
-        typeof value === 'object' &&
-        typeof value.$bigint === 'string' &&
-        Object.keys(value).length === 1) {
-        return BigInt(value.$bigint);
-    }
-    return value;
-}
-function encode(value) {
-    return value === undefined ? null : JSON.stringify(value, bigintReplacer);
-}
-function decode(value) {
-    return value === null ? undefined : JSON.parse(value, bigintReviver);
-}
-function toRecord(row) {
-    return {
-        operationId: row.operation_id,
-        status: row.status,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-        request: decode(row.request_json),
-        requestDigest: row.request_digest ?? undefined,
-        result: decode(row.result_json),
-        error: row.error ?? undefined,
-    };
+function decodeLegacy(value) {
+    if (value === null)
+        return undefined;
+    return JSON.parse(value, (_key, nested) => {
+        if (nested !== null &&
+            typeof nested === 'object' &&
+            typeof nested.$bigint === 'string' &&
+            Object.keys(nested).length === 1) {
+            return BigInt(nested.$bigint);
+        }
+        return nested;
+    });
 }
-/** Durable operation journal with atomic status transitions. */
+/** Durable operation journal with atomic status transitions, via storage SDK. */
 class OperationStore {
-    db;
+    kv;
     constructor(dbPath) {
-        this.db = new better_sqlite3_1.default(dbPath);
-        this.db.pragma('journal_mode = WAL');
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS omnia_operations (
-        operation_id TEXT PRIMARY KEY,
-        status TEXT NOT NULL,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        request_json TEXT,
-        request_digest TEXT,
-        result_json TEXT,
-        error TEXT
-      )
-    `);
-        const columns = this.db.prepare('PRAGMA table_info(omnia_operations)').all();
-        if (!columns.some((column) => column.name === 'request_digest')) {
-            this.db.exec('ALTER TABLE omnia_operations ADD COLUMN request_digest TEXT');
+        this.kv = new sqlite_sync_1.SyncSqliteStore(dbPath);
+        const version = this.kv.get(FORMAT_KEY);
+        if (version !== null && version !== STORE_FORMAT) {
+            this.kv.close();
+            throw new Error(`Unsupported OperationStore format ${version} (this build supports ${STORE_FORMAT}) — refusing to open`);
         }
+        if (version === null)
+            this.migrateLegacy();
+    }
+    migrateLegacy() {
+        // One-time migration from the pre-storage direct-SQLite table.
+        this.kv.migrateLegacyTable('omnia_operations', (row) => {
+            const request = decodeLegacy(row['request_json'] ?? null);
+            const result = decodeLegacy(row['result_json'] ?? null);
+            const digestValue = row['request_digest'] ? String(row['request_digest']) : undefined;
+            const error = row['error'] ? String(row['error']) : undefined;
+            const record = {
+                operationId: String(row['operation_id']),
+                status: row['status'] ?? 'unknown',
+                createdAt: Number(row['created_at']),
+                updatedAt: Number(row['updated_at']),
+                ...(request !== undefined ? { request } : {}),
+                ...(digestValue ? { requestDigest: digestValue } : {}),
+                ...(result !== undefined ? { result } : {}),
+                ...(error ? { error } : {}),
+            };
+            return { key: PREFIX + record.operationId, value: record };
+        });
+        this.kv.set(FORMAT_KEY, STORE_FORMAT);
     }
     get(operationId) {
-        const row = this.db.prepare('SELECT * FROM omnia_operations WHERE operation_id = ?').get(operationId);
-        return row ? toRecord(row) : undefined;
+        return this.kv.get(PREFIX + operationId) ?? undefined;
     }
     create(operationId, request, now = Date.now()) {
-        this.db.prepare(`
-      INSERT OR IGNORE INTO omnia_operations
-        (operation_id, status, created_at, updated_at, request_json, request_digest)
-      VALUES (?, 'pending', ?, ?, ?, ?)
-    `).run(operationId, now, now, encode(request), digest(request));
-        const record = this.get(operationId);
-        if (!record)
-            throw new Error(`Failed to create operation ${operationId}`);
-        return record;
+        return this.kv.transaction(() => {
+            const existing = this.get(operationId);
+            if (existing)
+                return existing;
+            const record = {
+                operationId,
+                status: 'pending',
+                createdAt: now,
+                updatedAt: now,
+                ...(request !== undefined ? { request } : {}),
+                requestDigest: digest(request),
+            };
+            this.kv.set(PREFIX + operationId, record);
+            return record;
+        });
     }
     verifyRequest(operationId, request) {
         const record = this.get(operationId);
         return !record?.requestDigest || record.requestDigest === digest(request);
     }
     transition(operationId, from, to, patch = {}, now = Date.now()) {
-        const result = this.db.prepare(`
-      UPDATE omnia_operations
-      SET status = ?, updated_at = ?, result_json = ?, error = ?
-      WHERE operation_id = ? AND status = ?
-    `).run(to, now, encode(patch.result), patch.error ?? null, operationId, from);
-        if (result.changes !== 1) {
-            const current = this.get(operationId);
-            if (!current)
+        return this.kv.transaction(() => {
+            const record = this.get(operationId);
+            if (!record)
                 throw new Error(`Unknown operation ${operationId}`);
-            throw new Error(`Operation ${operationId} expected status ${from} but is ${current.status}`);
-        }
-        return this.get(operationId);
+            if (record.status !== from) {
+                throw new Error(`Operation ${operationId} expected status ${from} but is ${record.status}`);
+            }
+            const next = {
+                ...record,
+                status: to,
+                updatedAt: now,
+                ...(patch.error !== undefined ? { error: patch.error } : {}),
+                ...(patch.result !== undefined ? { result: patch.result } : {}),
+            };
+            this.kv.set(PREFIX + operationId, next);
+            return next;
+        });
     }
     listByStatus(status) {
-        const rows = this.db.prepare('SELECT * FROM omnia_operations WHERE status = ? ORDER BY created_at').all(status);
-        return rows.map(toRecord);
+        return this.kv
+            .keys()
+            .filter((key) => key.startsWith(PREFIX))
+            .map((key) => this.kv.get(key))
+            .filter((record) => record !== null)
+            .filter((record) => record.status === status)
+            .sort((a, b) => a.createdAt - b.createdAt);
     }
     close() {
-        this.db.close();
+        this.kv.close();
     }
 }
 exports.OperationStore = OperationStore;
 function canonical(value) {
+    if (value === undefined)
+        return 'undefined';
     if (typeof value === 'bigint')
         return `{"$bigint":${JSON.stringify(value.toString())}}`;
     if (value === null || typeof value !== 'object')
-        return JSON.stringify(value);
+        return JSON.stringify(value) ?? 'null';
     if (Array.isArray(value))
         return `[${value.map(canonical).join(',')}]`;
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+    return `{${Object.keys(value)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+        .join(',')}}`;
 }
 function digest(value) {
     return (0, node_crypto_1.createHash)('sha256').update(canonical(value)).digest('hex');