zerc20-client-sdk 0.1.13 → 0.1.14

package/dist/wasm/serialization.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Serialization and deserialization utilities for WASM interop.
+ * Handles conversion between SDK types (camelCase) and WASM boundary types.
+ * Note: WASM types use mixed naming conventions (snake_case for some fields, camelCase for others).
+ *
+ * @remarks
+ * Most helpers in this file validate that required fields exist and that hex strings are well-formed.
+ * These validations intentionally throw early to avoid passing malformed values into WASM.
+ */
+import { AggregationTreeState, BurnArtifacts, ChainEvents, ChainLocalTeleportProofs, EventsWithEligibility, GlobalTeleportProofWithEvent, HubEntryConfig, IndexedEvent, LocalTeleportProof, SecretAndTweak, SeparatedChainEvents, TokenEntryConfig } from "../types.js";
+export type NumericValue = number | string | bigint;
+export interface RawSecretAndTweak {
+    secret: string;
+    tweak: string;
+}
+export interface RawGeneralRecipient {
+    chainId: number | string | bigint;
+    address: string;
+    tweak: string;
+    fr: string;
+    u256: string;
+}
+export interface RawBurnArtifacts {
+    burnAddress: string;
+    fullBurnAddress: string;
+    secret: string;
+    tweak?: string;
+    generalRecipient: RawGeneralRecipient;
+}
+export interface RawHubEntry {
+    hub_address: string;
+    chain_id: NumericValue;
+    rpc_urls: string[];
+}
+export interface RawTokenEntry {
+    label: string;
+    token_address: string;
+    verifier_address: string;
+    minter_address?: string;
+    chain_id: NumericValue;
+    deployed_block_number: NumericValue;
+    rpc_urls: string[];
+    legacy_tx: boolean;
+}
+export interface RawAggregationTreeState {
+    latestAggSeq: NumericValue;
+    aggregationRoot: string;
+    snapshot: string[];
+    transferTreeIndices: NumericValue[];
+    chainIds: NumericValue[];
+}
+export interface RawIndexedEvent {
+    event_index: NumericValue;
+    from: string;
+    to: string;
+    value: string;
+    eth_block_number: NumericValue;
+}
+export interface RawChainEvents {
+    chainId: NumericValue;
+    events: RawIndexedEvent[];
+}
+export interface RawEventsWithEligibility {
+    eligible: RawIndexedEvent[];
+    ineligible: RawIndexedEvent[];
+}
+export interface RawSeparatedChainEvents {
+    chainId: NumericValue;
+    events: RawEventsWithEligibility;
+}
+export interface RawLocalTeleportProof {
+    treeIndex: NumericValue;
+    event: RawIndexedEvent;
+    siblings: string[];
+}
+export interface RawChainLocalTeleportProofs {
+    chainId: NumericValue;
+    proofs: RawLocalTeleportProof[];
+}
+export interface RawGlobalTeleportProof {
+    event: RawIndexedEvent;
+    siblings: string[];
+    leafIndex: NumericValue;
+}
+export declare function asSecretAndTweak(value: unknown): SecretAndTweak;
+/**
+ * Convert an unknown WASM payload into {@link BurnArtifacts}.
+ * @throws If the payload shape is missing required fields.
+ */
+export declare function asBurnArtifacts(value: unknown): BurnArtifacts;
+export declare function copyRpcUrls(urls: readonly string[], label: string): string[];
+export declare function serializeHubEntry(entry: HubEntryConfig): RawHubEntry;
+/**
+ * Serialize a token entry for WASM/indexer boundary calls.
+ * @remarks `legacyTx` defaults to `false` when omitted.
+ */
+export declare function serializeTokenEntry(entry: TokenEntryConfig): RawTokenEntry;
+export declare function serializeAggregationTreeState(state: AggregationTreeState): RawAggregationTreeState;
+/**
+ * Serialize an indexed event for WASM/indexer boundary calls.
+ */
+export declare function serializeIndexedEvent(event: IndexedEvent): RawIndexedEvent;
+export declare function serializeChainEvents(entry: ChainEvents): RawChainEvents;
+export declare function serializeLocalTeleportProof(proof: LocalTeleportProof): RawLocalTeleportProof;
+export declare function serializeChainLocalTeleportProofs(entry: ChainLocalTeleportProofs): RawChainLocalTeleportProofs;
+export declare function deserializeAggregationTreeState(raw: RawAggregationTreeState): AggregationTreeState;
+export declare function deserializeIndexedEvent(raw: RawIndexedEvent): IndexedEvent;
+export declare function deserializeChainEvents(raw: RawChainEvents): ChainEvents;
+export declare function deserializeEventsWithEligibility(raw: RawEventsWithEligibility): EventsWithEligibility;
+export declare function deserializeSeparatedChainEvents(raw: RawSeparatedChainEvents): SeparatedChainEvents;
+export declare function deserializeLocalTeleportProof(raw: RawLocalTeleportProof): LocalTeleportProof;
+export declare function deserializeGlobalTeleportProof(raw: RawGlobalTeleportProof): GlobalTeleportProofWithEvent;
+//# sourceMappingURL=serialization.d.ts.map

