@psavelis/enterprise-blockchain 0.1.0 → 1.1.1

package/dist/stark-settlement/domain/value-objects.js

@@ -0,0 +1,500 @@
+/**
+ * Value Objects for Aggregated STARK Settlement Layer
+ *
+ * Immutable, self-validating value types that encapsulate domain concepts:
+ * - FieldElement: Arithmetic in the STARK prime field
+ * - IdempotencyKey: Collision-resistant exactly-once keys
+ * - ProofCommitment: Succinct commitment to a STARK proof
+ * - StateRoot: Merkle root of ledger state
+ *
+ * Value objects are equal if their values are equal (no identity).
+ * All validation happens at construction time.
+ *
+ * @see modules/mpc/src/field.ts for field arithmetic patterns
+ */
+import { createHash, randomBytes } from "node:crypto";
+// ─────────────────────────────────────────────────────────────────────────────
+// STARK Field Constants
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * STARK prime field: 2^251 + 17 * 2^192 + 1
+ * This is the prime used by StarkNet/Cairo for field operations.
+ */
+export const STARK_PRIME = 0x800000000000011000000000000000000000000000000000000000000000001n;
+/**
+ * Generator of the multiplicative group of the STARK field.
+ */
+export const STARK_GENERATOR = 3n;
+// ─────────────────────────────────────────────────────────────────────────────
+// FieldElement
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * An element in the STARK prime field.
+ *
+ * Supports modular arithmetic operations and serialization.
+ * Immutable - all operations return new instances.
+ */
+export class FieldElement {
+    value;
+    prime;
+    constructor(value, prime = STARK_PRIME) {
+        this.value = value;
+        this.prime = prime;
+    }
+    /**
+     * Create a field element from a bigint.
+     * Value is automatically reduced modulo prime.
+     */
+    static fromBigInt(value, prime = STARK_PRIME) {
+        const reduced = ((value % prime) + prime) % prime;
+        return new FieldElement(reduced, prime);
+    }
+    /**
+     * Create a field element from a hex string.
+     */
+    static fromHex(hex, prime = STARK_PRIME) {
+        const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+        return FieldElement.fromBigInt(BigInt("0x" + cleanHex), prime);
+    }
+    /**
+     * Create a field element from a byte array (big-endian).
+     */
+    static fromBytes(bytes, prime = STARK_PRIME) {
+        let value = 0n;
+        for (const byte of bytes) {
+            value = (value << 8n) | BigInt(byte);
+        }
+        return FieldElement.fromBigInt(value, prime);
+    }
+    /**
+     * Generate a random field element.
+     */
+    static random(prime = STARK_PRIME) {
+        const byteLength = Math.ceil(prime.toString(2).length / 8);
+        let value;
+        do {
+            const bytes = randomBytes(byteLength);
+            value = BigInt("0x" + bytes.toString("hex"));
+        } while (value >= prime);
+        return new FieldElement(value, prime);
+    }
+    /**
+     * Zero element in the field.
+     */
+    static zero(prime = STARK_PRIME) {
+        return new FieldElement(0n, prime);
+    }
+    /**
+     * One (multiplicative identity) in the field.
+     */
+    static one(prime = STARK_PRIME) {
+        return new FieldElement(1n, prime);
+    }
+    /**
+     * Modular addition: (this + other) mod prime
+     */
+    add(other) {
+        this.#assertSamePrime(other);
+        return FieldElement.fromBigInt(this.value + other.value, this.prime);
+    }
+    /**
+     * Modular subtraction: (this - other) mod prime
+     */
+    sub(other) {
+        this.#assertSamePrime(other);
+        return FieldElement.fromBigInt(this.value - other.value, this.prime);
+    }
+    /**
+     * Modular multiplication: (this * other) mod prime
+     */
+    mul(other) {
+        this.#assertSamePrime(other);
+        return FieldElement.fromBigInt(this.value * other.value, this.prime);
+    }
+    /**
+     * Modular exponentiation: this^exp mod prime
+     * Uses square-and-multiply for O(log exp) complexity.
+     */
+    pow(exp) {
+        let result = FieldElement.one(this.prime);
+        let base = FieldElement.fromBigInt(this.value, this.prime);
+        let e = exp;
+        while (e > 0n) {
+            if (e & 1n) {
+                result = result.mul(base);
+            }
+            e >>= 1n;
+            base = base.mul(base);
+        }
+        return result;
+    }
+    /**
+     * Modular multiplicative inverse: this^(-1) mod prime
+     * Uses Fermat's little theorem: a^(-1) = a^(p-2) mod p
+     */
+    inverse() {
+        if (this.value === 0n) {
+            throw new Error("Cannot compute inverse of zero");
+        }
+        return this.pow(this.prime - 2n);
+    }
+    /**
+     * Modular division: this / other mod prime
+     */
+    div(other) {
+        return this.mul(other.inverse());
+    }
+    /**
+     * Negation: -this mod prime
+     */
+    neg() {
+        return FieldElement.fromBigInt(-this.value, this.prime);
+    }
+    /**
+     * Check if this is zero.
+     */
+    isZero() {
+        return this.value === 0n;
+    }
+    /**
+     * Check equality with another field element.
+     */
+    equals(other) {
+        return this.value === other.value && this.prime === other.prime;
+    }
+    /**
+     * Convert to hex string (64 characters, zero-padded).
+     */
+    toHex() {
+        return this.value.toString(16).padStart(64, "0");
+    }
+    /**
+     * Convert to byte array (big-endian, 32 bytes).
+     */
+    toBytes() {
+        const hex = this.toHex();
+        const bytes = new Uint8Array(32);
+        for (let i = 0; i < 32; i++) {
+            bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+        }
+        return bytes;
+    }
+    /**
+     * String representation for debugging.
+     */
+    toString() {
+        return `FieldElement(0x${this.toHex()})`;
+    }
+    #assertSamePrime(other) {
+        if (this.prime !== other.prime) {
+            throw new Error("Cannot operate on field elements with different primes");
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// IdempotencyKey
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * A collision-resistant idempotency key for exactly-once processing.
+ *
+ * Generated from a combination of source, transaction ID, and timestamp.
+ * SHA-256 hash ensures collision resistance.
+ */
+export class IdempotencyKey {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Create an idempotency key from source components.
+     */
+    static create(source, txId, timestamp) {
+        const input = `${source}:${txId}:${timestamp}`;
+        const hash = createHash("sha256").update(input).digest("hex");
+        return new IdempotencyKey(hash);
+    }
+    /**
+     * Create from an existing key string (must be 64 hex chars).
+     */
+    static fromString(value) {
+        if (!/^[a-f0-9]{64}$/i.test(value)) {
+            throw new Error("IdempotencyKey must be 64 hex characters");
+        }
+        return new IdempotencyKey(value.toLowerCase());
+    }
+    /**
+     * Generate a random idempotency key.
+     */
+    static random() {
+        const bytes = randomBytes(32);
+        return new IdempotencyKey(bytes.toString("hex"));
+    }
+    /**
+     * Check equality with another key.
+     */
+    equals(other) {
+        return this.value === other.value;
+    }
+    /**
+     * String representation.
+     */
+    toString() {
+        return this.value;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// ProofCommitment
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * A succinct commitment to a STARK proof.
+ *
+ * Used for on-chain anchoring without storing the full proof.
+ * Computed as SHA-256(proofId || starkProof || publicInputs).
+ */
+export class ProofCommitment {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Create a commitment from proof components.
+     */
+    static create(proofId, starkProof, publicInputs) {
+        const hash = createHash("sha256");
+        hash.update(proofId);
+        hash.update(starkProof);
+        hash.update(publicInputs.join(":"));
+        return new ProofCommitment(hash.digest("hex"));
+    }
+    /**
+     * Create from an existing commitment string (must be 64 hex chars).
+     */
+    static fromString(value) {
+        if (!/^[a-f0-9]{64}$/i.test(value)) {
+            throw new Error("ProofCommitment must be 64 hex characters");
+        }
+        return new ProofCommitment(value.toLowerCase());
+    }
+    /**
+     * Check equality with another commitment.
+     */
+    equals(other) {
+        return this.value === other.value;
+    }
+    /**
+     * String representation.
+     */
+    toString() {
+        return this.value;
+    }
+    /**
+     * Convert to bytes for on-chain storage.
+     */
+    toBytes() {
+        const bytes = new Uint8Array(32);
+        for (let i = 0; i < 32; i++) {
+            bytes[i] = parseInt(this.value.slice(i * 2, i * 2 + 2), 16);
+        }
+        return bytes;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// StateRoot
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * A Merkle root representing the state of the ledger.
+ *
+ * Computed as the root of a Merkle tree over all account states.
+ * Used to prove state transitions in STARK proofs.
+ */
+export class StateRoot {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Create a state root from a hex string.
+     */
+    static fromHex(hex) {
+        const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+        if (!/^[a-f0-9]{64}$/i.test(clean)) {
+            throw new Error("StateRoot must be 64 hex characters");
+        }
+        return new StateRoot(clean.toLowerCase());
+    }
+    /**
+     * Create the genesis (empty) state root.
+     */
+    static genesis() {
+        // SHA-256 of empty string, represents empty state
+        const hash = createHash("sha256").update("").digest("hex");
+        return new StateRoot(hash);
+    }
+    /**
+     * Compute a new state root by hashing with another value.
+     * Used for incremental state updates.
+     */
+    hash(data) {
+        const hash = createHash("sha256");
+        hash.update(Buffer.from(this.value, "hex"));
+        hash.update(data);
+        return new StateRoot(hash.digest("hex"));
+    }
+    /**
+     * Check equality with another state root.
+     */
+    equals(other) {
+        return this.value === other.value;
+    }
+    /**
+     * String representation.
+     */
+    toString() {
+        return `0x${this.value}`;
+    }
+    /**
+     * Convert to bytes.
+     */
+    toBytes() {
+        const bytes = new Uint8Array(32);
+        for (let i = 0; i < 32; i++) {
+            bytes[i] = parseInt(this.value.slice(i * 2, i * 2 + 2), 16);
+        }
+        return bytes;
+    }
+    /**
+     * Convert to field element for STARK circuits.
+     */
+    toFieldElement() {
+        return FieldElement.fromHex(this.value);
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Amount
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * A validated amount with decimal conversion utilities.
+ *
+ * Stores value in atomic units (lamports, satoshis, cents).
+ * Provides conversion to/from human-readable format.
+ */
+export class Amount {
+    atomicValue;
+    decimals;
+    constructor(atomicValue, decimals) {
+        this.atomicValue = atomicValue;
+        this.decimals = decimals;
+    }
+    /**
+     * Create from atomic units (e.g., lamports, satoshis, cents).
+     */
+    static fromAtomic(value, decimals) {
+        if (value < 0n) {
+            throw new Error("Amount cannot be negative");
+        }
+        return new Amount(value, decimals);
+    }
+    /**
+     * Create from a decimal string (e.g., "1.5" SOL = 1500000000 lamports).
+     */
+    static fromDecimal(value, decimals) {
+        // Reject negative values
+        if (value.startsWith("-")) {
+            throw new Error("Amount cannot be negative");
+        }
+        const parts = value.split(".");
+        const wholePart = BigInt(parts[0] || "0");
+        const fracPart = parts[1] || "";
+        // Pad or truncate fractional part to match decimals
+        const paddedFrac = fracPart.padEnd(decimals, "0").slice(0, decimals);
+        const fracValue = BigInt(paddedFrac || "0");
+        const multiplier = 10n ** BigInt(decimals);
+        const atomicValue = wholePart * multiplier + fracValue;
+        return new Amount(atomicValue, decimals);
+    }
+    /**
+     * Add two amounts.
+     */
+    add(other) {
+        this.#assertSameDecimals(other);
+        return new Amount(this.atomicValue + other.atomicValue, this.decimals);
+    }
+    /**
+     * Subtract another amount.
+     */
+    sub(other) {
+        this.#assertSameDecimals(other);
+        const result = this.atomicValue - other.atomicValue;
+        if (result < 0n) {
+            throw new Error("Amount subtraction would result in negative value");
+        }
+        return new Amount(result, this.decimals);
+    }
+    /**
+     * Check if this amount is zero.
+     */
+    isZero() {
+        return this.atomicValue === 0n;
+    }
+    /**
+     * Compare with another amount.
+     * Returns -1 if this < other, 0 if equal, 1 if this > other.
+     */
+    compare(other) {
+        this.#assertSameDecimals(other);
+        if (this.atomicValue < other.atomicValue)
+            return -1;
+        if (this.atomicValue > other.atomicValue)
+            return 1;
+        return 0;
+    }
+    /**
+     * Convert to decimal string (e.g., "1.500000000" for 1.5 SOL).
+     */
+    toDecimal() {
+        const multiplier = 10n ** BigInt(this.decimals);
+        const wholePart = this.atomicValue / multiplier;
+        const fracPart = this.atomicValue % multiplier;
+        const fracStr = fracPart.toString().padStart(this.decimals, "0");
+        return `${wholePart}.${fracStr}`;
+    }
+    /**
+     * String representation.
+     */
+    toString() {
+        return this.toDecimal();
+    }
+    #assertSameDecimals(other) {
+        if (this.decimals !== other.decimals) {
+            throw new Error("Cannot operate on amounts with different decimal places");
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Hash Utilities
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Compute SHA-256 hash of a string.
+ */
+export function sha256(input) {
+    return createHash("sha256").update(input).digest("hex");
+}
+/**
+ * Compute SHA-256 hash of bytes.
+ */
+export function sha256Bytes(input) {
+    const hash = createHash("sha256").update(input).digest();
+    return new Uint8Array(hash);
+}
+/**
+ * Compute Pedersen hash (placeholder - actual implementation would use Cairo's Pedersen).
+ * For now, uses SHA-256 as a stand-in.
+ */
+export function pedersenHash(a, b) {
+    const hash = createHash("sha256");
+    hash.update(a.toBytes());
+    hash.update(b.toBytes());
+    const result = hash.digest();
+    // Reduce to field element
+    return FieldElement.fromBytes(result);
+}

package/dist/stark-settlement/index.d.ts

@@ -0,0 +1,172 @@
+/**
+ * @enterprise-blockchain/stark-settlement
+ *
+ * Aggregated STARK Settlement Layer with Recursive Proof Composition
+ *
+ * A production-grade, quantum-resistant settlement system that:
+ * - Uses zk-STARK proofs for verifiable state transitions
+ * - Aggregates thousands of transactions into single block proofs
+ * - Settles to multiple external chains (Solana, Bitcoin, Fiat)
+ * - Provides post-quantum security via ML-DSA-65 signatures
+ *
+ * Architecture:
+ * - Hexagonal (ports & adapters) with no SDK imports in domain layer
+ * - 3-tier recursive proof aggregation (Base → Tier-1 → Tier-2)
+ * - Exactly-once settlement semantics via idempotency keys
+ * - Full observability with OpenTelemetry
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   LedgerService,
+ *   AggregatorService,
+ *   SettlementService,
+ *   createDefaultContext,
+ * } from "@enterprise-blockchain/stark-settlement";
+ *
+ * // Create services with default adapters
+ * const ctx = createDefaultContext();
+ * const ledger = new LedgerService(ctx);
+ * const aggregator = new AggregatorService(ctx);
+ * const settler = new SettlementService(ctx);
+ *
+ * // Submit a transaction
+ * const tx = await ledger.submitTransaction({
+ *   type: "transfer",
+ *   fromAccountId: "alice",
+ *   toAccountId: "bob",
+ *   assetType: "SOL",
+ *   amount: 1000000000n, // 1 SOL in lamports
+ * });
+ *
+ * // Generate proofs and settle
+ * const blockProof = await aggregator.processToBlockProof();
+ * const result = await settler.settleAllRails(blockProof);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export type { AssetType, AssetConfig, MirrorAccount, TransactionType, TransactionStatus, LedgerTransaction, TransactionPayload, BaseProof, Tier1Proof, Tier2BlockProof, OutboxEntryStatus, OutboxEntry, NetTransfer, SolanaSettlementResult, BitcoinSettlementResult, FiatSettlementResult, DepositEvent, RaftState, RaftNode, AuditRecord, } from "./domain/entities.js";
+export { ASSET_CONFIGS } from "./domain/entities.js";
+export { STARK_PRIME, STARK_GENERATOR, FieldElement, IdempotencyKey, ProofCommitment, StateRoot, Amount, sha256, sha256Bytes, pedersenHash, } from "./domain/value-objects.js";
+export type { StarkProofGeneratorPort, LedgerPersistencePort, OutboxPort, OffsetTrackingPort, SolanaSettlementPort, BitcoinSettlementPort, FiatSettlementPort, OutboxListenerPort, DilithiumSigningPort, TransactionSigningPort, AuditPort, RaftPort, ClockPort, SettlementEvent, EventEmitterPort, } from "./domain/ports.js";
+export { InMemoryLedgerStore } from "./infrastructure/persistence/ledger-store.js";
+export { InMemoryOutboxStore } from "./infrastructure/persistence/outbox-store.js";
+export { InMemoryOffsetStore } from "./infrastructure/persistence/offset-store.js";
+export { MockStarkAdapter, FlexibleMockStarkAdapter, } from "./infrastructure/adapters/mock-stark-adapter.js";
+export type { MockStarkAdapterConfig } from "./infrastructure/adapters/mock-stark-adapter.js";
+export { SystemClock, FixedClock, defaultClock, } from "./infrastructure/adapters/clock-adapter.js";
+export { InMemoryEventEmitter, AsyncEventEmitter, defaultEventEmitter, } from "./infrastructure/adapters/event-emitter-adapter.js";
+export { DilithiumSigningAdapter, TransactionSigningAdapter, MockDilithiumAdapter, defaultDilithiumAdapter, createTransactionSigningAdapter, } from "./infrastructure/adapters/dilithium-adapter.js";
+export { InMemoryAuditLog, defaultAuditLog, } from "./infrastructure/adapters/audit-adapter.js";
+export { StarknetProofAdapter, createStarknetProofAdapter, } from "./infrastructure/adapters/starknet-proof-adapter.js";
+export type { StarknetProofAdapterConfig } from "./infrastructure/adapters/starknet-proof-adapter.js";
+export { StoneProofAdapter, createStoneProofAdapter, } from "./infrastructure/adapters/stone-proof-adapter.js";
+export type { StoneProofAdapterConfig } from "./infrastructure/adapters/stone-proof-adapter.js";
+export { SolanaDevnetAdapter, MockSolanaAdapter, } from "./infrastructure/adapters/solana-adapter.js";
+export type { SolanaAdapterConfig } from "./infrastructure/adapters/solana-adapter.js";
+export { BitcoinTestnetAdapter, MockBitcoinAdapter, } from "./infrastructure/adapters/bitcoin-adapter.js";
+export type { BitcoinAdapterConfig } from "./infrastructure/adapters/bitcoin-adapter.js";
+export { FiatMockAdapter, MockFiatAdapter, } from "./infrastructure/adapters/fiat-adapter.js";
+export type { FiatAdapterConfig } from "./infrastructure/adapters/fiat-adapter.js";
+export { LedgerService } from "./application/ledger-service.js";
+export type { CreateAccountOptions, SubmitTransactionOptions, SubmitTransactionResult, } from "./application/ledger-service.js";
+export { AggregatorService } from "./application/aggregator-service.js";
+export type { AggregationResult, AggregatorConfig, } from "./application/aggregator-service.js";
+export { SettlementService } from "./application/settlement-service.js";
+export type { SettlementRailResult, SettleAllRailsResult, SettlementServiceConfig, } from "./application/settlement-service.js";
+import type { StarkProofGeneratorPort, LedgerPersistencePort, OutboxPort, OffsetTrackingPort, DilithiumSigningPort, TransactionSigningPort, AuditPort, ClockPort, EventEmitterPort } from "./domain/ports.js";
+/**
+ * Context containing all dependencies for the settlement layer.
+ *
+ * Follows dependency injection pattern for testability.
+ */
+export interface SettlementContext {
+    readonly clock: ClockPort;
+    readonly ledgerStore: LedgerPersistencePort;
+    readonly outboxStore: OutboxPort;
+    readonly offsetStore: OffsetTrackingPort;
+    readonly starkProver: StarkProofGeneratorPort;
+    readonly dilithium: DilithiumSigningPort;
+    readonly transactionSigning: TransactionSigningPort;
+    readonly auditLog: AuditPort;
+    readonly events: EventEmitterPort;
+}
+/**
+ * Options for creating a settlement context.
+ */
+export interface CreateContextOptions {
+    /** Clock implementation (default: SystemClock) */
+    clock?: ClockPort;
+    /** Ledger store implementation (default: InMemoryLedgerStore) */
+    ledgerStore?: LedgerPersistencePort;
+    /** Outbox store implementation (default: InMemoryOutboxStore) */
+    outboxStore?: OutboxPort;
+    /** Offset store implementation (default: InMemoryOffsetStore) */
+    offsetStore?: OffsetTrackingPort;
+    /** STARK prover implementation (default: FlexibleMockStarkAdapter) */
+    starkProver?: StarkProofGeneratorPort;
+    /** Dilithium signing implementation (default: DilithiumSigningAdapter) */
+    dilithium?: DilithiumSigningPort;
+    /** Transaction signing implementation (default: TransactionSigningAdapter) */
+    transactionSigning?: TransactionSigningPort;
+    /** Audit log implementation (default: InMemoryAuditLog) */
+    auditLog?: AuditPort;
+    /** Event emitter implementation (default: InMemoryEventEmitter) */
+    events?: EventEmitterPort;
+    /** Tier-1 batch size for mock STARK adapter (default: 8) */
+    tier1BatchSize?: number;
+    /** Tier-2 batch size for mock STARK adapter (default: 4) */
+    tier2BatchSize?: number;
+}
+/**
+ * Create a settlement context with default or custom adapters.
+ *
+ * @example
+ * ```typescript
+ * // Default context (all in-memory, mock STARK)
+ * const ctx = createDefaultContext();
+ *
+ * // Custom batch sizes for demos
+ * const demoCtx = createDefaultContext({
+ *   tier1BatchSize: 4,
+ *   tier2BatchSize: 2,
+ * });
+ *
+ * // Custom adapters (clock must be passed to StarknetProofAdapter)
+ * const clock = new SystemClock();
+ * const prodCtx = createDefaultContext({
+ *   clock,
+ *   starkProver: new StarknetProofAdapter(clock),
+ *   ledgerStore: new PostgresLedgerStore(connectionString),
+ * });
+ * ```
+ */
+export declare function createDefaultContext(options?: CreateContextOptions): SettlementContext;
+/**
+ * Options specific to production context.
+ */
+export interface ProductionContextOptions extends Omit<CreateContextOptions, "tier1BatchSize" | "tier2BatchSize"> {
+    /** Stone prover gRPC endpoint (default: localhost:10000) */
+    proverEndpoint?: string;
+    /** Path to compiled Cairo artifacts (default: ./cairo/artifacts) */
+    cairoArtifactsPath?: string;
+    /** Use mock adapter instead of Stone prover (default: false) */
+    useMockProver?: boolean;
+}
+/**
+ * Create a context for production with full batch sizes.
+ *
+ * By default, uses the StoneProofAdapter for real STARK proof generation.
+ * Set useMockProver: true to use the mock adapter for testing without Docker.
+ *
+ * Requires 128 * 64 = 8,192 transactions per block proof.
+ */
+export declare function createProductionContext(options?: ProductionContextOptions): SettlementContext;
+/**
+ * Create a context for testing with minimal batch sizes.
+ *
+ * Requires only 2 * 2 = 4 transactions per block proof.
+ */
+export declare function createTestContext(options?: Omit<CreateContextOptions, "tier1BatchSize" | "tier2BatchSize">): SettlementContext;
+//# sourceMappingURL=index.d.ts.map

package/dist/stark-settlement/index.d.ts.map

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