@psavelis/enterprise-blockchain 0.1.0 → 1.1.1

package/dist/stark-settlement/application/ledger-service.js

@@ -0,0 +1,318 @@
+/**
+ * Ledger Service
+ *
+ * Orchestrates the ZKP ledger operations:
+ * - Account management (create, query, update)
+ * - Transaction submission with ML-DSA-65 signing
+ * - State transition proof generation
+ * - Audit logging
+ *
+ * All transactions are signed with post-quantum ML-DSA-65 signatures.
+ *
+ * @see domain/ports.ts for port interfaces
+ */
+import { createHash } from "node:crypto";
+import { StateRoot } from "../domain/value-objects.js";
+/**
+ * Ledger service for managing accounts and transactions.
+ */
+export class LedgerService {
+    ctx;
+    currentStateRoot;
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.currentStateRoot = StateRoot.genesis();
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Account Management
+    // ─────────────────────────────────────────────────────────────────────────
+    /**
+     * Create a new mirror account.
+     */
+    async createAccount(options) {
+        const now = this.ctx.clock.now();
+        const id = this.ctx.clock.uuid();
+        const account = {
+            id,
+            externalAddress: options.externalAddress,
+            assetType: options.assetType,
+            balance: options.initialBalance ?? 0n,
+            lastProofRoot: this.currentStateRoot.toString().replace("0x", ""),
+            createdAt: now,
+            updatedAt: now,
+            isActive: true,
+            metadata: options.metadata ?? {},
+        };
+        await this.ctx.ledgerStore.createAccount(account);
+        // Update state root to reflect new account
+        this.currentStateRoot = this.currentStateRoot.hash(new TextEncoder().encode(serializeWithBigInt(account)));
+        // Emit event
+        this.ctx.events.emit({
+            type: "transaction:submitted",
+            tx: {
+                txId: `account-creation-${id}`,
+                type: "deposit",
+                fromAccountId: null,
+                toAccountId: id,
+                assetType: options.assetType,
+                amount: options.initialBalance ?? 0n,
+                idempotencyKey: `account-creation-${id}`,
+                mlDsaSignature: new Uint8Array(0),
+                mlDsaPublicKeyHash: "",
+                status: "finalized",
+                metadata: { accountCreation: "true" },
+                createdAt: now,
+                updatedAt: now,
+            },
+        });
+        return account;
+    }
+    /**
+     * Get an account by ID.
+     */
+    async getAccount(accountId) {
+        return this.ctx.ledgerStore.getAccount(accountId);
+    }
+    /**
+     * Get an account by external address and asset type.
+     */
+    async getAccountByAddress(externalAddress, assetType) {
+        return this.ctx.ledgerStore.getAccountByAddress(externalAddress, assetType);
+    }
+    /**
+     * Get all accounts for an asset type.
+     */
+    async getAccountsByAssetType(assetType) {
+        return this.ctx.ledgerStore.getAccountsByAssetType(assetType);
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Transaction Submission
+    // ─────────────────────────────────────────────────────────────────────────
+    /**
+     * Submit a transaction to the ledger.
+     *
+     * The transaction is:
+     * 1. Validated (balances, account existence)
+     * 2. Signed with ML-DSA-65
+     * 3. Recorded in the ledger
+     * 4. A base STARK proof is generated
+     * 5. Account balances are updated
+     *
+     * @returns The transaction and its base proof
+     * @throws If validation fails
+     */
+    async submitTransaction(options) {
+        const now = this.ctx.clock.now();
+        const txId = this.ctx.clock.uuid();
+        // Generate idempotency key if not provided
+        const idempotencyKey = options.idempotencyKey ??
+            createHash("sha256").update(`${txId}:${now}`).digest("hex");
+        // Check for duplicate (idempotent replay)
+        const existingTxs = await this.ctx.ledgerStore.getTransactionsByIdempotencyKey(idempotencyKey);
+        if (existingTxs.length > 0) {
+            const existingTx = existingTxs[0];
+            // Look up proof using the proofId stored on the transaction (if present)
+            // or fall back to the deterministic proof ID pattern for backward compatibility
+            const txWithProofId = existingTx;
+            const proofId = txWithProofId.proofId ?? `proof-${existingTx.txId}`;
+            const existingProof = await this.ctx.ledgerStore.getBaseProof(proofId);
+            if (existingProof) {
+                return {
+                    transaction: existingTx,
+                    baseProof: existingProof,
+                    isDuplicate: true,
+                };
+            }
+            // Transaction exists but proof not found - refuse to create duplicate
+            throw new Error(`Idempotency violation: transaction with key "${idempotencyKey}" already exists (txId: ${existingTx.txId}), but proof could not be found. Refusing to create duplicate.`);
+        }
+        // Validate transaction
+        await this.validateTransaction(options);
+        // Create transaction payload for signing
+        const payload = {
+            txId,
+            type: options.type,
+            fromAccountId: options.fromAccountId ?? null,
+            toAccountId: options.toAccountId ?? null,
+            assetType: options.assetType,
+            amount: options.amount.toString(),
+            idempotencyKey,
+            createdAt: now,
+        };
+        // Sign with ML-DSA-65
+        const signature = this.ctx.transactionSigning.signPayload(payload, options.signerSecretKey);
+        const publicKeyHash = this.ctx.dilithium.hashPublicKey(options.signerPublicKey);
+        // Create transaction record
+        const transaction = {
+            txId,
+            type: options.type,
+            fromAccountId: options.fromAccountId ?? null,
+            toAccountId: options.toAccountId ?? null,
+            assetType: options.assetType,
+            amount: options.amount,
+            idempotencyKey,
+            mlDsaSignature: signature,
+            mlDsaPublicKeyHash: publicKeyHash,
+            status: "pending",
+            metadata: options.metadata ?? {},
+            createdAt: now,
+            updatedAt: now,
+        };
+        // Save transaction
+        await this.ctx.ledgerStore.appendTransaction(transaction);
+        // Compute state transition
+        const preStateRoot = this.currentStateRoot.toString().replace("0x", "");
+        await this.applyTransaction(transaction);
+        const postStateRoot = this.currentStateRoot.toString().replace("0x", "");
+        // Generate base STARK proof
+        const baseProof = await this.ctx.starkProver.generateBaseProof(transaction, preStateRoot, postStateRoot);
+        // Save base proof
+        await this.ctx.ledgerStore.saveBaseProof(baseProof);
+        // Update transaction status
+        await this.ctx.ledgerStore.updateTransactionStatus(txId, "proved");
+        // Create updated transaction with correct status for return/events
+        const provedTransaction = {
+            ...transaction,
+            status: "proved",
+            updatedAt: this.ctx.clock.now(),
+        };
+        // Log audit record
+        await this.ctx.auditLog.append({
+            eventType: "transaction_submitted",
+            entityId: txId,
+            entityType: "transaction",
+            actor: publicKeyHash,
+            timestamp: now,
+            data: {
+                type: options.type,
+                assetType: options.assetType,
+                amount: options.amount.toString(),
+                preStateRoot,
+                postStateRoot,
+            },
+        });
+        // Emit event with updated transaction
+        this.ctx.events.emit({
+            type: "transaction:submitted",
+            tx: provedTransaction,
+        });
+        this.ctx.events.emit({ type: "proof:base:generated", proof: baseProof });
+        return {
+            transaction: provedTransaction,
+            baseProof,
+            isDuplicate: false,
+        };
+    }
+    /**
+     * Get pending transactions that need proof generation.
+     */
+    async getPendingTransactions(limit = 1000) {
+        return this.ctx.ledgerStore.getPendingTransactions(limit);
+    }
+    /**
+     * Get the current state root.
+     */
+    getCurrentStateRoot() {
+        return this.currentStateRoot;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Private Helpers
+    // ─────────────────────────────────────────────────────────────────────────
+    async validateTransaction(options) {
+        // Validate based on transaction type
+        switch (options.type) {
+            case "deposit":
+                if (!options.toAccountId) {
+                    throw new Error("Deposit requires toAccountId");
+                }
+                await this.validateAccountExists(options.toAccountId, options.assetType);
+                break;
+            case "withdrawal":
+                if (!options.fromAccountId) {
+                    throw new Error("Withdrawal requires fromAccountId");
+                }
+                await this.validateAccountExists(options.fromAccountId, options.assetType);
+                await this.validateSufficientBalance(options.fromAccountId, options.amount);
+                break;
+            case "transfer":
+                if (!options.fromAccountId || !options.toAccountId) {
+                    throw new Error("Transfer requires both fromAccountId and toAccountId");
+                }
+                await this.validateAccountExists(options.fromAccountId, options.assetType);
+                await this.validateAccountExists(options.toAccountId, options.assetType);
+                await this.validateSufficientBalance(options.fromAccountId, options.amount);
+                break;
+        }
+        // Validate amount is positive
+        if (options.amount <= 0n) {
+            throw new Error("Amount must be positive");
+        }
+        // Verify signature is valid
+        const payload = {
+            txId: "validation-check",
+            type: options.type,
+            fromAccountId: options.fromAccountId ?? null,
+            toAccountId: options.toAccountId ?? null,
+            assetType: options.assetType,
+            amount: options.amount.toString(),
+            idempotencyKey: "validation-check",
+            createdAt: this.ctx.clock.now(),
+        };
+        const testSignature = this.ctx.transactionSigning.signPayload(payload, options.signerSecretKey);
+        const isValid = this.ctx.transactionSigning.verifyPayload(payload, testSignature, options.signerPublicKey);
+        if (!isValid) {
+            throw new Error("Invalid signature");
+        }
+    }
+    async validateAccountExists(accountId, expectedAssetType) {
+        const account = await this.ctx.ledgerStore.getAccount(accountId);
+        if (!account) {
+            throw new Error(`Account ${accountId} not found`);
+        }
+        if (account.assetType !== expectedAssetType) {
+            throw new Error(`Account ${accountId} has asset type ${account.assetType}, expected ${expectedAssetType}`);
+        }
+        if (!account.isActive) {
+            throw new Error(`Account ${accountId} is not active`);
+        }
+    }
+    async validateSufficientBalance(accountId, amount) {
+        const account = await this.ctx.ledgerStore.getAccount(accountId);
+        if (!account) {
+            throw new Error(`Account ${accountId} not found`);
+        }
+        if (account.balance < amount) {
+            throw new Error(`Insufficient balance: ${account.balance} < ${amount}`);
+        }
+    }
+    async applyTransaction(tx) {
+        // First, advance the state root to reflect the new transaction
+        this.currentStateRoot = this.currentStateRoot.hash(new TextEncoder().encode(serializeWithBigInt(tx)));
+        // Use the post-transaction state root for account updates
+        const postTxStateRoot = this.currentStateRoot.toString().replace("0x", "");
+        switch (tx.type) {
+            case "deposit":
+                if (tx.toAccountId) {
+                    await this.ctx.ledgerStore.updateAccountBalance(tx.toAccountId, tx.amount, postTxStateRoot);
+                }
+                break;
+            case "withdrawal":
+                if (tx.fromAccountId) {
+                    await this.ctx.ledgerStore.updateAccountBalance(tx.fromAccountId, -tx.amount, postTxStateRoot);
+                }
+                break;
+            case "transfer":
+                if (tx.fromAccountId && tx.toAccountId) {
+                    await this.ctx.ledgerStore.updateAccountBalance(tx.fromAccountId, -tx.amount, postTxStateRoot);
+                    await this.ctx.ledgerStore.updateAccountBalance(tx.toAccountId, tx.amount, postTxStateRoot);
+                }
+                break;
+        }
+    }
+}
+/**
+ * Serialize an object to JSON, converting BigInt values to strings.
+ */
+function serializeWithBigInt(obj) {
+    return JSON.stringify(obj, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+}

package/dist/stark-settlement/application/settlement-service.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Settlement Service
+ *
+ * Orchestrates outbound settlement to external chains:
+ * - Solana (devnet): VersionedTransaction with lookup tables
+ * - Bitcoin (testnet): PSBT batched UTXO spends
+ * - Fiat (mock): ISO 20022 pain.001 credit transfers
+ *
+ * Uses idempotency keys and outbox entry state transitions to coordinate
+ * settlement attempts and reduce duplicate processing.
+ *
+ * @see domain/ports.ts for settlement port interfaces
+ */
+import type { AssetType, Tier2BlockProof, OutboxEntry, SolanaSettlementResult, BitcoinSettlementResult, FiatSettlementResult } from "../domain/entities.js";
+import type { SolanaSettlementPort, BitcoinSettlementPort, FiatSettlementPort } from "../domain/ports.js";
+import type { SettlementContext } from "../index.js";
+/**
+ * Result of settling a single rail.
+ */
+export type SettlementRailResult = {
+    success: true;
+    assetType: AssetType;
+    result: SolanaSettlementResult | BitcoinSettlementResult | FiatSettlementResult;
+} | {
+    success: false;
+    assetType: AssetType;
+    error: string;
+};
+/**
+ * Result of settling all rails.
+ */
+export interface SettleAllRailsResult {
+    blockProofId: string;
+    results: SettlementRailResult[];
+    allSucceeded: boolean;
+}
+/**
+ * Settlement service configuration.
+ */
+export interface SettlementServiceConfig {
+    /** Delay between retries in ms (default: 1000) */
+    retryDelayMs?: number;
+}
+/**
+ * Settlement service for external chain settlement.
+ */
+export declare class SettlementService {
+    private readonly ctx;
+    private readonly config;
+    private solanaAdapter;
+    private bitcoinAdapter;
+    private fiatAdapter;
+    constructor(ctx: SettlementContext, config?: SettlementServiceConfig);
+    /**
+     * Set the Solana settlement adapter.
+     */
+    setSolanaAdapter(adapter: SolanaSettlementPort): void;
+    /**
+     * Set the Bitcoin settlement adapter.
+     */
+    setBitcoinAdapter(adapter: BitcoinSettlementPort): void;
+    /**
+     * Set the Fiat settlement adapter.
+     */
+    setFiatAdapter(adapter: FiatSettlementPort): void;
+    /**
+     * Settle all pending outbox entries for a block proof.
+     */
+    settleAllRails(blockProof: Tier2BlockProof): Promise<SettleAllRailsResult>;
+    /**
+     * Settle a single outbox entry.
+     */
+    settleEntry(entry: OutboxEntry, blockProof: Tier2BlockProof): Promise<SettlementRailResult>;
+    /**
+     * Process all retryable entries.
+     */
+    processRetries(): Promise<SettlementRailResult[]>;
+    /**
+     * Get health status of all settlement rails.
+     */
+    getHealth(): Promise<{
+        solana: {
+            available: boolean;
+            healthy: boolean;
+            details?: unknown;
+        };
+        bitcoin: {
+            available: boolean;
+            healthy: boolean;
+            details?: unknown;
+        };
+        fiat: {
+            available: boolean;
+            healthy: boolean;
+            details?: unknown;
+        };
+    }>;
+    private executeSettlement;
+    private settleSolana;
+    private settleBitcoin;
+    private settleFiat;
+    private getSettlementTxId;
+}
+//# sourceMappingURL=settlement-service.d.ts.map

package/dist/stark-settlement/application/settlement-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settlement-service.d.ts","sourceRoot":"","sources":["../../../src/stark-settlement/application/settlement-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EACf,WAAW,EAEX,sBAAsB,EACtB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IACE,OAAO,EAAE,IAAI,CAAC;IACd,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,EACF,sBAAsB,GACtB,uBAAuB,GACvB,oBAAoB,CAAC;CAC1B,GACD;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,kDAAkD;IAClD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAO1B,OAAO,CAAC,QAAQ,CAAC,GAAG;IANtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoC;IAC3D,OAAO,CAAC,aAAa,CAAqC;IAC1D,OAAO,CAAC,cAAc,CAAsC;IAC5D,OAAO,CAAC,WAAW,CAAmC;gBAGnC,GAAG,EAAE,iBAAiB,EACvC,MAAM,CAAC,EAAE,uBAAuB;IAOlC;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAIrD;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI;IAIvD;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAQjD;;OAEG;IACG,cAAc,CAClB,UAAU,EAAE,eAAe,GAC1B,OAAO,CAAC,oBAAoB,CAAC;IA0BhC;;OAEG;IACG,WAAW,CACf,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,eAAe,GAC1B,OAAO,CAAC,oBAAoB,CAAC;IAoFhC;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAkCvD;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC;QACzB,MAAM,EAAE;YAAE,SAAS,EAAE,OAAO,CAAC;YAAC,OAAO,EAAE,OAAO,CAAC;YAAC,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC;QACpE,OAAO,EAAE;YAAE,SAAS,EAAE,OAAO,CAAC;YAAC,OAAO,EAAE,OAAO,CAAC;YAAC,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC;QACrE,IAAI,EAAE;YAAE,SAAS,EAAE,OAAO,CAAC;YAAC,OAAO,EAAE,OAAO,CAAC;YAAC,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC;KACnE,CAAC;YA0DY,iBAAiB;YAgBjB,YAAY;YAUZ,aAAa;YAUb,UAAU;IAUxB,OAAO,CAAC,iBAAiB;CAc1B"}

package/dist/stark-settlement/application/settlement-service.js

@@ -0,0 +1,251 @@
+/**
+ * Settlement Service
+ *
+ * Orchestrates outbound settlement to external chains:
+ * - Solana (devnet): VersionedTransaction with lookup tables
+ * - Bitcoin (testnet): PSBT batched UTXO spends
+ * - Fiat (mock): ISO 20022 pain.001 credit transfers
+ *
+ * Uses idempotency keys and outbox entry state transitions to coordinate
+ * settlement attempts and reduce duplicate processing.
+ *
+ * @see domain/ports.ts for settlement port interfaces
+ */
+/**
+ * Settlement service for external chain settlement.
+ */
+export class SettlementService {
+    ctx;
+    config;
+    solanaAdapter = null;
+    bitcoinAdapter = null;
+    fiatAdapter = null;
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = {
+            retryDelayMs: config?.retryDelayMs ?? 1000,
+        };
+    }
+    /**
+     * Set the Solana settlement adapter.
+     */
+    setSolanaAdapter(adapter) {
+        this.solanaAdapter = adapter;
+    }
+    /**
+     * Set the Bitcoin settlement adapter.
+     */
+    setBitcoinAdapter(adapter) {
+        this.bitcoinAdapter = adapter;
+    }
+    /**
+     * Set the Fiat settlement adapter.
+     */
+    setFiatAdapter(adapter) {
+        this.fiatAdapter = adapter;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Settlement Operations
+    // ─────────────────────────────────────────────────────────────────────────
+    /**
+     * Settle all pending outbox entries for a block proof.
+     */
+    async settleAllRails(blockProof) {
+        const results = [];
+        // Get all pending entries for this block
+        for (const assetType of ["SOL", "BTC", "USD"]) {
+            const entries = await this.ctx.outboxStore.getPendingEntries(assetType, 100);
+            const blockEntries = entries.filter((e) => e.blockProofId === blockProof.blockProofId);
+            for (const entry of blockEntries) {
+                const result = await this.settleEntry(entry, blockProof);
+                results.push(result);
+            }
+        }
+        return {
+            blockProofId: blockProof.blockProofId,
+            results,
+            allSucceeded: results.every((r) => r.success),
+        };
+    }
+    /**
+     * Settle a single outbox entry.
+     */
+    async settleEntry(entry, blockProof) {
+        // Mark as processing
+        await this.ctx.outboxStore.markProcessing(entry.entryId);
+        try {
+            const result = await this.executeSettlement(entry, blockProof);
+            // Mark as settled
+            await this.ctx.outboxStore.markSettled(entry.entryId, this.getSettlementTxId(result));
+            // Log audit record
+            await this.ctx.auditLog.append({
+                eventType: "settlement_confirmed",
+                entityId: entry.entryId,
+                entityType: "outbox_entry",
+                actor: "settlement-service",
+                timestamp: this.ctx.clock.now(),
+                data: {
+                    assetType: entry.assetType,
+                    blockProofId: blockProof.blockProofId,
+                    settlementTxId: this.getSettlementTxId(result),
+                },
+            });
+            // Emit event with updated entry status
+            const settledEntry = {
+                ...entry,
+                status: "settled",
+                settledAt: this.ctx.clock.now(),
+                settlementTxId: this.getSettlementTxId(result),
+            };
+            this.ctx.events.emit({
+                type: "settlement:completed",
+                entry: settledEntry,
+                result,
+            });
+            return { success: true, assetType: entry.assetType, result };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Mark as failed
+            await this.ctx.outboxStore.markFailed(entry.entryId, errorMessage);
+            // Log audit record
+            await this.ctx.auditLog.append({
+                eventType: "settlement_failed",
+                entityId: entry.entryId,
+                entityType: "outbox_entry",
+                actor: "settlement-service",
+                timestamp: this.ctx.clock.now(),
+                data: {
+                    assetType: entry.assetType,
+                    blockProofId: blockProof.blockProofId,
+                    error: errorMessage,
+                    retryCount: entry.retryCount + 1,
+                },
+            });
+            // Emit event with updated entry status
+            const failedEntry = {
+                ...entry,
+                status: "failed",
+                retryCount: entry.retryCount + 1,
+                errorMessage,
+            };
+            this.ctx.events.emit({
+                type: "settlement:failed",
+                entry: failedEntry,
+                error: errorMessage,
+            });
+            return {
+                success: false,
+                assetType: entry.assetType,
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * Process all retryable entries.
+     */
+    async processRetries() {
+        const results = [];
+        for (const assetType of ["SOL", "BTC", "USD"]) {
+            const entries = await this.ctx.outboxStore.getRetryableEntries(assetType, 10);
+            for (const entry of entries) {
+                // Get the block proof for this entry
+                const blockProof = await this.ctx.ledgerStore.getTier2Proof(entry.blockProofId);
+                if (!blockProof) {
+                    console.warn(`Block proof ${entry.blockProofId} not found for retry`);
+                    continue;
+                }
+                const result = await this.settleEntry(entry, blockProof);
+                results.push(result);
+                // Delay between retries
+                if (this.config.retryDelayMs > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, this.config.retryDelayMs));
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Get health status of all settlement rails.
+     */
+    async getHealth() {
+        const result = {
+            solana: { available: false, healthy: false },
+            bitcoin: { available: false, healthy: false },
+            fiat: { available: false, healthy: false },
+        };
+        if (this.solanaAdapter) {
+            result.solana.available = true;
+            try {
+                const health = await this.solanaAdapter.getHealth();
+                result.solana.healthy = health.healthy;
+                result.solana.details = health;
+            }
+            catch {
+                result.solana.healthy = false;
+            }
+        }
+        if (this.bitcoinAdapter) {
+            result.bitcoin.available = true;
+            try {
+                const health = await this.bitcoinAdapter.getHealth();
+                result.bitcoin.healthy = health.healthy;
+                result.bitcoin.details = health;
+            }
+            catch {
+                result.bitcoin.healthy = false;
+            }
+        }
+        if (this.fiatAdapter) {
+            result.fiat.available = true;
+            try {
+                const health = await this.fiatAdapter.getHealth();
+                result.fiat.healthy = health.healthy;
+            }
+            catch {
+                result.fiat.healthy = false;
+            }
+        }
+        return result;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Private Helpers
+    // ─────────────────────────────────────────────────────────────────────────
+    async executeSettlement(entry, blockProof) {
+        switch (entry.assetType) {
+            case "SOL":
+                return this.settleSolana(entry.netTransfers, blockProof);
+            case "BTC":
+                return this.settleBitcoin(entry.netTransfers, blockProof);
+            case "USD":
+                return this.settleFiat(entry.netTransfers, blockProof);
+        }
+    }
+    async settleSolana(transfers, blockProof) {
+        if (!this.solanaAdapter) {
+            throw new Error("Solana adapter not configured");
+        }
+        return this.solanaAdapter.executeBatchedTransfer(transfers, blockProof);
+    }
+    async settleBitcoin(transfers, blockProof) {
+        if (!this.bitcoinAdapter) {
+            throw new Error("Bitcoin adapter not configured");
+        }
+        return this.bitcoinAdapter.executeBatchedSpend(transfers, blockProof);
+    }
+    async settleFiat(transfers, blockProof) {
+        if (!this.fiatAdapter) {
+            throw new Error("Fiat adapter not configured");
+        }
+        return this.fiatAdapter.executeTransfer(transfers, blockProof);
+    }
+    getSettlementTxId(result) {
+        if ("signature" in result) {
+            return result.signature; // Solana
+        }
+        if ("txid" in result) {
+            return result.txid; // Bitcoin
+        }
+        return result.iso20022MessageId; // Fiat
+    }
+}