package/dist/wasm/serialization.d.ts.map

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

package/dist/wasm/serialization.js

@@ -0,0 +1,188 @@
+/**
+ * Serialization and deserialization utilities for WASM interop.
+ * Handles conversion between SDK types (camelCase) and WASM boundary types.
+ * Note: WASM types use mixed naming conventions (snake_case for some fields, camelCase for others).
+ *
+ * @remarks
+ * Most helpers in this file validate that required fields exist and that hex strings are well-formed.
+ * These validations intentionally throw early to avoid passing malformed values into WASM.
+ */
+import { normalizeHex, toBigInt } from "../utils/hex.js";
+// ============================================================================
+// Conversion Helpers
+// ============================================================================
+export function asSecretAndTweak(value) {
+    const candidate = value;
+    if (!candidate || typeof candidate.secret !== "string" || typeof candidate.tweak !== "string") {
+        throw new Error("unexpected secret/tweak payload from wasm");
+    }
+    return {
+        secret: normalizeHex(candidate.secret),
+        tweak: normalizeHex(candidate.tweak),
+    };
+}
+/**
+ * Convert an unknown WASM payload into {@link BurnArtifacts}.
+ * @throws If the payload shape is missing required fields.
+ */
+export function asBurnArtifacts(value) {
+    const raw = value;
+    if (!raw || typeof raw.burnAddress !== "string" || typeof raw.secret !== "string") {
+        throw new Error("unexpected burn artifacts payload from wasm");
+    }
+    const recipient = raw.generalRecipient;
+    if (!recipient || typeof recipient.address !== "string") {
+        throw new Error("missing general recipient payload from wasm");
+    }
+    const tweakSource = raw.tweak ?? recipient.tweak;
+    if (typeof tweakSource !== "string") {
+        throw new Error("missing burn tweak payload from wasm");
+    }
+    return {
+        burnAddress: normalizeHex(raw.burnAddress),
+        fullBurnAddress: normalizeHex(raw.fullBurnAddress),
+        secret: normalizeHex(raw.secret),
+        tweak: normalizeHex(tweakSource),
+        generalRecipient: {
+            chainId: toBigInt(recipient.chainId ?? 0),
+            address: normalizeHex(recipient.address),
+            tweak: normalizeHex(recipient.tweak),
+            fr: normalizeHex(recipient.fr),
+            u256: normalizeHex(recipient.u256),
+        },
+    };
+}
+// ============================================================================
+// RPC URL Validation
+// ============================================================================
+export function copyRpcUrls(urls, label) {
+    if (!Array.isArray(urls) || urls.length === 0) {
+        throw new Error(`${label} must provide at least one RPC URL`);
+    }
+    return urls.map((url, idx) => {
+        if (typeof url !== "string" || url.trim().length === 0) {
+            throw new Error(`${label} RPC URL at index ${idx} must be a non-empty string`);
+        }
+        return url.trim();
+    });
+}
+// ============================================================================
+// Serialization (SDK → WASM)
+// ============================================================================
+export function serializeHubEntry(entry) {
+    return {
+        hub_address: normalizeHex(entry.hubAddress),
+        chain_id: entry.chainId,
+        rpc_urls: copyRpcUrls(entry.rpcUrls, "hub.rpcUrls"),
+    };
+}
+/**
+ * Serialize a token entry for WASM/indexer boundary calls.
+ * @remarks `legacyTx` defaults to `false` when omitted.
+ */
+export function serializeTokenEntry(entry) {
+    return {
+        label: entry.label,
+        token_address: normalizeHex(entry.tokenAddress),
+        verifier_address: normalizeHex(entry.verifierAddress),
+        minter_address: entry.minterAddress ? normalizeHex(entry.minterAddress) : undefined,
+        chain_id: entry.chainId,
+        deployed_block_number: entry.deployedBlockNumber,
+        rpc_urls: copyRpcUrls(entry.rpcUrls, `${entry.label}.rpcUrls`),
+        legacy_tx: entry.legacyTx ?? false,
+    };
+}
+export function serializeAggregationTreeState(state) {
+    return {
+        latestAggSeq: state.latestAggSeq,
+        aggregationRoot: normalizeHex(state.aggregationRoot),
+        snapshot: state.snapshot.map((value) => normalizeHex(value)),
+        transferTreeIndices: state.transferTreeIndices.map((value) => value),
+        chainIds: state.chainIds.map((value) => value),
+    };
+}
+/**
+ * Serialize an indexed event for WASM/indexer boundary calls.
+ */
+export function serializeIndexedEvent(event) {
+    return {
+        event_index: event.eventIndex,
+        from: normalizeHex(event.from),
+        to: normalizeHex(event.to),
+        value: normalizeHex(event.value),
+        eth_block_number: event.ethBlockNumber,
+    };
+}
+export function serializeChainEvents(entry) {
+    return {
+        chainId: entry.chainId,
+        events: entry.events.map(serializeIndexedEvent),
+    };
+}
+export function serializeLocalTeleportProof(proof) {
+    return {
+        treeIndex: proof.treeIndex,
+        event: serializeIndexedEvent(proof.event),
+        siblings: proof.siblings.map((value) => normalizeHex(value)),
+    };
+}
+export function serializeChainLocalTeleportProofs(entry) {
+    return {
+        chainId: entry.chainId,
+        proofs: entry.proofs.map(serializeLocalTeleportProof),
+    };
+}
+// ============================================================================
+// Deserialization (WASM → SDK)
+// ============================================================================
+export function deserializeAggregationTreeState(raw) {
+    return {
+        latestAggSeq: toBigInt(raw.latestAggSeq),
+        aggregationRoot: normalizeHex(raw.aggregationRoot),
+        snapshot: raw.snapshot.map((value) => normalizeHex(value)),
+        transferTreeIndices: raw.transferTreeIndices.map((value) => toBigInt(value)),
+        chainIds: raw.chainIds.map((value) => toBigInt(value)),
+    };
+}
+export function deserializeIndexedEvent(raw) {
+    return {
+        eventIndex: toBigInt(raw.event_index),
+        from: normalizeHex(raw.from),
+        to: normalizeHex(raw.to),
+        value: toBigInt(raw.value),
+        ethBlockNumber: toBigInt(raw.eth_block_number),
+    };
+}
+export function deserializeChainEvents(raw) {
+    return {
+        chainId: toBigInt(raw.chainId),
+        events: raw.events.map(deserializeIndexedEvent),
+    };
+}
+export function deserializeEventsWithEligibility(raw) {
+    return {
+        eligible: raw.eligible.map(deserializeIndexedEvent),
+        ineligible: raw.ineligible.map(deserializeIndexedEvent),
+    };
+}
+export function deserializeSeparatedChainEvents(raw) {
+    return {
+        chainId: toBigInt(raw.chainId),
+        events: deserializeEventsWithEligibility(raw.events),
+    };
+}
+export function deserializeLocalTeleportProof(raw) {
+    return {
+        treeIndex: toBigInt(raw.treeIndex),
+        event: deserializeIndexedEvent(raw.event),
+        siblings: raw.siblings.map((value) => normalizeHex(value)),
+    };
+}
+export function deserializeGlobalTeleportProof(raw) {
+    return {
+        event: deserializeIndexedEvent(raw.event),
+        siblings: raw.siblings.map((value) => normalizeHex(value)),
+        leafIndex: toBigInt(raw.leafIndex),
+    };
+}
+//# sourceMappingURL=serialization.js.map

