dop-wallet-v6 1.3.39 → 1.3.41

package/dist/services/dop/crypto/react-native-prover.d.ts

@@ -0,0 +1,338 @@
+/**
+ * React Native Prover - Complete ZK Proof Solution
+ *
+ * This module provides a complete proof generation solution for React Native
+ * that works exactly like snarkjs in Node.js:
+ *
+ * Node.js snarkjs flow:
+ * 1. groth16.fullProve(inputs, wasmPath, zkeyPath)
+ * 2. Internally: Load WASM -> Create WitnessCalculator -> Calculate witness -> Generate proof
+ *
+ * React Native rapidsnark flow (this module):
+ * 1. setReactNativeProver(config) - Initialize with rapidsnark + file system
+ * 2. DOP Engine calls groth16.fullProveDop(inputs, wasm, zkey)
+ * 3. Internally: Calculate witness using WASM -> Save files -> Call rapidsnark -> Return proof
+ *
+ * Key components:
+ * - CircuitArtifactManager: Downloads and stores circuit files (WASM, zkey) locally
+ * - WitnessGenerator: Calculates witness from inputs using WASM (like circom_runtime)
+ * - RapidsnarkProver: Generates proof using witness and zkey
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+import { FormattedCircuitInputsDop, Proof } from 'dop-engine-v3';
+/**
+ * Result from rapidsnark groth16Prove
+ */
+export interface RNRapidsnarkProofResult {
+    proof: {
+        a: string[];
+        b: string[][];
+        c: string[];
+    };
+    pub_signals: string[];
+}
+/**
+ * Rapidsnark's groth16Prove function signature
+ * From: import { groth16Prove } from 'react-native-rapidsnark'
+ */
+export type RNGroth16ProveFunction = (zkeyPath: string, witnessBase64: string) => Promise<RNRapidsnarkProofResult>;
+/**
+ * Rapidsnark's groth16ProveWithZKeyFilePath for file-based proving
+ * Some versions of rapidsnark support this
+ */
+export type RNGroth16ProveWithFilesFunction = (zkeyPath: string, witnessPath: string) => Promise<RNRapidsnarkProofResult>;
+/**
+ * File system interface for React Native
+ * Implement using react-native-fs or expo-file-system
+ */
+export interface RNFileSystem {
+    writeFile(path: string, data: string, encoding: 'base64' | 'utf8'): Promise<void>;
+    readFile(path: string, encoding: 'base64' | 'utf8'): Promise<string>;
+    exists(path: string): Promise<boolean>;
+    unlink(path: string): Promise<void>;
+    mkdir(path: string): Promise<void>;
+    documentDirectory: string;
+    cacheDirectory: string;
+}
+/**
+ * Witness calculation result
+ */
+export interface WitnessResult {
+    witnessBin: Uint8Array;
+    witnessBase64: string;
+}
+/**
+ * Rapidsnark's groth16Verify function signature
+ * From: import { groth16Verify } from 'react-native-rapidsnark'
+ */
+export type RNGroth16VerifyFunction = (proof: string, inputs: string, verificationKey: string) => Promise<boolean>;
+/**
+ * Circuit artifacts stored on device
+ */
+export interface StoredCircuitArtifacts {
+    wasmPath: string;
+    zkeyPath: string;
+    vkeyPath: string;
+    circuitId: string;
+}
+/**
+ * Configuration for React Native Prover
+ */
+export interface ReactNativeProverConfig {
+    /**
+     * Rapidsnark's groth16Prove function
+     * Import: import { groth16Prove } from 'react-native-rapidsnark'
+     */
+    groth16Prove: RNGroth16ProveFunction;
+    /**
+     * Optional: Rapidsnark's groth16Verify function for local proof verification
+     * Import: import { groth16Verify } from 'react-native-rapidsnark'
+     * If not provided, verification will throw an error
+     */
+    groth16Verify?: RNGroth16VerifyFunction;
+    /**
+     * File system interface (react-native-fs or expo-file-system)
+     */
+    fs: RNFileSystem;
+    /**
+     * Optional: Custom artifact storage directory
+     * Default: fs.documentDirectory + '/dop-circuits'
+     */
+    artifactDir?: string;
+    /**
+     * Optional: Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Optional: Custom witness calculator
+     * If not provided, will use the built-in WASM-based calculator
+     */
+    witnessCalculator?: (wasmBuffer: Uint8Array, inputs: FormattedCircuitInputsDop) => Promise<Uint8Array>;
+}
+/**
+ * Convert Uint8Array to base64 string (React Native compatible)
+ */
+export declare function uint8ArrayToBase64(data: Uint8Array): string;
+/**
+ * Convert base64 string to Uint8Array (React Native compatible)
+ */
+export declare function base64ToUint8Array(base64: string): Uint8Array;
+/**
+ * Calculate witness using WASM
+ * This is the core function that mimics circom_runtime's WitnessCalculator
+ *
+ * For React Native, the WASM execution needs special handling.
+ * This function provides the interface - the actual WASM execution
+ * should be done by a native module or WebAssembly polyfill.
+ */
+export declare function calculateWitnessFromWASM(wasmBuffer: Uint8Array, inputs: FormattedCircuitInputsDop, wasmExecutor?: (wasm: Uint8Array, inputs: Record<string, unknown>) => Promise<bigint[]>): Promise<WitnessResult>;
+/**
+ * Manages circuit artifacts (WASM, zkey, vkey) on the device
+ */
+export declare class CircuitArtifactManager {
+    private fs;
+    private artifactDir;
+    private debug;
+    constructor(fs: RNFileSystem, artifactDir?: string, debug?: boolean);
+    private log;
+    /**
+     * Ensure artifact directory exists
+     */
+    ensureDir(dir: string): Promise<void>;
+    /**
+     * Get paths for circuit artifacts
+     */
+    getArtifactPaths(circuitId: string): StoredCircuitArtifacts;
+    /**
+     * Check if circuit artifacts are already stored
+     */
+    hasArtifacts(circuitId: string): Promise<boolean>;
+    /**
+     * Store circuit artifacts from buffers
+     * Call this after downloading artifacts
+     */
+    storeArtifacts(circuitId: string, wasmBuffer: Uint8Array, zkeyBuffer: Uint8Array, vkeyJson?: object): Promise<StoredCircuitArtifacts>;
+    /**
+     * Store artifacts from the DOP Engine's artifact getter
+     * This is called during proof generation when we receive buffers from the engine
+     */
+    storeArtifactsFromBuffers(circuitId: string, wasmOrDat: Uint8Array | ArrayLike<number>, zkey: ArrayLike<number>): Promise<StoredCircuitArtifacts>;
+    /**
+     * Load WASM buffer from stored file
+     */
+    loadWASM(circuitId: string): Promise<Uint8Array>;
+    /**
+     * Get zkey path for rapidsnark
+     */
+    getZkeyPath(circuitId: string): string;
+    /**
+     * Clean up artifacts for a circuit
+     */
+    removeArtifacts(circuitId: string): Promise<void>;
+    /**
+     * Get all stored circuit IDs
+     */
+    getArtifactDirectory(): string;
+}
+/**
+ * React Native Prover Instance
+ * Manages the complete proof generation flow
+ */
+declare class ReactNativeProverInstance {
+    private config;
+    private artifactManager;
+    private initialized;
+    constructor(config: ReactNativeProverConfig);
+    private log;
+    /**
+     * Initialize the prover (ensure directories exist)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Generate proof using rapidsnark
+     * This is the main function that mimics snarkjs.groth16.fullProve
+     */
+    generateProof(inputs: FormattedCircuitInputsDop, wasmBuffer: Uint8Array | ArrayLike<number>, zkeyBuffer: ArrayLike<number>, logger: {
+        debug: (log: string) => void;
+    }, progressCallback?: (progress: number) => void): Promise<{
+        proof: Proof;
+        publicSignals: string[];
+    }>;
+    /**
+     * Get the artifact manager for manual artifact management
+     */
+    getArtifactManager(): CircuitArtifactManager;
+}
+/**
+ * Set up React Native prover for DOP Engine
+ *
+ * This function configures the DOP Engine to use rapidsnark for proof generation
+ * on React Native. It works exactly like setSnarkJSGroth16 but uses rapidsnark
+ * under the hood.
+ *
+ * @example
+ * ```typescript
+ * import { groth16Prove } from 'react-native-rapidsnark';
+ * import RNFS from 'react-native-fs';
+ * import { setReactNativeProver } from 'new-dop-wallet-v3';
+ *
+ * // Create file system interface for react-native-fs
+ * const fs: RNFileSystem = {
+ *   writeFile: (path, data, encoding) => RNFS.writeFile(path, data, encoding),
+ *   readFile: (path, encoding) => RNFS.readFile(path, encoding),
+ *   exists: RNFS.exists,
+ *   unlink: RNFS.unlink,
+ *   mkdir: RNFS.mkdir,
+ *   documentDirectory: RNFS.DocumentDirectoryPath,
+ *   cacheDirectory: RNFS.CachesDirectoryPath,
+ * };
+ *
+ * // Initialize React Native prover (call after initDOP)
+ * await setReactNativeProver({
+ *   groth16Prove,
+ *   fs,
+ *   debug: true,
+ * });
+ *
+ * // Now all DOP SDK transactions will use rapidsnark automatically!
+ * ```
+ */
+export declare function setReactNativeProver(config: ReactNativeProverConfig): Promise<void>;
+/**
+ * Get the global React Native prover instance
+ * Useful for accessing the artifact manager directly
+ */
+export declare function getReactNativeProver(): ReactNativeProverInstance | null;
+/**
+ * Create RNFileSystem from react-native-fs (RNFS)
+ *
+ * @example
+ * ```typescript
+ * import RNFS from 'react-native-fs';
+ * const fs = createRNFSInterface(RNFS);
+ * ```
+ */
+export declare function createRNFSInterface(RNFS: {
+    writeFile: (path: string, content: string, encoding: string) => Promise<void>;
+    readFile: (path: string, encoding: string) => Promise<string>;
+    exists: (path: string) => Promise<boolean>;
+    unlink: (path: string) => Promise<void>;
+    mkdir: (path: string, options?: object) => Promise<void>;
+    DocumentDirectoryPath: string;
+    CachesDirectoryPath: string;
+}): RNFileSystem;
+/**
+ * Create RNFileSystem from expo-file-system
+ *
+ * @example
+ * ```typescript
+ * import * as FileSystem from 'expo-file-system';
+ * const fs = createExpoFSInterface(FileSystem);
+ * ```
+ */
+export declare function createExpoFSInterface(ExpoFS: {
+    writeAsStringAsync: (path: string, content: string, options?: {
+        encoding: string;
+    }) => Promise<void>;
+    readAsStringAsync: (path: string, options?: {
+        encoding: string;
+    }) => Promise<string>;
+    getInfoAsync: (path: string) => Promise<{
+        exists: boolean;
+    }>;
+    deleteAsync: (path: string, options?: {
+        idempotent: boolean;
+    }) => Promise<void>;
+    makeDirectoryAsync: (path: string, options?: {
+        intermediates: boolean;
+    }) => Promise<void>;
+    documentDirectory: string | null;
+    cacheDirectory: string | null;
+}): RNFileSystem;
+/**
+ * ArtifactStore type matching the SDK's artifact-store.ts
+ */
+export interface RNArtifactStore {
+    get: (path: string) => Promise<string | Buffer | null>;
+    store: (dir: string, path: string, item: string | Uint8Array) => Promise<void>;
+    exists: (path: string) => Promise<boolean>;
+}
+/**
+ * Create an ArtifactStore for React Native that stores files to device storage
+ *
+ * This allows the SDK's ArtifactDownloader to automatically save artifacts
+ * to a location that rapidsnark can access by file path.
+ *
+ * Use this when initializing the DOP Engine to make artifacts available for rapidsnark.
+ *
+ * @example
+ * ```typescript
+ * import RNFS from 'react-native-fs';
+ * import { createRNArtifactStore, createRNFSInterface } from 'new-dop-wallet-v3';
+ *
+ * const fs = createRNFSInterface(RNFS);
+ * const artifactStore = createRNArtifactStore(fs);
+ *
+ * // Pass to ArtifactDownloader when initializing DOP Engine
+ * const artifactDownloader = new ArtifactDownloader(artifactStore, false);
+ * ```
+ */
+export declare function createRNArtifactStore(fs: RNFileSystem, baseDir?: string): RNArtifactStore;
+/**
+ * Get the full file path for an artifact stored via RNArtifactStore
+ *
+ * Use this to get the path for rapidsnark's groth16Prove function
+ *
+ * @example
+ * ```typescript
+ * const zkeyPath = getRNArtifactPath(fs, '3x2', 'zkey');
+ * const proofResult = await groth16Prove(zkeyPath, witnessBase64);
+ * ```
+ */
+export declare function getRNArtifactPath(fs: RNFileSystem, circuitId: string, artifactType: 'zkey' | 'wasm' | 'vkey' | 'dat', baseDir?: string): string;
+/**
+ * Check if all artifacts for a circuit are downloaded
+ */
+export declare function hasRNArtifacts(fs: RNFileSystem, circuitId: string, baseDir?: string, useNativeArtifacts?: boolean): Promise<boolean>;
+export {};