@psavelis/enterprise-blockchain 0.1.0 → 1.1.1

package/dist/stark-settlement/infrastructure/adapters/fiat-adapter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Fiat Settlement Adapter (ISO 20022 Mock)
+ *
+ * Implements FiatSettlementPort for mock fiat settlement.
+ * Generates ISO 20022 pain.001 credit transfer messages.
+ *
+ * Features:
+ * - ISO 20022 pain.001.001.03 XML generation
+ * - Proof commitment in RemittanceInformation
+ * - Batch credit transfers
+ *
+ * @see https://www.iso20022.org/ for ISO 20022 documentation
+ * @see domain/ports.ts for FiatSettlementPort interface
+ */
+import type { NetTransfer, Tier2BlockProof, FiatSettlementResult } from "../../domain/entities.js";
+import type { FiatSettlementPort, ClockPort } from "../../domain/ports.js";
+/**
+ * Configuration for Fiat adapter.
+ */
+export interface FiatAdapterConfig {
+    /** Initiating party name */
+    initiatingPartyName?: string;
+    /** Initiating party identification */
+    initiatingPartyId?: string;
+    /** Bank BIC (SWIFT code) */
+    bankBic?: string;
+    /** Settlement date offset in days (default: 1 for T+1) */
+    settlementDateOffsetDays?: number;
+}
+/**
+ * Fiat mock adapter for settlement operations.
+ */
+export declare class FiatMockAdapter implements FiatSettlementPort {
+    private readonly clock;
+    private readonly config;
+    private messageCounter;
+    constructor(clock: ClockPort, config?: FiatAdapterConfig);
+    executeTransfer(transfers: readonly NetTransfer[], blockProof: Tier2BlockProof): Promise<FiatSettlementResult>;
+    getHealth(): Promise<{
+        healthy: boolean;
+    }>;
+    private generateMessageId;
+    private generatePain001;
+    private generateCreditTransferTxInf;
+    private formatAmount;
+    private escapeXml;
+}
+/**
+ * Mock Fiat adapter for testing.
+ */
+export declare class MockFiatAdapter implements FiatSettlementPort {
+    private readonly clock;
+    readonly settlements: Array<{
+        transfers: readonly NetTransfer[];
+        blockProofId: string;
+        result: FiatSettlementResult;
+    }>;
+    private messageCounter;
+    constructor(clock: ClockPort);
+    executeTransfer(transfers: readonly NetTransfer[], blockProof: Tier2BlockProof): Promise<FiatSettlementResult>;
+    getHealth(): Promise<{
+        healthy: boolean;
+    }>;
+}
+//# sourceMappingURL=fiat-adapter.d.ts.map

package/dist/stark-settlement/infrastructure/adapters/fiat-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fiat-adapter.d.ts","sourceRoot":"","sources":["../../../../src/stark-settlement/infrastructure/adapters/fiat-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAG3E;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,4BAA4B;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,sCAAsC;IACtC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,4BAA4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AAED;;GAEG;AACH,qBAAa,eAAgB,YAAW,kBAAkB;IAKtD,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,cAAc,CAAK;gBAGR,KAAK,EAAE,SAAS,EACjC,MAAM,CAAC,EAAE,iBAAiB;IAWtB,eAAe,CACnB,SAAS,EAAE,SAAS,WAAW,EAAE,EACjC,UAAU,EAAE,eAAe,GAC1B,OAAO,CAAC,oBAAoB,CAAC;IAgD1B,SAAS,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IAShD,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,eAAe;IAgEvB,OAAO,CAAC,2BAA2B;IAoCnC,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,SAAS;CAQlB;AAED;;GAEG;AACH,qBAAa,eAAgB,YAAW,kBAAkB;IAS5C,OAAO,CAAC,QAAQ,CAAC,KAAK;IARlC,SAAgB,WAAW,EAAE,KAAK,CAAC;QACjC,SAAS,EAAE,SAAS,WAAW,EAAE,CAAC;QAClC,YAAY,EAAE,MAAM,CAAC;QACrB,MAAM,EAAE,oBAAoB,CAAC;KAC9B,CAAC,CAAM;IAER,OAAO,CAAC,cAAc,CAAK;gBAEE,KAAK,EAAE,SAAS;IAEvC,eAAe,CACnB,SAAS,EAAE,SAAS,WAAW,EAAE,EACjC,UAAU,EAAE,eAAe,GAC1B,OAAO,CAAC,oBAAoB,CAAC;IA4B1B,SAAS,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAGjD"}