package/dist/wasm/serialization.js.map

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

package/dist/wasm/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Global object interface for resolving WASM URLs.
+ */
+export interface WasmLocatorGlobal {
+    location?: {
+        origin?: string;
+    };
+}
+/**
+ * Configuration options for WasmRuntime.
+ * @remarks
+ * URL resolution order is:
+ * 1) `url` (explicit override)
+ * 2) `baseUrl` + `wasmFilename` (defaults to `assets/wasm/web/zerc20_wasm_bg.wasm`)
+ * 3) bundled fallback URL (package-relative)
+ *
+ * If `baseUrl` is relative (not `http(s)://`), the runtime needs `location.origin` from the configured
+ * `globalObject` (defaults to `globalThis`) to construct an absolute URL.
+ */
+export interface WasmRuntimeOptions {
+    /** Direct URL to the wasm bundle (takes precedence over other resolution). */
+    url?: string;
+    /** Base URL used to resolve the wasm file. */
+    baseUrl?: string;
+    /** Override filename when using a custom base. */
+    wasmFilename?: string;
+    /** Custom global object used when resolving relative base URLs (defaults to globalThis). */
+    globalObject?: WasmLocatorGlobal;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/wasm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/wasm/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE;QACT,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4FAA4F;IAC5F,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC"}

package/dist/wasm/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/wasm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/wasm/types.ts"],"names":[],"mappings":""}

package/dist/zkp/__tests__/proofService.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=proofService.test.d.ts.map

package/dist/zkp/__tests__/proofService.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proofService.test.d.ts","sourceRoot":"","sources":["../../../src/zkp/__tests__/proofService.test.ts"],"names":[],"mappings":""}

package/dist/zkp/__tests__/proofService.test.js

@@ -0,0 +1,283 @@
+import { afterAll, afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { ProofService } from "../proofService.js";
+// Suppress console output during tests
+const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+// Mock dependencies
+vi.mock("../workerClient.js", () => ({
+    canUseZkpWorker: vi.fn(),
+    disableZkpWorker: vi.fn(),
+    runZkpWorkerJob: vi.fn(),
+}));
+vi.mock("../../wasm/artifacts.js", () => ({
+    loadSingleTeleportArtifacts: vi.fn(),
+    loadBatchTeleportArtifacts: vi.fn(),
+}));
+vi.mock("../../utils/merkle.js", () => ({
+    verifyGlobalTeleportProofs: vi.fn(),
+}));
+import { canUseZkpWorker, disableZkpWorker, runZkpWorkerJob } from "../workerClient.js";
+import { loadSingleTeleportArtifacts, loadBatchTeleportArtifacts } from "../../wasm/artifacts.js";
+import { verifyGlobalTeleportProofs } from "../../utils/merkle.js";
+const mockCanUseZkpWorker = vi.mocked(canUseZkpWorker);
+const mockDisableZkpWorker = vi.mocked(disableZkpWorker);
+const mockRunZkpWorkerJob = vi.mocked(runZkpWorkerJob);
+const mockLoadSingleTeleportArtifacts = vi.mocked(loadSingleTeleportArtifacts);
+const mockLoadBatchTeleportArtifacts = vi.mocked(loadBatchTeleportArtifacts);
+const mockVerifyGlobalTeleportProofs = vi.mocked(verifyGlobalTeleportProofs);
+describe("ProofService", () => {
+    const mockSingleWithdrawProgram = {
+        prove: vi.fn(),
+    };
+    const mockNovaProgram = {
+        prove: vi.fn(),
+    };
+    const mockWasmRuntime = {
+        createSingleWithdrawProgram: vi.fn().mockResolvedValue(mockSingleWithdrawProgram),
+        createWithdrawNovaProgram: vi.fn().mockResolvedValue(mockNovaProgram),
+    };
+    const singleTeleportParams = {
+        aggregationState: {
+            latestAggSeq: 1n,
+            aggregationRoot: "0x" + "00".repeat(32),
+            snapshot: [],
+            transferTreeIndices: [],
+            chainIds: [],
+        },
+        recipientFr: "0x" + "01".repeat(32),
+        secretHex: "0x" + "02".repeat(32),
+        event: {
+            from: "0x" + "03".repeat(20),
+            to: "0x" + "05".repeat(20),
+            value: 1000n,
+            eventIndex: 0n,
+            ethBlockNumber: 12345n,
+        },
+        proof: {
+            leafIndex: 5n,
+            siblings: ["0x" + "04".repeat(32)],
+        },
+    };
+    const novaProverParams = {
+        aggregationState: {
+            latestAggSeq: 1n,
+            aggregationRoot: "0x" + "00".repeat(32),
+            snapshot: [],
+            transferTreeIndices: [],
+            chainIds: [],
+        },
+        recipientFr: "0x" + "01".repeat(32),
+        secretHex: "0x" + "02".repeat(32),
+        events: [
+            {
+                from: "0x" + "03".repeat(20),
+                to: "0x" + "05".repeat(20),
+                value: 1000n,
+                eventIndex: 0n,
+                ethBlockNumber: 12345n,
+            },
+        ],
+        proofs: [
+            {
+                leafIndex: 5n,
+                siblings: ["0x" + "04".repeat(32)],
+            },
+        ],
+    };
+    const mockSingleArtifacts = {
+        localPk: new Uint8Array([1, 2, 3]),
+        localVk: new Uint8Array([4, 5, 6]),
+        globalPk: new Uint8Array([7, 8, 9]),
+        globalVk: new Uint8Array([10, 11, 12]),
+    };
+    const mockBatchArtifacts = {
+        localPp: new Uint8Array([1, 2, 3]),
+        localVp: new Uint8Array([4, 5, 6]),
+        globalPp: new Uint8Array([7, 8, 9]),
+        globalVp: new Uint8Array([10, 11, 12]),
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockLoadSingleTeleportArtifacts.mockResolvedValue(mockSingleArtifacts);
+        mockLoadBatchTeleportArtifacts.mockResolvedValue(mockBatchArtifacts);
+    });
+    afterEach(() => {
+        consoleWarnSpy.mockClear();
+        consoleErrorSpy.mockClear();
+    });
+    afterAll(() => {
+        consoleWarnSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+    });
+    describe("createSingleTeleportProof", () => {
+        test("uses worker when available", async () => {
+            mockCanUseZkpWorker.mockReturnValue(true);
+            const expectedResult = {
+                proofCalldata: "0xproof",
+                publicInputs: ["0xinput1"],
+                treeDepth: 20,
+            };
+            mockRunZkpWorkerJob.mockResolvedValue(expectedResult);
+            const service = new ProofService(mockWasmRuntime);
+            const result = await service.createSingleTeleportProof(singleTeleportParams);
+            expect(result).toEqual(expectedResult);
+            expect(mockRunZkpWorkerJob).toHaveBeenCalledWith("singleTeleport", {
+                params: singleTeleportParams,
+                artifacts: mockSingleArtifacts,
+            });
+            expect(mockWasmRuntime.createSingleWithdrawProgram).not.toHaveBeenCalled();
+        });
+        test("falls back to main thread when worker fails", async () => {
+            mockCanUseZkpWorker.mockReturnValue(true);
+            mockRunZkpWorkerJob.mockRejectedValue(new Error("Worker error"));
+            mockSingleWithdrawProgram.prove.mockResolvedValue({
+                proofCalldata: "0xaabbccdd",
+                publicInputs: ["0x1122"],
+                treeDepth: 20,
+            });
+            const service = new ProofService(mockWasmRuntime);
+            const result = await service.createSingleTeleportProof(singleTeleportParams);
+            expect(result.proofCalldata).toBe("0xaabbccdd");
+            expect(mockDisableZkpWorker).toHaveBeenCalled();
+            expect(mockWasmRuntime.createSingleWithdrawProgram).toHaveBeenCalled();
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("Worker single proof failed"), expect.any(Error));
+        });
+        test("uses main thread directly when worker not available", async () => {
+            mockCanUseZkpWorker.mockReturnValue(false);
+            mockSingleWithdrawProgram.prove.mockResolvedValue({
+                proofCalldata: "0xaabbccdd",
+                publicInputs: ["0x1122"],
+                treeDepth: 20,
+            });
+            const service = new ProofService(mockWasmRuntime);
+            const result = await service.createSingleTeleportProof(singleTeleportParams);
+            expect(result.proofCalldata).toBe("0xaabbccdd");
+            expect(mockRunZkpWorkerJob).not.toHaveBeenCalled();
+        });
+        test("throws formatted error on proof failure", async () => {
+            mockCanUseZkpWorker.mockReturnValue(false);
+            mockSingleWithdrawProgram.prove.mockRejectedValue(new Error("Proof generation failed"));
+            const service = new ProofService(mockWasmRuntime);
+            await expect(service.createSingleTeleportProof(singleTeleportParams)).rejects.toThrow("single teleport proof failed: Proof generation failed");
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("createSingleTeleportProof failed"), expect.any(Object), expect.any(Error));
+        });
+        test("handles non-Error exceptions", async () => {
+            mockCanUseZkpWorker.mockReturnValue(false);
+            mockSingleWithdrawProgram.prove.mockRejectedValue("string error");
+            const service = new ProofService(mockWasmRuntime);
+            await expect(service.createSingleTeleportProof(singleTeleportParams)).rejects.toThrow("single teleport proof failed: string error");
+            expect(consoleErrorSpy).toHaveBeenCalled();
+        });
+    });
+    describe("runNovaProver", () => {
+        test("uses worker when available", async () => {
+            mockCanUseZkpWorker.mockReturnValue(true);
+            const expectedResult = {
+                ivcProof: new Uint8Array([1, 2, 3]),
+                finalState: ["0xstate1"],
+                steps: 2,
+            };
+            mockRunZkpWorkerJob.mockResolvedValue(expectedResult);
+            const service = new ProofService(mockWasmRuntime);
+            const result = await service.runNovaProver(novaProverParams);
+            expect(result).toEqual(expectedResult);
+            expect(mockRunZkpWorkerJob).toHaveBeenCalledWith("nova", {
+                params: novaProverParams,
+                artifacts: mockBatchArtifacts,
+            });
+        });
+        test("falls back to main thread when worker fails", async () => {
+            mockCanUseZkpWorker.mockReturnValue(true);
+            mockRunZkpWorkerJob.mockRejectedValue(new Error("Worker error"));
+            mockNovaProgram.prove.mockResolvedValue({
+                ivcProof: "0x010203",
+                finalState: ["0xstate1"],
+                steps: 2,
+            });
+            const service = new ProofService(mockWasmRuntime);
+            const result = await service.runNovaProver(novaProverParams);
+            expect(result.steps).toBe(2);
+            expect(mockDisableZkpWorker).toHaveBeenCalled();
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("Worker nova prover failed"), expect.any(Error));
+        });
+        test("throws when events and proofs length mismatch", async () => {
+            mockCanUseZkpWorker.mockReturnValue(false);
+            const invalidParams = {
+                ...novaProverParams,
+                events: [novaProverParams.events[0], novaProverParams.events[0]],
+                proofs: [novaProverParams.proofs[0]],
+            };
+            const service = new ProofService(mockWasmRuntime);
+            await expect(service.runNovaProver(invalidParams)).rejects.toThrow("events length must match proofs length for batch teleport");
+        });
+        test("verifies proofs before computing", async () => {
+            mockCanUseZkpWorker.mockReturnValue(false);
+            mockNovaProgram.prove.mockResolvedValue({
+                ivcProof: "0x010203",
+                finalState: ["0xstate1"],
+                steps: 1,
+            });
+            const service = new ProofService(mockWasmRuntime);
+            await service.runNovaProver(novaProverParams);
+            expect(mockVerifyGlobalTeleportProofs).toHaveBeenCalledWith({
+                aggregationRoot: novaProverParams.aggregationState.aggregationRoot,
+                events: novaProverParams.events,
+                proofs: novaProverParams.proofs,
+            });
+        });
+        test("sorts proofs by leaf index before computing", async () => {
+            mockCanUseZkpWorker.mockReturnValue(false);
+            const multiEventParams = {
+                ...novaProverParams,
+                events: [
+                    { ...novaProverParams.events[0], value: 2000n },
+                    { ...novaProverParams.events[0], value: 1000n },
+                ],
+                proofs: [
+                    { leafIndex: 10n, siblings: [] },
+                    { leafIndex: 5n, siblings: [] },
+                ],
+            };
+            mockNovaProgram.prove.mockResolvedValue({
+                ivcProof: "0x010203",
+                finalState: ["0xstate1"],
+                steps: 2,
+            });
+            const service = new ProofService(mockWasmRuntime);
+            await service.runNovaProver(multiEventParams);
+            // Verify proofs are sorted by leafIndex ascending (5n before 10n)
+            const verifyCall = mockVerifyGlobalTeleportProofs.mock.calls[0][0];
+            expect(verifyCall.proofs).toHaveLength(2);
+            expect(verifyCall.proofs[0].leafIndex).toBe(5n);
+            expect(verifyCall.proofs[1].leafIndex).toBe(10n);
+            // Verify events are reordered to match (value 1000n paired with leafIndex 5n)
+            expect(verifyCall.events[0].value).toBe(1000n);
+            expect(verifyCall.events[1].value).toBe(2000n);
+        });
+        test("throws formatted error on proof failure", async () => {
+            mockCanUseZkpWorker.mockReturnValue(false);
+            mockNovaProgram.prove.mockRejectedValue(new Error("Nova proof failed"));
+            const service = new ProofService(mockWasmRuntime);
+            await expect(service.runNovaProver(novaProverParams)).rejects.toThrow("batch teleport proof failed: Nova proof failed");
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("runNovaProver failed"), expect.any(Object), expect.any(Object), expect.any(Error));
+        });
+        test("handles empty events array (dummy steps only)", async () => {
+            mockCanUseZkpWorker.mockReturnValue(false);
+            const emptyParams = {
+                ...novaProverParams,
+                events: [],
+                proofs: [],
+            };
+            mockNovaProgram.prove.mockResolvedValue({
+                ivcProof: "0x010203",
+                finalState: ["0xstate1"],
+                steps: 1,
+            });
+            const service = new ProofService(mockWasmRuntime);
+            const result = await service.runNovaProver(emptyParams);
+            expect(result.steps).toBe(1);
+            expect(mockNovaProgram.prove).toHaveBeenCalled();
+        });
+    });
+});
+//# sourceMappingURL=proofService.test.js.map