@vorionsys/platform-core 0.1.0

package/dist/proof/chain/index.js

@@ -0,0 +1,483 @@
+/**
+ * Blockchain Anchoring Module
+ *
+ * Provides optional blockchain anchoring for proofs to create
+ * tamper-evident timestamps on public ledgers.
+ *
+ * @packageDocumentation
+ */
+import { createLogger } from '../../common/logger.js';
+import { sha256, buildMerkleTree, generateAllProofs, verifyMerkleProof, hashProofToLeaf, } from '../merkle.js';
+const logger = createLogger({ component: 'chain-anchor' });
+// =============================================================================
+// CHAIN ANCHOR SERVICE
+// =============================================================================
+/**
+ * Service for anchoring proofs to blockchain
+ *
+ * Supports multiple chains and batching via Merkle trees for efficiency.
+ *
+ * Architecture layers:
+ *  1. Local proof layer (current): In-memory Map + optional database persistence.
+ *     All anchoring operations store proofs locally with deterministic anchor IDs,
+ *     Merkle tree batching, and full verification capabilities.
+ *  2. L2 blockchain layer (future): Polygon / Arbitrum on-chain anchoring.
+ *     When rpcUrl and contractAddress are configured, Merkle roots will be
+ *     submitted to an on-chain anchor contract for tamper-evident timestamping.
+ *
+ * // ---- Future Polygon L2 Integration Architecture ----
+ * // When config.rpcUrl and config.contractAddress are set:
+ * //   1. anchorProof / anchorBatch computes the Merkle root as it does today
+ * //   2. A ProofAnchorContract adapter calls:
+ * //        contract.anchorRoot(merkleRoot, leafCount, metadata)
+ * //   3. The tx receipt provides txHash and blockNumber for ProofAnchorResult
+ * //   4. Verification calls contract.verifyRoot(merkleRoot) to confirm on-chain
+ * //   5. The in-memory store continues to hold Merkle paths for local verification
+ * // ---------------------------------------------------
+ */
+export class ChainAnchorService {
+    config;
+    db;
+    pendingProofs = [];
+    stats = {
+        totalAnchored: 0,
+        totalBatches: 0,
+        pendingCount: 0,
+    };
+    /**
+     * In-memory anchor store keyed by proofId.
+     * Serves as the primary local proof layer. In production this would be
+     * backed by the database; the in-memory Map provides zero-dependency
+     * functionality for development and testing.
+     */
+    anchorStore = new Map();
+    /**
+     * Auto-incrementing simulated block number for the local anchor layer.
+     * Each anchorProof call increments this to simulate blockchain progression.
+     */
+    simulatedBlockNumber = 0;
+    constructor(config) {
+        this.config = config;
+        logger.info('Chain anchor service created', {
+            batchSize: config.defaultBatchSize,
+            chain: config.chain,
+        });
+    }
+    /**
+     * Initialize with database connection
+     */
+    initialize(db) {
+        this.db = db;
+        logger.info('Chain anchor service initialized');
+    }
+    /**
+     * Check if anchoring is enabled
+     */
+    isEnabled() {
+        return this.config.enabled ?? true;
+    }
+    /**
+     * Add proofs to the current batch
+     */
+    async addProofsToBatch(proofs) {
+        this.pendingProofs.push(...proofs);
+        this.stats.pendingCount = this.pendingProofs.length;
+        logger.debug('Added proofs to batch', {
+            added: proofs.length,
+            pending: this.pendingProofs.length,
+        });
+        // Auto-flush if batch size reached
+        const batchSize = this.config.defaultBatchSize ?? 1000;
+        if (this.pendingProofs.length >= batchSize) {
+            await this.processPendingBatches();
+        }
+    }
+    /**
+     * Process pending batches
+     */
+    async processPendingBatches() {
+        if (this.pendingProofs.length === 0) {
+            return [];
+        }
+        const batchSize = this.config.defaultBatchSize ?? 1000;
+        const results = [];
+        while (this.pendingProofs.length > 0) {
+            const batch = this.pendingProofs.splice(0, batchSize);
+            const result = await this.anchorBatch(batch);
+            results.push(result);
+        }
+        this.stats.pendingCount = 0;
+        return results;
+    }
+    /**
+     * Anchor a single proof to blockchain
+     *
+     * Local proof layer implementation:
+     *  - Generates a deterministic anchor ID (txHash) from the proof hash using SHA-256
+     *  - Assigns an incrementing simulated block number
+     *  - Stores the anchor record in the in-memory store for later lookup and verification
+     *
+     * When a real blockchain backend is configured (rpcUrl + contractAddress),
+     * this method would submit the proof hash to the on-chain anchor contract
+     * and use the actual txHash and blockNumber from the receipt.
+     */
+    async anchorProof(proof) {
+        logger.info('Anchoring proof', { proofId: proof.id });
+        const chainId = this.config.chain || 'local';
+        const anchoredAt = new Date();
+        // Generate a deterministic anchor ID (txHash) from the proof hash.
+        // Prefixed with '0x' to resemble an EVM transaction hash.
+        const txHash = '0x' + await sha256(`anchor:${proof.hash}:${proof.id}`);
+        // Simulate block progression
+        this.simulatedBlockNumber++;
+        const blockNumber = this.simulatedBlockNumber;
+        const result = {
+            proofId: proof.id,
+            success: true,
+            txHash,
+            blockNumber,
+            chainId,
+            anchoredAt,
+        };
+        // Store in the local anchor store for lookup and verification
+        this.anchorStore.set(proof.id, {
+            result,
+            proofHash: proof.hash,
+            storedAt: anchoredAt,
+        });
+        this.stats.totalAnchored++;
+        this.stats.lastAnchorAt = anchoredAt;
+        this.stats.chainId = chainId;
+        logger.info('Proof anchored', {
+            proofId: proof.id,
+            txHash: txHash.slice(0, 18) + '...',
+            blockNumber,
+            chainId,
+        });
+        return result;
+    }
+    /**
+     * Anchor a batch of proofs using Merkle tree
+     *
+     * Implementation:
+     *  1. Convert each proof into a Merkle leaf hash (sha256 of proofId:proofHash)
+     *  2. Build a binary Merkle tree from all leaf hashes
+     *  3. Generate individual Merkle proofs (inclusion paths) for every leaf
+     *  4. Compute a deterministic batch txHash from the Merkle root
+     *  5. Store each proof's anchor record with its Merkle path for later verification
+     *
+     * The Merkle root is the single value that would be submitted on-chain in
+     * a production L2 deployment, making batch anchoring O(1) on-chain cost
+     * regardless of the number of proofs in the batch.
+     */
+    async anchorBatch(proofs) {
+        logger.info('Anchoring proof batch', { count: proofs.length });
+        if (proofs.length === 0) {
+            return { total: 0, succeeded: 0, failed: 0, results: [] };
+        }
+        const chainId = this.config.chain || 'local';
+        const anchoredAt = new Date();
+        const results = [];
+        let succeeded = 0;
+        let failed = 0;
+        try {
+            // Step 1: Compute leaf hashes for every proof in the batch
+            const leafHashes = await Promise.all(proofs.map((p) => hashProofToLeaf(p.id, p.hash)));
+            // Step 2: Build the binary Merkle tree
+            const tree = await buildMerkleTree(leafHashes);
+            // Step 3: Generate Merkle inclusion proofs for each leaf
+            const merkleProofs = generateAllProofs(tree);
+            // Step 4: Derive a deterministic batch txHash from the Merkle root
+            const batchTxHash = '0x' + await sha256(`batch-anchor:${tree.root}`);
+            // Simulate block progression for the batch (one block per batch)
+            this.simulatedBlockNumber++;
+            const blockNumber = this.simulatedBlockNumber;
+            // Step 5: Create individual anchor results and store them
+            for (let i = 0; i < proofs.length; i++) {
+                const proof = proofs[i];
+                const merkleProof = merkleProofs[i];
+                // Each proof in the batch shares the same txHash and block (batched into one tx)
+                const proofTxHash = batchTxHash;
+                const anchorResult = {
+                    proofId: proof.id,
+                    success: true,
+                    txHash: proofTxHash,
+                    blockNumber,
+                    chainId,
+                    anchoredAt,
+                };
+                // Store with Merkle path for future verification
+                this.anchorStore.set(proof.id, {
+                    result: anchorResult,
+                    proofHash: proof.hash,
+                    merkleProof,
+                    batchRoot: tree.root,
+                    storedAt: anchoredAt,
+                });
+                results.push(anchorResult);
+                succeeded++;
+            }
+            this.stats.totalAnchored += succeeded;
+            this.stats.totalBatches++;
+            this.stats.lastAnchorAt = anchoredAt;
+            this.stats.chainId = chainId;
+            logger.info('Proof batch anchored', {
+                total: proofs.length,
+                succeeded,
+                merkleRoot: tree.root.slice(0, 16) + '...',
+                batchTxHash: batchTxHash.slice(0, 18) + '...',
+                blockNumber,
+            });
+            return {
+                total: proofs.length,
+                succeeded,
+                failed,
+                results,
+                batchRoot: tree.root,
+                batchTxHash,
+            };
+        }
+        catch (error) {
+            // If Merkle tree construction fails, mark all proofs as failed
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            logger.error({ error: errorMessage, count: proofs.length }, 'Batch anchoring failed');
+            for (const proof of proofs) {
+                results.push({
+                    proofId: proof.id,
+                    success: false,
+                    chainId,
+                    error: errorMessage,
+                });
+                failed++;
+            }
+            return {
+                total: proofs.length,
+                succeeded: 0,
+                failed,
+                results,
+            };
+        }
+    }
+    /**
+     * Get anchor status for a specific proof
+     *
+     * Looks up the proof anchor record from the in-memory store.
+     * Returns the full ProofAnchorResult including txHash, blockNumber,
+     * chainId, and anchoring timestamp, or null if the proof has not
+     * been anchored.
+     *
+     * In a production deployment with database persistence, this would
+     * query the anchor records table instead of the in-memory Map.
+     */
+    async getProofAnchor(proofId) {
+        logger.debug('Getting proof anchor', { proofId });
+        const record = this.anchorStore.get(proofId);
+        if (!record) {
+            logger.debug('Proof anchor not found', { proofId });
+            return null;
+        }
+        return record.result;
+    }
+    /**
+     * Verify a proof is properly anchored
+     *
+     * Verification steps:
+     *  1. Look up the anchor record from the in-memory store
+     *  2. Verify the provided hash matches the stored proof hash
+     *  3. If the proof was part of a Merkle batch, verify the Merkle inclusion path
+     *     by recomputing the leaf hash and walking the path up to the stored root
+     *  4. Return a verification result with details
+     *
+     * In a production L2 deployment, step 3 would additionally verify
+     * that the Merkle root is anchored on-chain by querying the anchor contract.
+     */
+    async verifyProofAnchored(proofId, hash) {
+        logger.debug('Verifying proof anchor', { proofId });
+        // Step 1: Look up the anchor record
+        const record = this.anchorStore.get(proofId);
+        if (!record) {
+            return {
+                valid: false,
+                error: 'Proof anchor not found - proof has not been anchored',
+            };
+        }
+        // Step 2: Verify the proof hash matches what was anchored
+        if (record.proofHash !== hash) {
+            logger.warn('Proof hash mismatch during verification', {
+                proofId,
+                expectedHash: record.proofHash.slice(0, 16) + '...',
+                providedHash: hash.slice(0, 16) + '...',
+            });
+            return {
+                valid: false,
+                error: 'Proof hash does not match the anchored hash - possible tampering',
+                details: {
+                    anchoredHash: record.proofHash,
+                    providedHash: hash,
+                },
+            };
+        }
+        // Step 3: If part of a Merkle batch, verify the inclusion path
+        if (record.merkleProof && record.batchRoot) {
+            // Recompute the expected leaf hash from the proof data
+            const expectedLeafHash = await hashProofToLeaf(proofId, hash);
+            // Verify the leaf hash matches what's in the Merkle proof
+            if (record.merkleProof.leafHash !== expectedLeafHash) {
+                return {
+                    valid: false,
+                    error: 'Merkle leaf hash mismatch - proof data inconsistency',
+                    details: {
+                        expectedLeafHash,
+                        storedLeafHash: record.merkleProof.leafHash,
+                    },
+                };
+            }
+            // Verify the full Merkle inclusion path against the batch root
+            const merkleValid = await verifyMerkleProof(record.merkleProof, record.batchRoot);
+            if (!merkleValid) {
+                return {
+                    valid: false,
+                    error: 'Merkle inclusion proof verification failed - tree integrity compromised',
+                    details: {
+                        batchRoot: record.batchRoot,
+                        leafIndex: record.merkleProof.leafIndex,
+                        leafHash: record.merkleProof.leafHash,
+                    },
+                };
+            }
+            logger.debug('Proof anchor verified with Merkle path', {
+                proofId,
+                batchRoot: record.batchRoot.slice(0, 16) + '...',
+                leafIndex: record.merkleProof.leafIndex,
+            });
+            return {
+                valid: true,
+                details: {
+                    txHash: record.result.txHash,
+                    blockNumber: record.result.blockNumber,
+                    chainId: record.result.chainId,
+                    batchRoot: record.batchRoot,
+                    merkleLeafIndex: record.merkleProof.leafIndex,
+                    merklePathLength: record.merkleProof.siblingHashes.length,
+                    anchoredAt: record.result.anchoredAt?.toISOString(),
+                },
+            };
+        }
+        // Single proof (not batched) - hash match is sufficient
+        logger.debug('Proof anchor verified (single proof)', {
+            proofId,
+            txHash: record.result.txHash?.slice(0, 18) + '...',
+        });
+        return {
+            valid: true,
+            details: {
+                txHash: record.result.txHash,
+                blockNumber: record.result.blockNumber,
+                chainId: record.result.chainId,
+                anchoredAt: record.result.anchoredAt?.toISOString(),
+            },
+        };
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Shutdown the service
+     */
+    async shutdown() {
+        // Process any remaining proofs
+        if (this.pendingProofs.length > 0) {
+            await this.processPendingBatches();
+        }
+        logger.info('Chain anchor service shutdown');
+    }
+}
+// =============================================================================
+// CHAIN ANCHOR SCHEDULER
+// =============================================================================
+/**
+ * Scheduler for batching and periodically anchoring proofs
+ */
+export class ChainAnchorScheduler {
+    service;
+    db;
+    intervalId;
+    batchSize;
+    intervalMs;
+    constructor(service, options = {}) {
+        this.service = service;
+        this.batchSize = options.batchSize || 1000;
+        this.intervalMs = options.intervalMs || 300000; // 5 minutes default
+    }
+    /**
+     * Initialize with database connection
+     */
+    initialize(db) {
+        this.db = db;
+        logger.info('Chain anchor scheduler initialized');
+    }
+    /**
+     * Start the scheduler
+     */
+    start() {
+        if (this.intervalId) {
+            return; // Already running
+        }
+        logger.info('Starting chain anchor scheduler', {
+            batchSize: this.batchSize,
+            intervalMs: this.intervalMs,
+        });
+        this.intervalId = setInterval(() => {
+            this.flush().catch((err) => {
+                logger.error('Failed to flush anchor batch', { error: err });
+            });
+        }, this.intervalMs);
+    }
+    /**
+     * Stop the scheduler
+     */
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+            logger.info('Stopped chain anchor scheduler');
+        }
+    }
+    /**
+     * Queue a proof for anchoring
+     */
+    async queue(proof) {
+        await this.service.addProofsToBatch([proof]);
+    }
+    /**
+     * Flush pending proofs to blockchain
+     */
+    async flush() {
+        return this.service.processPendingBatches();
+    }
+    /**
+     * Get count of pending proofs
+     */
+    getPendingCount() {
+        return this.service.getStats().pendingCount;
+    }
+}
+// =============================================================================
+// FACTORY FUNCTIONS
+// =============================================================================
+/**
+ * Create a chain anchor service
+ */
+export function createChainAnchorService(config) {
+    return new ChainAnchorService(config);
+}
+/**
+ * Create a chain anchor scheduler
+ */
+export function createChainAnchorScheduler(service, options) {
+    return new ChainAnchorScheduler(service, options);
+}
+//# sourceMappingURL=index.js.map

package/dist/proof/chain/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/proof/chain/index.ts"],"names":[],"mappings":"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"}