package/dist/stark-settlement/infrastructure/adapters/fiat-adapter.js

@@ -0,0 +1,207 @@
+/**
+ * Fiat Settlement Adapter (ISO 20022 Mock)
+ *
+ * Implements FiatSettlementPort for mock fiat settlement.
+ * Generates ISO 20022 pain.001 credit transfer messages.
+ *
+ * Features:
+ * - ISO 20022 pain.001.001.03 XML generation
+ * - Proof commitment in RemittanceInformation
+ * - Batch credit transfers
+ *
+ * @see https://www.iso20022.org/ for ISO 20022 documentation
+ * @see domain/ports.ts for FiatSettlementPort interface
+ */
+/* eslint-disable @typescript-eslint/require-await */
+import { createHash } from "node:crypto";
+import { ProofCommitment } from "../../domain/value-objects.js";
+/**
+ * Fiat mock adapter for settlement operations.
+ */
+export class FiatMockAdapter {
+    clock;
+    config;
+    messageCounter = 0;
+    constructor(clock, config) {
+        this.clock = clock;
+        this.config = {
+            initiatingPartyName: config?.initiatingPartyName ?? "Enterprise Blockchain Settlement Corp",
+            initiatingPartyId: config?.initiatingPartyId ?? "EBSC001",
+            bankBic: config?.bankBic ?? "TESTUS33XXX",
+            settlementDateOffsetDays: config?.settlementDateOffsetDays ?? 1,
+        };
+    }
+    async executeTransfer(transfers, blockProof) {
+        // Compute proof commitment for RemittanceInformation
+        const proofCommitment = ProofCommitment.create(blockProof.blockProofId, blockProof.finalProof, blockProof.publicInputs);
+        // Generate message ID
+        const messageId = this.generateMessageId();
+        // Calculate settlement date (T+1)
+        const now = new Date(this.clock.now());
+        const settlementDate = new Date(now);
+        settlementDate.setDate(settlementDate.getDate() + this.config.settlementDateOffsetDays);
+        // Calculate total amount (absolute values)
+        const totalAmount = transfers.reduce((sum, t) => sum + (t.netAmount > 0n ? t.netAmount : -t.netAmount), 0n);
+        // Generate ISO 20022 pain.001 XML
+        const pain001Xml = this.generatePain001(messageId, transfers, proofCommitment.toString(), settlementDate);
+        const settlementDateStr = settlementDate.toISOString().split("T")[0] ?? "";
+        console.log(`[Fiat] Generated pain.001 message: ${messageId}`);
+        console.log(`[Fiat] Settlement date: ${settlementDateStr}`);
+        console.log(`[Fiat] Total amount: ${totalAmount} cents`);
+        console.log(`[Fiat] Transactions: ${transfers.length}`);
+        return {
+            iso20022MessageId: messageId,
+            pain001Xml,
+            settlementDate: settlementDateStr,
+            totalAmount,
+            transactionCount: transfers.length,
+        };
+    }
+    async getHealth() {
+        // Mock always healthy
+        return { healthy: true };
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Private Helpers
+    // ─────────────────────────────────────────────────────────────────────────
+    generateMessageId() {
+        const timestamp = this.clock.now();
+        const counter = this.messageCounter++;
+        const hash = createHash("sha256")
+            .update(`${timestamp}:${counter}`)
+            .digest("hex")
+            .slice(0, 16);
+        return `EBSC-${new Date(timestamp)
+            .toISOString()
+            .replace(/[-:T.Z]/g, "")
+            .slice(0, 14)}-${hash}`;
+    }
+    generatePain001(messageId, transfers, proofCommitment, settlementDate) {
+        const creationDateTime = new Date(this.clock.now()).toISOString();
+        const settlementDateStr = settlementDate.toISOString().split("T")[0];
+        // Calculate control sum (total absolute amount)
+        const controlSum = transfers.reduce((sum, t) => sum + (t.netAmount > 0n ? t.netAmount : -t.netAmount), 0n);
+        // Generate credit transfer transactions
+        const creditTransferTxs = transfers
+            .map((t, i) => this.generateCreditTransferTxInf(t, i, proofCommitment))
+            .join("\n");
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<Document xmlns="urn:iso:std:iso:20022:tech:xsd:pain.001.001.03">
+  <CstmrCdtTrfInitn>
+    <GrpHdr>
+      <MsgId>${this.escapeXml(messageId)}</MsgId>
+      <CreDtTm>${creationDateTime}</CreDtTm>
+      <NbOfTxs>${transfers.length}</NbOfTxs>
+      <CtrlSum>${this.formatAmount(controlSum)}</CtrlSum>
+      <InitgPty>
+        <Nm>${this.escapeXml(this.config.initiatingPartyName)}</Nm>
+        <Id>
+          <OrgId>
+            <Othr>
+              <Id>${this.escapeXml(this.config.initiatingPartyId)}</Id>
+            </Othr>
+          </OrgId>
+        </Id>
+      </InitgPty>
+    </GrpHdr>
+    <PmtInf>
+      <PmtInfId>${this.escapeXml(messageId)}-PMT</PmtInfId>
+      <PmtMtd>TRF</PmtMtd>
+      <NbOfTxs>${transfers.length}</NbOfTxs>
+      <CtrlSum>${this.formatAmount(controlSum)}</CtrlSum>
+      <ReqdExctnDt>${settlementDateStr}</ReqdExctnDt>
+      <Dbtr>
+        <Nm>${this.escapeXml(this.config.initiatingPartyName)}</Nm>
+      </Dbtr>
+      <DbtrAcct>
+        <Id>
+          <IBAN>US00EBSC0000000000000001</IBAN>
+        </Id>
+      </DbtrAcct>
+      <DbtrAgt>
+        <FinInstnId>
+          <BIC>${this.config.bankBic}</BIC>
+        </FinInstnId>
+      </DbtrAgt>
+${creditTransferTxs}
+    </PmtInf>
+  </CstmrCdtTrfInitn>
+</Document>`;
+    }
+    generateCreditTransferTxInf(transfer, index, proofCommitment) {
+        const amount = transfer.netAmount > 0n ? transfer.netAmount : -transfer.netAmount;
+        return `      <CdtTrfTxInf>
+        <PmtId>
+          <EndToEndId>TX-${index.toString().padStart(6, "0")}</EndToEndId>
+        </PmtId>
+        <Amt>
+          <InstdAmt Ccy="USD">${this.formatAmount(amount)}</InstdAmt>
+        </Amt>
+        <CdtrAgt>
+          <FinInstnId>
+            <BIC>${this.config.bankBic}</BIC>
+          </FinInstnId>
+        </CdtrAgt>
+        <Cdtr>
+          <Nm>Account ${this.escapeXml(transfer.externalAddress.slice(0, 20))}</Nm>
+        </Cdtr>
+        <CdtrAcct>
+          <Id>
+            <Othr>
+              <Id>${this.escapeXml(transfer.externalAddress)}</Id>
+            </Othr>
+          </Id>
+        </CdtrAcct>
+        <RmtInf>
+          <Ustrd>STARK-PROOF:${proofCommitment.slice(0, 32)}</Ustrd>
+        </RmtInf>
+      </CdtTrfTxInf>`;
+    }
+    formatAmount(cents) {
+        const dollars = cents / 100n;
+        const remainingCents = cents % 100n;
+        return `${dollars}.${remainingCents.toString().padStart(2, "0")}`;
+    }
+    escapeXml(str) {
+        return str
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&apos;");
+    }
+}
+/**
+ * Mock Fiat adapter for testing.
+ */
+export class MockFiatAdapter {
+    clock;
+    settlements = [];
+    messageCounter = 0;
+    constructor(clock) {
+        this.clock = clock;
+    }
+    async executeTransfer(transfers, blockProof) {
+        const messageId = `MOCK-${this.messageCounter++}`;
+        const now = new Date(this.clock.now());
+        const settlementDate = new Date(now);
+        settlementDate.setDate(settlementDate.getDate() + 1);
+        const totalAmount = transfers.reduce((sum, t) => sum + (t.netAmount > 0n ? t.netAmount : -t.netAmount), 0n);
+        const result = {
+            iso20022MessageId: messageId,
+            pain001Xml: "<mock-pain001/>",
+            settlementDate: settlementDate.toISOString().split("T")[0] ?? "",
+            totalAmount,
+            transactionCount: transfers.length,
+        };
+        this.settlements.push({
+            transfers,
+            blockProofId: blockProof.blockProofId,
+            result,
+        });
+        return result;
+    }
+    async getHealth() {
+        return { healthy: true };
+    }
+}

package/dist/stark-settlement/infrastructure/adapters/mock-stark-adapter.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Mock STARK Proof Adapter
+ *
+ * Simulated STARK proof generation for testing and demos.
+ * Generates deterministic proofs based on input data without actual cryptography.
+ *
+ * For production, use StarknetProofAdapter with real starknet.js.
+ *
+ * @see domain/ports.ts for StarkProofGeneratorPort interface
+ */
+import type { LedgerTransaction, BaseProof, Tier1Proof, Tier2BlockProof } from "../../domain/entities.js";
+import type { StarkProofGeneratorPort, ClockPort } from "../../domain/ports.js";
+/**
+ * Configuration for the mock STARK adapter.
+ */
+export interface MockStarkAdapterConfig {
+    /** Simulated proof generation delay in ms (default: 10) */
+    simulatedDelayMs?: number;
+    /** Simulated proof size in bytes (default: 1024) */
+    proofSizeBytes?: number;
+    /** Whether to simulate random failures (default: false) */
+    simulateFailures?: boolean;
+    /** Failure probability when simulateFailures is true (default: 0.01) */
+    failureProbability?: number;
+}
+/**
+ * Mock implementation of StarkProofGeneratorPort for testing.
+ */
+export declare class MockStarkAdapter implements StarkProofGeneratorPort {
+    private readonly clock;
+    private readonly config;
+    private readonly verificationKeyHash;
+    private proofCounter;
+    constructor(clock: ClockPort, config?: MockStarkAdapterConfig);
+    generateBaseProof(tx: LedgerTransaction, preStateRoot: string, postStateRoot: string): Promise<BaseProof>;
+    aggregateTier1(baseProofs: readonly BaseProof[]): Promise<Tier1Proof>;
+    aggregateTier2(tier1Proofs: readonly Tier1Proof[]): Promise<Tier2BlockProof>;
+    verifyBlockProof(blockProof: Tier2BlockProof): Promise<boolean>;
+    getVerificationKeyHash(): Promise<string>;
+    private generateMockProof;
+    private simulateDelay;
+    private maybeSimulateFailure;
+}
+/**
+ * Mock STARK adapter that allows smaller batch sizes for testing.
+ *
+ * Use this for demos where generating 8192 transactions is impractical.
+ */
+export declare class FlexibleMockStarkAdapter implements StarkProofGeneratorPort {
+    private readonly clock;
+    private readonly baseAdapter;
+    private readonly tier1BatchSize;
+    private readonly tier2BatchSize;
+    private proofCounter;
+    constructor(clock: ClockPort, config?: MockStarkAdapterConfig & {
+        tier1BatchSize?: number;
+        tier2BatchSize?: number;
+    });
+    generateBaseProof(tx: LedgerTransaction, preStateRoot: string, postStateRoot: string): Promise<BaseProof>;
+    aggregateTier1(baseProofs: readonly BaseProof[]): Promise<Tier1Proof>;
+    aggregateTier2(tier1Proofs: readonly Tier1Proof[]): Promise<Tier2BlockProof>;
+    verifyBlockProof(blockProof: Tier2BlockProof): Promise<boolean>;
+    getVerificationKeyHash(): Promise<string>;
+    private generateMockProof;
+    /**
+     * Get the configured batch sizes.
+     */
+    getBatchSizes(): {
+        tier1: number;
+        tier2: number;
+    };
+}
+//# sourceMappingURL=mock-stark-adapter.d.ts.map

package/dist/stark-settlement/infrastructure/adapters/mock-stark-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-stark-adapter.d.ts","sourceRoot":"","sources":["../../../../src/stark-settlement/infrastructure/adapters/mock-stark-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EACV,iBAAiB,EACjB,SAAS,EACT,UAAU,EACV,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oDAAoD;IACpD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;GAEG;AACH,qBAAa,gBAAiB,YAAW,uBAAuB;IAM5D,OAAO,CAAC,QAAQ,CAAC,KAAK;IALxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmC;IAC1D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAC7C,OAAO,CAAC,YAAY,CAAM;gBAGP,KAAK,EAAE,SAAS,EACjC,MAAM,GAAE,sBAA2B;IAe/B,iBAAiB,CACrB,EAAE,EAAE,iBAAiB,EACrB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,SAAS,CAAC;IAkCf,cAAc,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IAsDrE,cAAc,CAClB,WAAW,EAAE,SAAS,UAAU,EAAE,GACjC,OAAO,CAAC,eAAe,CAAC;IAuDrB,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC;IAa/D,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC;IAM/C,OAAO,CAAC,iBAAiB;YAoBX,aAAa;IAQ3B,OAAO,CAAC,oBAAoB;CAQ7B;AAED;;;;GAIG;AACH,qBAAa,wBAAyB,YAAW,uBAAuB;IAOpE,OAAO,CAAC,QAAQ,CAAC,KAAK;IANxB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmB;IAC/C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,YAAY,CAAM;gBAGP,KAAK,EAAE,SAAS,EACjC,MAAM,GAAE,sBAAsB,GAAG;QAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,CAAC;KACpB;IAOF,iBAAiB,CACrB,EAAE,EAAE,iBAAiB,EACrB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,SAAS,CAAC;IAIf,cAAc,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IA+CrE,cAAc,CAClB,WAAW,EAAE,SAAS,UAAU,EAAE,GACjC,OAAO,CAAC,eAAe,CAAC;IAsCrB,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ/D,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC;IAI/C,OAAO,CAAC,iBAAiB;IASzB;;OAEG;IACH,aAAa,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;CAGlD"}

package/dist/stark-settlement/infrastructure/adapters/mock-stark-adapter.js

@@ -0,0 +1,287 @@
+/**
+ * Mock STARK Proof Adapter
+ *
+ * Simulated STARK proof generation for testing and demos.
+ * Generates deterministic proofs based on input data without actual cryptography.
+ *
+ * For production, use StarknetProofAdapter with real starknet.js.
+ *
+ * @see domain/ports.ts for StarkProofGeneratorPort interface
+ */
+/* eslint-disable @typescript-eslint/require-await */
+import { createHash } from "node:crypto";
+/**
+ * Mock implementation of StarkProofGeneratorPort for testing.
+ */
+export class MockStarkAdapter {
+    clock;
+    config;
+    verificationKeyHash;
+    proofCounter = 0n;
+    constructor(clock, config = {}) {
+        this.clock = clock;
+        this.config = {
+            simulatedDelayMs: config.simulatedDelayMs ?? 10,
+            proofSizeBytes: config.proofSizeBytes ?? 1024,
+            simulateFailures: config.simulateFailures ?? false,
+            failureProbability: config.failureProbability ?? 0.01,
+        };
+        // Generate a deterministic verification key hash
+        this.verificationKeyHash = createHash("sha256")
+            .update("mock-stark-verification-key-v1")
+            .digest("hex");
+    }
+    async generateBaseProof(tx, preStateRoot, postStateRoot) {
+        await this.simulateDelay();
+        this.maybeSimulateFailure("generateBaseProof");
+        const proofId = this.clock.uuid();
+        const starkProof = this.generateMockProof([
+            tx.txId,
+            tx.type,
+            tx.fromAccountId ?? "",
+            tx.toAccountId ?? "",
+            tx.amount.toString(),
+            preStateRoot,
+            postStateRoot,
+        ]);
+        const publicInputs = [
+            preStateRoot,
+            postStateRoot,
+            tx.txId,
+            tx.amount.toString(16).padStart(64, "0"),
+        ];
+        return {
+            proofId,
+            txId: tx.txId,
+            starkProof,
+            publicInputs,
+            verificationKeyHash: this.verificationKeyHash,
+            preStateRoot,
+            postStateRoot,
+            createdAt: this.clock.now(),
+        };
+    }
+    async aggregateTier1(baseProofs) {
+        if (baseProofs.length !== 128) {
+            throw new Error(`Tier-1 aggregation requires exactly 128 base proofs, got ${baseProofs.length}`);
+        }
+        await this.simulateDelay();
+        this.maybeSimulateFailure("aggregateTier1");
+        const proofId = this.clock.uuid();
+        const baseProofIds = baseProofs.map((p) => p.proofId);
+        // Aggregate all proofs into a single hash
+        const proofHashes = baseProofs.map((p) => createHash("sha256").update(p.starkProof).digest("hex"));
+        const aggregatedProof = this.generateMockProof([
+            "tier1-aggregation",
+            ...proofHashes,
+        ]);
+        // Collect idempotency keys (would come from the original transactions)
+        const idempotencyKeys = baseProofs.map((p) => createHash("sha256").update(p.txId).digest("hex"));
+        // First proof's pre-state, last proof's post-state
+        const firstProof = baseProofs[0];
+        const lastProof = baseProofs[baseProofs.length - 1];
+        const preStateRoot = firstProof.preStateRoot;
+        const postStateRoot = lastProof.postStateRoot;
+        const publicInputs = [
+            preStateRoot,
+            postStateRoot,
+            baseProofs.length.toString(),
+            createHash("sha256").update(proofHashes.join("")).digest("hex"),
+        ];
+        return {
+            proofId,
+            baseProofIds,
+            aggregatedProof,
+            publicInputs,
+            idempotencyKeys,
+            preStateRoot,
+            postStateRoot,
+            txCount: 128,
+            createdAt: this.clock.now(),
+        };
+    }
+    async aggregateTier2(tier1Proofs) {
+        if (tier1Proofs.length !== 64) {
+            throw new Error(`Tier-2 aggregation requires exactly 64 Tier-1 proofs, got ${tier1Proofs.length}`);
+        }
+        await this.simulateDelay();
+        this.maybeSimulateFailure("aggregateTier2");
+        const blockProofId = this.clock.uuid();
+        const tier1ProofIds = tier1Proofs.map((p) => p.proofId);
+        // Aggregate all Tier-1 proofs into a single hash
+        const proofHashes = tier1Proofs.map((p) => createHash("sha256").update(p.aggregatedProof).digest("hex"));
+        const finalProof = this.generateMockProof([
+            "tier2-block-proof",
+            ...proofHashes,
+        ]);
+        // Collect all idempotency keys from all Tier-1 proofs
+        const idempotencyKeys = tier1Proofs.flatMap((p) => p.idempotencyKeys);
+        // Final state root (last Tier-1's post-state)
+        const lastTier1Proof = tier1Proofs[tier1Proofs.length - 1];
+        const stateRoot = lastTier1Proof.postStateRoot;
+        // Total transaction count
+        const txCount = tier1Proofs.reduce((sum, p) => sum + p.txCount, 0);
+        const publicInputs = [
+            stateRoot,
+            txCount.toString(),
+            createHash("sha256").update(proofHashes.join("")).digest("hex"),
+        ];
+        // Increment block number
+        const blockNumber = this.proofCounter++;
+        return {
+            blockProofId,
+            tier1ProofIds,
+            finalProof,
+            publicInputs,
+            stateRoot,
+            idempotencyKeys,
+            txCount,
+            blockNumber,
+            createdAt: this.clock.now(),
+        };
+    }
+    async verifyBlockProof(blockProof) {
+        await this.simulateDelay();
+        this.maybeSimulateFailure("verifyBlockProof");
+        // Mock verification: check that the proof is non-empty and has valid structure
+        return (blockProof.finalProof.length > 0 &&
+            blockProof.tier1ProofIds.length === 64 &&
+            blockProof.txCount === 128 * 64 &&
+            blockProof.stateRoot.length === 64);
+    }
+    async getVerificationKeyHash() {
+        return this.verificationKeyHash;
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────
+    generateMockProof(inputs) {
+        // Generate a deterministic mock proof based on inputs
+        const hash = createHash("sha256");
+        hash.update("mock-stark-proof-v1");
+        for (const input of inputs) {
+            hash.update(input);
+        }
+        // Create a proof of the configured size
+        const proofSeed = hash.digest();
+        const proof = new Uint8Array(this.config.proofSizeBytes);
+        // Fill with deterministic pseudo-random data based on seed
+        for (let i = 0; i < proof.length; i++) {
+            proof[i] = proofSeed[i % proofSeed.length] ^ (i & 0xff);
+        }
+        return proof;
+    }
+    async simulateDelay() {
+        if (this.config.simulatedDelayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, this.config.simulatedDelayMs));
+        }
+    }
+    maybeSimulateFailure(operation) {
+        if (this.config.simulateFailures &&
+            Math.random() < this.config.failureProbability) {
+            throw new Error(`Simulated failure in ${operation}`);
+        }
+    }
+}
+/**
+ * Mock STARK adapter that allows smaller batch sizes for testing.
+ *
+ * Use this for demos where generating 8192 transactions is impractical.
+ */
+export class FlexibleMockStarkAdapter {
+    clock;
+    baseAdapter;
+    tier1BatchSize;
+    tier2BatchSize;
+    proofCounter = 0n;
+    constructor(clock, config = {}) {
+        this.clock = clock;
+        this.baseAdapter = new MockStarkAdapter(clock, config);
+        this.tier1BatchSize = config.tier1BatchSize ?? 128;
+        this.tier2BatchSize = config.tier2BatchSize ?? 64;
+    }
+    async generateBaseProof(tx, preStateRoot, postStateRoot) {
+        return this.baseAdapter.generateBaseProof(tx, preStateRoot, postStateRoot);
+    }
+    async aggregateTier1(baseProofs) {
+        if (baseProofs.length !== this.tier1BatchSize) {
+            throw new Error(`Tier-1 aggregation requires exactly ${this.tier1BatchSize} base proofs, got ${baseProofs.length}`);
+        }
+        const proofId = this.clock.uuid();
+        const baseProofIds = baseProofs.map((p) => p.proofId);
+        const proofHashes = baseProofs.map((p) => createHash("sha256").update(p.starkProof).digest("hex"));
+        const aggregatedProof = this.generateMockProof([
+            "tier1-aggregation",
+            ...proofHashes,
+        ]);
+        const idempotencyKeys = baseProofs.map((p) => createHash("sha256").update(p.txId).digest("hex"));
+        const firstBaseProof = baseProofs[0];
+        const lastBaseProof = baseProofs[baseProofs.length - 1];
+        const preStateRoot = firstBaseProof.preStateRoot;
+        const postStateRoot = lastBaseProof.postStateRoot;
+        const publicInputs = [
+            preStateRoot,
+            postStateRoot,
+            baseProofs.length.toString(),
+        ];
+        return {
+            proofId,
+            baseProofIds,
+            aggregatedProof,
+            publicInputs,
+            idempotencyKeys,
+            preStateRoot,
+            postStateRoot,
+            txCount: this.tier1BatchSize,
+            createdAt: this.clock.now(),
+        };
+    }
+    async aggregateTier2(tier1Proofs) {
+        if (tier1Proofs.length !== this.tier2BatchSize) {
+            throw new Error(`Tier-2 aggregation requires exactly ${this.tier2BatchSize} Tier-1 proofs, got ${tier1Proofs.length}`);
+        }
+        const blockProofId = this.clock.uuid();
+        const tier1ProofIds = tier1Proofs.map((p) => p.proofId);
+        const proofHashes = tier1Proofs.map((p) => createHash("sha256").update(p.aggregatedProof).digest("hex"));
+        const finalProof = this.generateMockProof([
+            "tier2-block-proof",
+            ...proofHashes,
+        ]);
+        const idempotencyKeys = tier1Proofs.flatMap((p) => p.idempotencyKeys);
+        const lastTier1 = tier1Proofs[tier1Proofs.length - 1];
+        const stateRoot = lastTier1.postStateRoot;
+        const txCount = tier1Proofs.reduce((sum, p) => sum + p.txCount, 0);
+        const blockNumber = this.proofCounter++;
+        return {
+            blockProofId,
+            tier1ProofIds,
+            finalProof,
+            publicInputs: [stateRoot, txCount.toString()],
+            stateRoot,
+            idempotencyKeys,
+            txCount,
+            blockNumber,
+            createdAt: this.clock.now(),
+        };
+    }
+    async verifyBlockProof(blockProof) {
+        return (blockProof.finalProof.length > 0 &&
+            blockProof.tier1ProofIds.length === this.tier2BatchSize &&
+            blockProof.stateRoot.length === 64);
+    }
+    async getVerificationKeyHash() {
+        return this.baseAdapter.getVerificationKeyHash();
+    }
+    generateMockProof(inputs) {
+        const hash = createHash("sha256");
+        hash.update("flexible-mock-stark-proof-v1");
+        for (const input of inputs) {
+            hash.update(input);
+        }
+        return new Uint8Array(hash.digest());
+    }
+    /**
+     * Get the configured batch sizes.
+     */
+    getBatchSizes() {
+        return { tier1: this.tier1BatchSize, tier2: this.tier2BatchSize };
+    }
+}