dop-wallet-v6 1.3.39 → 1.3.41

package/dist/services/dop/crypto/react-native-prover.js

@@ -0,0 +1,814 @@
+"use strict";
+/* eslint-disable no-bitwise */
+/* eslint-disable no-plusplus */
+/* eslint-disable max-classes-per-file */
+/* eslint-disable camelcase */
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable @typescript-eslint/strict-boolean-expressions */
+/**
+ * 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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRNArtifacts = exports.getRNArtifactPath = exports.createRNArtifactStore = exports.createExpoFSInterface = exports.createRNFSInterface = exports.getReactNativeProver = exports.setReactNativeProver = exports.CircuitArtifactManager = exports.calculateWitnessFromWASM = exports.base64ToUint8Array = exports.uint8ArrayToBase64 = void 0;
+const engine_1 = require("../core/engine");
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Convert Uint8Array to base64 string (React Native compatible)
+ */
+function uint8ArrayToBase64(data) {
+    // Use Buffer if available (Node.js/React Native with buffer polyfill)
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(data).toString('base64');
+    }
+    // Fallback for pure JS environments
+    let binary = '';
+    const len = data.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(data[i]);
+    }
+    return btoa(binary);
+}
+exports.uint8ArrayToBase64 = uint8ArrayToBase64;
+/**
+ * Convert base64 string to Uint8Array (React Native compatible)
+ */
+function base64ToUint8Array(base64) {
+    // Use Buffer if available
+    if (typeof Buffer !== 'undefined') {
+        return new Uint8Array(Buffer.from(base64, 'base64'));
+    }
+    // Fallback for pure JS environments
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+exports.base64ToUint8Array = base64ToUint8Array;
+/**
+ * Get circuit ID from formatted inputs
+ * DOP circuits are named like "3x2" (3 nullifiers, 2 commitments)
+ */
+function getCircuitIdFromInputs(inputs) {
+    const nullifierCount = inputs.nullifiers?.filter((n) => n !== undefined && n !== null && BigInt(n) !== BigInt(0)).length || 0;
+    const commitmentCount = inputs.commitmentsOut?.filter((c) => c !== undefined && c !== null && BigInt(c) !== BigInt(0)).length || 0;
+    return `${nullifierCount}x${commitmentCount}`;
+}
+// ============================================================================
+// Witness Calculator (WASM-based, like circom_runtime)
+// ============================================================================
+/**
+ * The BN128 prime field used in Groth16
+ */
+const BN128_PRIME = BigInt('21888242871839275222246405745257275088548364400416034343698204186575808495617');
+/**
+ * FNV-1a hash function for signal names (same as circom_runtime)
+ */
+function fnvHash(str) {
+    const FNV_OFFSET = BigInt('0xCBF29CE484222325');
+    const FNV_PRIME = BigInt('0x100000001B3');
+    let hash = FNV_OFFSET;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= BigInt(str.charCodeAt(i));
+        hash = (hash * FNV_PRIME) % (BigInt(1) << BigInt(64));
+    }
+    return hash;
+}
+/**
+ * Convert bigint to 32-bit array (little-endian, like circom_runtime)
+ */
+function toArray32(num, size) {
+    const result = new Uint32Array(size);
+    let temp = num;
+    for (let i = 0; i < size; i++) {
+        result[i] = Number(temp & BigInt(0xFFFFFFFF));
+        temp >>= BigInt(32);
+    }
+    return result;
+}
+/**
+ * Normalize value to prime field (like circom_runtime)
+ */
+function normalizeToField(value) {
+    let num;
+    if (typeof value === 'bigint') {
+        num = value;
+    }
+    else if (typeof value === 'string') {
+        // Handle hex strings
+        if (value.startsWith('0x')) {
+            num = BigInt(value);
+        }
+        else {
+            num = BigInt(value);
+        }
+    }
+    else {
+        num = BigInt(value);
+    }
+    // Normalize to prime field
+    num %= BN128_PRIME;
+    if (num < BigInt(0)) {
+        num += BN128_PRIME;
+    }
+    return num;
+}
+/**
+ * Flatten nested arrays (like circom_runtime)
+ */
+function flatArray(arr) {
+    const result = [];
+    function flatten(item) {
+        if (Array.isArray(item)) {
+            for (const subItem of item) {
+                flatten(subItem);
+            }
+        }
+        else if (typeof item === 'bigint' || typeof item === 'string' || typeof item === 'number') {
+            result.push(normalizeToField(item));
+        }
+    }
+    flatten(arr);
+    return result;
+}
+/**
+ * Create WTNS (witness) binary format
+ * This matches the format expected by rapidsnark
+ *
+ * WTNS format:
+ * - 4 bytes: "wtns" magic
+ * - 4 bytes: version (2)
+ * - 4 bytes: number of sections
+ * - Section 1 (header): field info
+ * - Section 2 (data): witness values
+ */
+function createWTNSBin(witness) {
+    const n8 = 32; // 32 bytes per field element (256 bits)
+    const witnessSize = witness.length;
+    // Calculate total size
+    // Header: magic(4) + version(4) + numSections(4) = 12
+    // Section 1 header: sectionType(4) + sectionSize(8) = 12
+    // Section 1 data: n8(4) + prime(n8) + witnessSize(4) = 4 + 32 + 4 = 40
+    // Section 2 header: sectionType(4) + sectionSize(8) = 12
+    // Section 2 data: witness values = witnessSize * n8
+    const section1Size = 4 + n8 + 4; // n8 size + prime + witness count
+    const section2Size = witnessSize * n8;
+    const totalSize = 12 + 12 + section1Size + 12 + section2Size;
+    const buffer = new ArrayBuffer(totalSize);
+    const view = new DataView(buffer);
+    const uint8 = new Uint8Array(buffer);
+    let offset = 0;
+    // Magic "wtns"
+    uint8[offset++] = 0x77; // 'w'
+    uint8[offset++] = 0x74; // 't'
+    uint8[offset++] = 0x6e; // 'n'
+    uint8[offset++] = 0x73; // 's'
+    // Version (2)
+    view.setUint32(offset, 2, true);
+    offset += 4;
+    // Number of sections (2)
+    view.setUint32(offset, 2, true);
+    offset += 4;
+    // Section 1: Header
+    view.setUint32(offset, 1, true); // section type
+    offset += 4;
+    // Section size as 64-bit
+    view.setUint32(offset, section1Size, true);
+    offset += 4;
+    view.setUint32(offset, 0, true);
+    offset += 4;
+    // n8 (field element size in bytes)
+    view.setUint32(offset, n8, true);
+    offset += 4;
+    // Prime (BN128 prime, little-endian)
+    const primeArray = toArray32(BN128_PRIME, 8);
+    for (let i = 0; i < 8; i++) {
+        view.setUint32(offset, primeArray[i], true);
+        offset += 4;
+    }
+    // Witness size
+    view.setUint32(offset, witnessSize, true);
+    offset += 4;
+    // Section 2: Data (witness values)
+    view.setUint32(offset, 2, true); // section type
+    offset += 4;
+    // Section size as 64-bit
+    view.setUint32(offset, section2Size, true);
+    offset += 4;
+    view.setUint32(offset, 0, true);
+    offset += 4;
+    // Write witness values (each as 32-byte little-endian)
+    for (const w of witness) {
+        const wArray = toArray32(w, 8);
+        for (let i = 0; i < 8; i++) {
+            view.setUint32(offset, wArray[i], true);
+            offset += 4;
+        }
+    }
+    return uint8;
+}
+/**
+ * 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.
+ */
+async function calculateWitnessFromWASM(wasmBuffer, inputs, wasmExecutor) {
+    let witness;
+    if (wasmExecutor) {
+        // Use provided WASM executor
+        witness = await wasmExecutor(wasmBuffer, inputs);
+    }
+    else {
+        // Try to use circom_runtime if available
+        try {
+            const circomRuntime = await Promise.resolve().then(() => __importStar(require('circom_runtime')));
+            const witnessCalculator = await circomRuntime.WitnessCalculatorBuilder(wasmBuffer);
+            const witnessBin = await witnessCalculator.calculateWTNSBin(inputs);
+            // Return directly as it's already in WTNS format
+            return {
+                witnessBin: new Uint8Array(witnessBin),
+                witnessBase64: uint8ArrayToBase64(new Uint8Array(witnessBin)),
+            };
+        }
+        catch {
+            throw new Error('WASM execution not available. Please provide a wasmExecutor or ensure circom_runtime is available.');
+        }
+    }
+    // Create WTNS binary from witness array
+    const witnessBin = createWTNSBin(witness);
+    return {
+        witnessBin,
+        witnessBase64: uint8ArrayToBase64(witnessBin),
+    };
+}
+exports.calculateWitnessFromWASM = calculateWitnessFromWASM;
+// ============================================================================
+// Circuit Artifact Manager
+// ============================================================================
+/**
+ * Manages circuit artifacts (WASM, zkey, vkey) on the device
+ */
+class CircuitArtifactManager {
+    fs;
+    artifactDir;
+    debug;
+    constructor(fs, artifactDir, debug = false) {
+        this.fs = fs;
+        this.artifactDir = artifactDir || `${fs.documentDirectory}/dop-circuits`;
+        this.debug = debug;
+    }
+    log(message) {
+        if (this.debug) {
+            console.log(`[CircuitArtifactManager] ${message}`);
+        }
+    }
+    /**
+     * Ensure artifact directory exists
+     */
+    async ensureDir(dir) {
+        try {
+            if (!(await this.fs.exists(dir))) {
+                await this.fs.mkdir(dir);
+                this.log(`Created directory: ${dir}`);
+            }
+        }
+        catch {
+            // Directory might already exist
+        }
+    }
+    /**
+     * Get paths for circuit artifacts
+     */
+    getArtifactPaths(circuitId) {
+        const circuitDir = `${this.artifactDir}/${circuitId}`;
+        return {
+            wasmPath: `${circuitDir}/circuit.wasm`,
+            zkeyPath: `${circuitDir}/circuit.zkey`,
+            vkeyPath: `${circuitDir}/vkey.json`,
+            circuitId,
+        };
+    }
+    /**
+     * Check if circuit artifacts are already stored
+     */
+    async hasArtifacts(circuitId) {
+        const paths = this.getArtifactPaths(circuitId);
+        const [hasWasm, hasZkey] = await Promise.all([
+            this.fs.exists(paths.wasmPath),
+            this.fs.exists(paths.zkeyPath),
+        ]);
+        return hasWasm && hasZkey;
+    }
+    /**
+     * Store circuit artifacts from buffers
+     * Call this after downloading artifacts
+     */
+    async storeArtifacts(circuitId, wasmBuffer, zkeyBuffer, vkeyJson) {
+        const paths = this.getArtifactPaths(circuitId);
+        const circuitDir = `${this.artifactDir}/${circuitId}`;
+        await this.ensureDir(this.artifactDir);
+        await this.ensureDir(circuitDir);
+        this.log(`Storing artifacts for circuit ${circuitId}`);
+        // Store WASM
+        await this.fs.writeFile(paths.wasmPath, uint8ArrayToBase64(wasmBuffer), 'base64');
+        this.log(`Stored WASM: ${paths.wasmPath} (${wasmBuffer.byteLength} bytes)`);
+        // Store zkey
+        await this.fs.writeFile(paths.zkeyPath, uint8ArrayToBase64(zkeyBuffer), 'base64');
+        this.log(`Stored zkey: ${paths.zkeyPath} (${zkeyBuffer.byteLength} bytes)`);
+        // Store vkey if provided
+        if (vkeyJson) {
+            await this.fs.writeFile(paths.vkeyPath, JSON.stringify(vkeyJson), 'utf8');
+            this.log(`Stored vkey: ${paths.vkeyPath}`);
+        }
+        return paths;
+    }
+    /**
+     * Store artifacts from the DOP Engine's artifact getter
+     * This is called during proof generation when we receive buffers from the engine
+     */
+    async storeArtifactsFromBuffers(circuitId, wasmOrDat, zkey) {
+        const wasmBuffer = wasmOrDat instanceof Uint8Array
+            ? wasmOrDat
+            : new Uint8Array(wasmOrDat);
+        const zkeyBuffer = new Uint8Array(zkey);
+        return this.storeArtifacts(circuitId, wasmBuffer, zkeyBuffer);
+    }
+    /**
+     * Load WASM buffer from stored file
+     */
+    async loadWASM(circuitId) {
+        const paths = this.getArtifactPaths(circuitId);
+        const base64 = await this.fs.readFile(paths.wasmPath, 'base64');
+        return base64ToUint8Array(base64);
+    }
+    /**
+     * Get zkey path for rapidsnark
+     */
+    getZkeyPath(circuitId) {
+        return this.getArtifactPaths(circuitId).zkeyPath;
+    }
+    /**
+     * Clean up artifacts for a circuit
+     */
+    async removeArtifacts(circuitId) {
+        const paths = this.getArtifactPaths(circuitId);
+        try {
+            await this.fs.unlink(paths.wasmPath);
+        }
+        catch { /* ignore */ }
+        try {
+            await this.fs.unlink(paths.zkeyPath);
+        }
+        catch { /* ignore */ }
+        try {
+            await this.fs.unlink(paths.vkeyPath);
+        }
+        catch { /* ignore */ }
+        this.log(`Removed artifacts for circuit ${circuitId}`);
+    }
+    /**
+     * Get all stored circuit IDs
+     */
+    getArtifactDirectory() {
+        return this.artifactDir;
+    }
+}
+exports.CircuitArtifactManager = CircuitArtifactManager;
+// ============================================================================
+// React Native Prover
+// ============================================================================
+/**
+ * React Native Prover Instance
+ * Manages the complete proof generation flow
+ */
+class ReactNativeProverInstance {
+    config;
+    artifactManager;
+    initialized = false;
+    constructor(config) {
+        this.config = config;
+        this.artifactManager = new CircuitArtifactManager(config.fs, config.artifactDir, config.debug);
+    }
+    log(message) {
+        if (this.config.debug) {
+            console.log(`[ReactNativeProver] ${message}`);
+        }
+    }
+    /**
+     * Initialize the prover (ensure directories exist)
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.artifactManager.ensureDir(this.config.artifactDir || `${this.config.fs.documentDirectory}/dop-circuits`);
+        this.initialized = true;
+        this.log('Initialized');
+    }
+    /**
+     * Generate proof using rapidsnark
+     * This is the main function that mimics snarkjs.groth16.fullProve
+     */
+    async generateProof(inputs, wasmBuffer, zkeyBuffer, logger, progressCallback) {
+        await this.initialize();
+        const circuitId = getCircuitIdFromInputs(inputs);
+        this.log(`Generating proof for circuit ${circuitId}`);
+        progressCallback?.(5);
+        // Step 1: Store artifacts on device (if not already stored)
+        logger.debug(`[RN Prover] Step 1: Preparing artifacts for circuit ${circuitId}...`);
+        const wasm = wasmBuffer instanceof Uint8Array
+            ? wasmBuffer
+            : new Uint8Array(wasmBuffer);
+        const artifacts = await this.artifactManager.storeArtifactsFromBuffers(circuitId, wasm, zkeyBuffer);
+        this.log(`Artifacts stored at: ${artifacts.zkeyPath}`);
+        progressCallback?.(20);
+        // Step 2: Calculate witness from inputs
+        logger.debug('[RN Prover] Step 2: Calculating witness...');
+        let witnessResult;
+        if (this.config.witnessCalculator) {
+            // Use custom witness calculator
+            const witnessBin = await this.config.witnessCalculator(wasm, inputs);
+            witnessResult = {
+                witnessBin,
+                witnessBase64: uint8ArrayToBase64(witnessBin),
+            };
+        }
+        else {
+            // Use built-in WASM-based calculator
+            witnessResult = await calculateWitnessFromWASM(wasm, inputs);
+        }
+        this.log(`Witness calculated: ${witnessResult.witnessBin.byteLength} bytes`);
+        progressCallback?.(50);
+        // Step 3: Generate proof with rapidsnark
+        logger.debug('[RN Prover] Step 3: Generating proof with rapidsnark...');
+        const rapidsnarkResult = await this.config.groth16Prove(artifacts.zkeyPath, witnessResult.witnessBase64);
+        this.log('Proof generated successfully');
+        progressCallback?.(90);
+        // Step 4: Convert to DOP Engine format
+        const proof = {
+            pi_a: [rapidsnarkResult.proof.a[0], rapidsnarkResult.proof.a[1]],
+            pi_b: [
+                [rapidsnarkResult.proof.b[0][0], rapidsnarkResult.proof.b[0][1]],
+                [rapidsnarkResult.proof.b[1][0], rapidsnarkResult.proof.b[1][1]],
+            ],
+            pi_c: [rapidsnarkResult.proof.c[0], rapidsnarkResult.proof.c[1]],
+        };
+        progressCallback?.(100);
+        return {
+            proof,
+            publicSignals: rapidsnarkResult.pub_signals,
+        };
+    }
+    /**
+     * Get the artifact manager for manual artifact management
+     */
+    getArtifactManager() {
+        return this.artifactManager;
+    }
+}
+// ============================================================================
+// Main Export: setReactNativeProver
+// ============================================================================
+let globalReactNativeProver = null;
+/**
+ * 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!
+ * ```
+ */
+async function setReactNativeProver(config) {
+    const engine = (0, engine_1.getEngine)();
+    if (!engine) {
+        throw new Error('DOP Engine not initialized. Call initDOP() first.');
+    }
+    // Create prover instance
+    globalReactNativeProver = new ReactNativeProverInstance(config);
+    await globalReactNativeProver.initialize();
+    console.log('[RN Prover] Setting up React Native prover with rapidsnark');
+    // Create groth16 implementation
+    const reactNativeGroth16 = {
+        fullProve: async (inputs, wasm, zkey, logger) => {
+            if (!globalReactNativeProver) {
+                throw new Error('React Native prover not initialized');
+            }
+            if (!wasm) {
+                throw new Error('WASM buffer is required for proof generation');
+            }
+            return globalReactNativeProver.generateProof(inputs, wasm, zkey, logger, undefined);
+        },
+        /**
+         * Verify a proof using rapidsnark's groth16Verify
+         * This works like snarkjs.groth16.verify in Node.js
+         */
+        verify: async (vkey, publicSignals, proof) => {
+            // Check if groth16Verify was provided in config
+            if (!config.groth16Verify) {
+                console.warn('[RN Prover] groth16Verify not provided in config. Cannot verify proof locally.');
+                throw new Error('Proof verification requires groth16Verify function. ' +
+                    'Pass groth16Verify from react-native-rapidsnark in setReactNativeProver config.');
+            }
+            try {
+                // Convert proof to rapidsnark format
+                // rapidsnark expects: proof as JSON string, inputs as JSON string, vkey as JSON string
+                const rapidsnarkProof = {
+                    pi_a: proof.pi_a,
+                    pi_b: proof.pi_b,
+                    pi_c: proof.pi_c,
+                    protocol: 'groth16',
+                    curve: 'bn128',
+                };
+                const proofJson = JSON.stringify(rapidsnarkProof);
+                const inputsJson = JSON.stringify(publicSignals);
+                const vkeyJson = JSON.stringify(vkey);
+                const isValid = await config.groth16Verify(proofJson, inputsJson, vkeyJson);
+                console.log('[RN Prover] Proof verification result:', isValid);
+                return isValid;
+            }
+            catch (error) {
+                console.error('[RN Prover] Proof verification failed:', error);
+                throw error;
+            }
+        },
+    };
+    // Set on engine
+    engine.prover.setSnarkJSGroth16(reactNativeGroth16);
+    console.log('[RN Prover] React Native prover configured successfully');
+}
+exports.setReactNativeProver = setReactNativeProver;
+/**
+ * Get the global React Native prover instance
+ * Useful for accessing the artifact manager directly
+ */
+function getReactNativeProver() {
+    return globalReactNativeProver;
+}
+exports.getReactNativeProver = getReactNativeProver;
+// ============================================================================
+// Helper: Create file system interfaces
+// ============================================================================
+/**
+ * Create RNFileSystem from react-native-fs (RNFS)
+ *
+ * @example
+ * ```typescript
+ * import RNFS from 'react-native-fs';
+ * const fs = createRNFSInterface(RNFS);
+ * ```
+ */
+function createRNFSInterface(RNFS) {
+    return {
+        writeFile: (path, data, encoding) => RNFS.writeFile(path, data, encoding),
+        readFile: (path, encoding) => RNFS.readFile(path, encoding),
+        exists: RNFS.exists,
+        unlink: RNFS.unlink,
+        mkdir: (path) => RNFS.mkdir(path, { NSURLIsExcludedFromBackupKey: true }),
+        documentDirectory: RNFS.DocumentDirectoryPath,
+        cacheDirectory: RNFS.CachesDirectoryPath,
+    };
+}
+exports.createRNFSInterface = createRNFSInterface;
+/**
+ * Create RNFileSystem from expo-file-system
+ *
+ * @example
+ * ```typescript
+ * import * as FileSystem from 'expo-file-system';
+ * const fs = createExpoFSInterface(FileSystem);
+ * ```
+ */
+function createExpoFSInterface(ExpoFS) {
+    const docDir = ExpoFS.documentDirectory || '';
+    const cacheDir = ExpoFS.cacheDirectory || '';
+    return {
+        writeFile: async (path, data, encoding) => {
+            const options = encoding === 'base64'
+                ? { encoding: 'base64' }
+                : { encoding: 'utf8' };
+            await ExpoFS.writeAsStringAsync(path, data, options);
+        },
+        readFile: async (path, encoding) => {
+            const options = encoding === 'base64'
+                ? { encoding: 'base64' }
+                : { encoding: 'utf8' };
+            return ExpoFS.readAsStringAsync(path, options);
+        },
+        exists: async (path) => {
+            const info = await ExpoFS.getInfoAsync(path);
+            return info.exists;
+        },
+        unlink: (path) => ExpoFS.deleteAsync(path, { idempotent: true }),
+        mkdir: (path) => ExpoFS.makeDirectoryAsync(path, { intermediates: true }),
+        documentDirectory: docDir,
+        cacheDirectory: cacheDir,
+    };
+}
+exports.createExpoFSInterface = createExpoFSInterface;
+/**
+ * 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);
+ * ```
+ */
+function createRNArtifactStore(fs, baseDir) {
+    const artifactBaseDir = baseDir || `${fs.documentDirectory}/dop-artifacts`;
+    // Ensure base directory exists
+    const ensureBaseDir = async () => {
+        try {
+            if (!(await fs.exists(artifactBaseDir))) {
+                await fs.mkdir(artifactBaseDir);
+            }
+        }
+        catch {
+            // Directory might already exist
+        }
+    };
+    return {
+        /**
+         * Get artifact content from device storage
+         */
+        get: async (path) => {
+            const fullPath = `${artifactBaseDir}/${path}`;
+            try {
+                if (!(await fs.exists(fullPath))) {
+                    return null;
+                }
+                // Check if it's a JSON file (vkey)
+                if (path.endsWith('.json')) {
+                    const content = await fs.readFile(fullPath, 'utf8');
+                    return content;
+                }
+                // Binary file (zkey, wasm, dat)
+                const base64 = await fs.readFile(fullPath, 'base64');
+                return Buffer.from(base64, 'base64');
+            }
+            catch {
+                return null;
+            }
+        },
+        /**
+         * Store artifact to device storage
+         * This is called by SDK's ArtifactDownloader after downloading
+         */
+        store: async (dir, path, item) => {
+            await ensureBaseDir();
+            const fullDir = `${artifactBaseDir}/${dir}`;
+            const fullPath = `${artifactBaseDir}/${path}`;
+            // Ensure directory exists
+            try {
+                if (!(await fs.exists(fullDir))) {
+                    await fs.mkdir(fullDir);
+                }
+            }
+            catch {
+                // Directory might already exist
+            }
+            // Store the artifact
+            if (typeof item === 'string') {
+                // JSON string (vkey)
+                await fs.writeFile(fullPath, item, 'utf8');
+            }
+            else {
+                // Binary data (zkey, wasm, dat)
+                const base64 = uint8ArrayToBase64(item);
+                await fs.writeFile(fullPath, base64, 'base64');
+            }
+            console.log(`[RN ArtifactStore] Stored artifact: ${path}`);
+        },
+        /**
+         * Check if artifact exists on device
+         */
+        exists: async (path) => {
+            const fullPath = `${artifactBaseDir}/${path}`;
+            return fs.exists(fullPath);
+        },
+    };
+}
+exports.createRNArtifactStore = createRNArtifactStore;
+/**
+ * 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);
+ * ```
+ */
+function getRNArtifactPath(fs, circuitId, artifactType, baseDir) {
+    const artifactBaseDir = baseDir || `${fs.documentDirectory}/dop-artifacts`;
+    const artifactDir = `artifacts-v2.1/${circuitId}`;
+    switch (artifactType) {
+        case 'zkey':
+            return `${artifactBaseDir}/${artifactDir}/zkey`;
+        case 'wasm':
+            return `${artifactBaseDir}/${artifactDir}/wasm`;
+        case 'vkey':
+            return `${artifactBaseDir}/${artifactDir}/vkey.json`;
+        case 'dat':
+            return `${artifactBaseDir}/${artifactDir}/dat`;
+    }
+}
+exports.getRNArtifactPath = getRNArtifactPath;
+/**
+ * Check if all artifacts for a circuit are downloaded
+ */
+async function hasRNArtifacts(fs, circuitId, baseDir, useNativeArtifacts = false) {
+    const zkeyPath = getRNArtifactPath(fs, circuitId, 'zkey', baseDir);
+    const wasmOrDatPath = getRNArtifactPath(fs, circuitId, useNativeArtifacts ? 'dat' : 'wasm', baseDir);
+    const [hasZkey, hasWasmOrDat] = await Promise.all([
+        fs.exists(zkeyPath),
+        fs.exists(wasmOrDatPath),
+    ]);
+    return hasZkey && hasWasmOrDat;
+}
+exports.hasRNArtifacts = hasRNArtifacts;
+// Types and classes are exported where they are defined
+//# sourceMappingURL=react-native-prover.js.map