@umbra-privacy/rn-zk-prover 0.1.0 → 0.1.2

package/lib/typescript/src/generated/mopro_umbra_2.d.ts

@@ -205,9 +205,6 @@ export declare const MoproError: Readonly<{
             cause?: unknown;
         }): Readonly<[string]>;
         isError(error: unknown): error is Error;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
     };
     Halo2Error: {
         new (v0: string): {
@@ -276,9 +273,6 @@ export declare const MoproError: Readonly<{
             cause?: unknown;
         }): Readonly<[string]>;
         isError(error: unknown): error is Error;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
     };
     NoirError: {
         new (v0: string): {
@@ -347,9 +341,6 @@ export declare const MoproError: Readonly<{
             cause?: unknown;
         }): Readonly<[string]>;
         isError(error: unknown): error is Error;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-        stackTraceLimit: number;
     };
 }>;
 export type MoproError = InstanceType<typeof MoproError[keyof Omit<typeof MoproError, 'instanceOf'>]>;

package/lib/typescript/src/generated/mopro_umbra_2.d.ts.map

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umbra-privacy/rn-zk-prover",
   "private": false,
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "ZK Prover bindings for React Native for Umbra Privacy ZKs",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -14,6 +14,7 @@
     "./package.json": "./package.json"
   },
   "files": [
+    "src",
     "lib",
     "android",
     "ios",
@@ -49,14 +50,14 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/zkmopro/react-native-app.git"
+    "url": "git+https://github.com/umbra-defi/rn-zk-prover.git"
   },
   "author": "ZK Mopro Team (https://zkmopro.com)",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/zkmopro/react-native-app/issues"
+    "url": "https://github.com/umbra-defi/rn-zk-prover/issues"
   },
-  "homepage": "https://github.com/zkmopro/react-native-app#readme",
+  "homepage": "https://github.com/umbra-defi/rn-zk-prover#readme",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "restricted"

package/src/NativeMoproFfi.ts

@@ -0,0 +1,10 @@
+// Generated by uniffi-bindgen-react-native
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  installRustCrate(): boolean;
+  cleanupRustCrate(): boolean;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('MoproFfi');

package/src/generated/mopro_umbra_2-ffi.ts

@@ -0,0 +1,153 @@
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import {
+  type StructuralEquality as UniffiStructuralEquality,
+  type UniffiForeignFuture as RuntimeUniffiForeignFuture,
+  type UniffiRustCallStatus,
+  type UniffiRustArcPtr,
+  type UniffiRustFutureContinuationCallback as RuntimeUniffiRustFutureContinuationCallback,
+  type UniffiResult,
+ } from 'uniffi-bindgen-react-native';
+
+interface NativeModuleInterface {
+    ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(string: string, uniffi_out_err: UniffiRustCallStatus): number;
+    ubrn_uniffi_internal_fn_func_ffi__string_to_arraybuffer(string: string, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
+    ubrn_uniffi_internal_fn_func_ffi__arraybuffer_to_string(buffer: Uint8Array, uniffi_out_err: UniffiRustCallStatus): string;
+    ubrn_uniffi_mopro_umbra_2_fn_func_generate_circom_proof(zkeyPath: Uint8Array, circuitInputs: Uint8Array, proofLib: Uint8Array, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
+    ubrn_uniffi_mopro_umbra_2_fn_func_generate_halo2_proof(srsPath: Uint8Array, pkPath: Uint8Array, circuitInputs: Uint8Array, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
+    ubrn_uniffi_mopro_umbra_2_fn_func_generate_noir_proof(circuitPath: Uint8Array, srsPath: Uint8Array, inputs: Uint8Array, onChain: number, vk: Uint8Array, lowMemoryMode: number, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
+    ubrn_uniffi_mopro_umbra_2_fn_func_get_noir_verification_key(circuitPath: Uint8Array, srsPath: Uint8Array, onChain: number, lowMemoryMode: number, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
+    ubrn_uniffi_mopro_umbra_2_fn_func_mopro_hello_world(uniffi_out_err: UniffiRustCallStatus): Uint8Array;
+    ubrn_uniffi_mopro_umbra_2_fn_func_verify_circom_proof(zkeyPath: Uint8Array, proofResult: Uint8Array, proofLib: Uint8Array, uniffi_out_err: UniffiRustCallStatus): number;
+    ubrn_uniffi_mopro_umbra_2_fn_func_verify_halo2_proof(srsPath: Uint8Array, vkPath: Uint8Array, proof: Uint8Array, publicInput: Uint8Array, uniffi_out_err: UniffiRustCallStatus): number;
+    ubrn_uniffi_mopro_umbra_2_fn_func_verify_noir_proof(circuitPath: Uint8Array, proof: Uint8Array, onChain: number, vk: Uint8Array, lowMemoryMode: number, uniffi_out_err: UniffiRustCallStatus): number;
+    ubrn_uniffi_mopro_umbra_2_checksum_func_generate_circom_proof(): number;
+    ubrn_uniffi_mopro_umbra_2_checksum_func_generate_halo2_proof(): number;
+    ubrn_uniffi_mopro_umbra_2_checksum_func_generate_noir_proof(): number;
+    ubrn_uniffi_mopro_umbra_2_checksum_func_get_noir_verification_key(): number;
+    ubrn_uniffi_mopro_umbra_2_checksum_func_mopro_hello_world(): number;
+    ubrn_uniffi_mopro_umbra_2_checksum_func_verify_circom_proof(): number;
+    ubrn_uniffi_mopro_umbra_2_checksum_func_verify_halo2_proof(): number;
+    ubrn_uniffi_mopro_umbra_2_checksum_func_verify_noir_proof(): number;
+    ubrn_ffi_mopro_umbra_2_uniffi_contract_version(): number;
+}
+
+// Casting globalThis to any allows us to look for `NativeMoproUmbra2`
+// if it was added via JSI.
+//
+// We use a getter here rather than simply `globalThis.NativeMoproUmbra2` so that
+// if/when the startup sequence isn't just so, an empty value isn't inadvertantly cached.
+const getter: () => NativeModuleInterface = () => (globalThis as any).NativeMoproUmbra2;
+export default getter;
+
+// Structs and function types for calling back into Typescript from Rust.
+export type UniffiRustFutureContinuationCallback = (data: bigint, pollResult: number) => void;
+type UniffiForeignFutureFree = (handle: bigint) => void;
+type UniffiCallbackInterfaceFree = (handle: bigint) => void;
+export type UniffiForeignFuture = {
+  handle: bigint;
+  free: UniffiForeignFutureFree;
+};
+export type UniffiForeignFutureStructU8 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteU8 = (callbackData: bigint, result: UniffiForeignFutureStructU8) => void;
+export type UniffiForeignFutureStructI8 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteI8 = (callbackData: bigint, result: UniffiForeignFutureStructI8) => void;
+export type UniffiForeignFutureStructU16 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteU16 = (callbackData: bigint, result: UniffiForeignFutureStructU16) => void;
+export type UniffiForeignFutureStructI16 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteI16 = (callbackData: bigint, result: UniffiForeignFutureStructI16) => void;
+export type UniffiForeignFutureStructU32 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteU32 = (callbackData: bigint, result: UniffiForeignFutureStructU32) => void;
+export type UniffiForeignFutureStructI32 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteI32 = (callbackData: bigint, result: UniffiForeignFutureStructI32) => void;
+export type UniffiForeignFutureStructU64 = {
+  returnValue: bigint;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteU64 = (callbackData: bigint, result: UniffiForeignFutureStructU64) => void;
+export type UniffiForeignFutureStructI64 = {
+  returnValue: bigint;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteI64 = (callbackData: bigint, result: UniffiForeignFutureStructI64) => void;
+export type UniffiForeignFutureStructF32 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteF32 = (callbackData: bigint, result: UniffiForeignFutureStructF32) => void;
+export type UniffiForeignFutureStructF64 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteF64 = (callbackData: bigint, result: UniffiForeignFutureStructF64) => void;
+export type UniffiForeignFutureStructPointer = {
+  returnValue: bigint;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompletePointer = (callbackData: bigint, result: UniffiForeignFutureStructPointer) => void;
+export type UniffiForeignFutureStructRustBuffer = {
+  returnValue: Uint8Array;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteRustBuffer = (callbackData: bigint, result: UniffiForeignFutureStructRustBuffer) => void;
+export type UniffiForeignFutureStructVoid = {
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteVoid = (callbackData: bigint, result: UniffiForeignFutureStructVoid) => void;
+
+// UniffiRustFutureContinuationCallback is generated as part of the component interface's
+// ffi_definitions. However, we need it in the runtime.
+// We could:
+// (a) do some complicated template logic to ensure the declaration is not generated here (possible)
+// (b) import the generated declaration into the runtime (m a y b e) or…
+// (c) generate the declaration anyway, and use a different declaration in the runtime.
+//
+// We chose (c) here as the simplest. In addition, we perform a compile time check that
+// the two versions of `UniffiRustFutureContinuationCallback` are structurally equivalent.
+//
+// If you see the error:
+// ```
+// Type 'true' is not assignable to type 'false'.(2322)
+// ```
+// Then a new version of uniffi has changed the signature of the callback. Most likely, code in
+// `typescript/src/async-rust-call.ts` will need to be changed.
+//
+// If you see the error:
+// ```
+// Cannot find name 'UniffiRustFutureContinuationCallback'. Did you mean 'RuntimeUniffiRustFutureContinuationCallback'?(2552)
+// ```
+// then you may not be using callbacks or promises, and uniffi is now not generating Futures and callbacks.
+// You should not generate this if that is the case.
+//
+// ('You' being the bindings generator maintainer).
+const isRustFutureContinuationCallbackTypeCompatible: UniffiStructuralEquality<
+  RuntimeUniffiRustFutureContinuationCallback,
+  UniffiRustFutureContinuationCallback
+> = true;
+const isUniffiForeignFutureTypeCompatible: UniffiStructuralEquality<
+  RuntimeUniffiForeignFuture,
+  UniffiForeignFuture
+> = true;

package/src/generated/mopro_umbra_2.ts

@@ -0,0 +1,838 @@
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+import nativeModule, {
+  type UniffiRustFutureContinuationCallback,
+  type UniffiForeignFuture,
+  type UniffiForeignFutureStructU8,
+  type UniffiForeignFutureCompleteU8,
+  type UniffiForeignFutureStructI8,
+  type UniffiForeignFutureCompleteI8,
+  type UniffiForeignFutureStructU16,
+  type UniffiForeignFutureCompleteU16,
+  type UniffiForeignFutureStructI16,
+  type UniffiForeignFutureCompleteI16,
+  type UniffiForeignFutureStructU32,
+  type UniffiForeignFutureCompleteU32,
+  type UniffiForeignFutureStructI32,
+  type UniffiForeignFutureCompleteI32,
+  type UniffiForeignFutureStructU64,
+  type UniffiForeignFutureCompleteU64,
+  type UniffiForeignFutureStructI64,
+  type UniffiForeignFutureCompleteI64,
+  type UniffiForeignFutureStructF32,
+  type UniffiForeignFutureCompleteF32,
+  type UniffiForeignFutureStructF64,
+  type UniffiForeignFutureCompleteF64,
+  type UniffiForeignFutureStructPointer,
+  type UniffiForeignFutureCompletePointer,
+  type UniffiForeignFutureStructRustBuffer,
+  type UniffiForeignFutureCompleteRustBuffer,
+  type UniffiForeignFutureStructVoid,
+  type UniffiForeignFutureCompleteVoid,
+} from "./mopro_umbra_2-ffi";
+import {
+  type UniffiByteArray, 
+  AbstractFfiConverterByteArray, 
+  FfiConverterArray, 
+  FfiConverterArrayBuffer, 
+  FfiConverterBool, 
+  FfiConverterInt32, 
+  FfiConverterMap, 
+  FfiConverterOptional, 
+  RustBuffer, 
+  UniffiError, 
+  UniffiInternalError, 
+  UniffiRustCaller, 
+  uniffiCreateFfiConverterString, 
+  uniffiCreateRecord, 
+  uniffiTypeNameSymbol, 
+  variantOrdinalSymbol } from "uniffi-bindgen-react-native";
+
+// Get converters from the other files, if any.
+const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+
+const uniffiIsDebug =
+  // @ts-ignore -- The process global might not be defined
+  typeof process !== "object" ||
+  // @ts-ignore -- The process global might not be defined
+  process?.env?.NODE_ENV !== "production" ||
+  false;
+// Public interface members begin here.
+
+export function generateCircomProof(zkeyPath: string, circuitInputs: string, proofLib: ProofLib): CircomProofResult /*throws*/ {
+    return FfiConverterTypeCircomProofResult.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeMoproError.lift.bind(FfiConverterTypeMoproError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_mopro_umbra_2_fn_func_generate_circom_proof(
+        FfiConverterString.lower(zkeyPath),
+        FfiConverterString.lower(circuitInputs),
+        FfiConverterTypeProofLib.lower(proofLib),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+export function generateHalo2Proof(srsPath: string, pkPath: string, circuitInputs: Map<string, Array<string>>): Halo2ProofResult /*throws*/ {
+    return FfiConverterTypeHalo2ProofResult.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeMoproError.lift.bind(FfiConverterTypeMoproError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_mopro_umbra_2_fn_func_generate_halo2_proof(
+        FfiConverterString.lower(srsPath),
+        FfiConverterString.lower(pkPath),
+        FfiConverterMapStringArrayString.lower(circuitInputs),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+export function generateNoirProof(circuitPath: string, srsPath: string | undefined, inputs: Array<string>, onChain: boolean, vk: ArrayBuffer, lowMemoryMode: boolean): ArrayBuffer /*throws*/ {
+    return FfiConverterArrayBuffer.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeMoproError.lift.bind(FfiConverterTypeMoproError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_mopro_umbra_2_fn_func_generate_noir_proof(
+        FfiConverterString.lower(circuitPath),
+        FfiConverterOptionalString.lower(srsPath),
+        FfiConverterArrayString.lower(inputs),
+        FfiConverterBool.lower(onChain),
+        FfiConverterArrayBuffer.lower(vk),
+        FfiConverterBool.lower(lowMemoryMode),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+export function getNoirVerificationKey(circuitPath: string, srsPath: string | undefined, onChain: boolean, lowMemoryMode: boolean): ArrayBuffer /*throws*/ {
+    return FfiConverterArrayBuffer.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeMoproError.lift.bind(FfiConverterTypeMoproError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_mopro_umbra_2_fn_func_get_noir_verification_key(
+        FfiConverterString.lower(circuitPath),
+        FfiConverterOptionalString.lower(srsPath),
+        FfiConverterBool.lower(onChain),
+        FfiConverterBool.lower(lowMemoryMode),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * You can also customize the bindings by #[uniffi::export]
+ * Reference: https://mozilla.github.io/uniffi-rs/latest/proc_macro/index.html
+ */
+export function moproHelloWorld(): string {
+    return FfiConverterString.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_mopro_umbra_2_fn_func_mopro_hello_world(
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+export function verifyCircomProof(zkeyPath: string, proofResult: CircomProofResult, proofLib: ProofLib): boolean /*throws*/ {
+    return FfiConverterBool.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeMoproError.lift.bind(FfiConverterTypeMoproError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_mopro_umbra_2_fn_func_verify_circom_proof(
+        FfiConverterString.lower(zkeyPath),
+        FfiConverterTypeCircomProofResult.lower(proofResult),
+        FfiConverterTypeProofLib.lower(proofLib),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+export function verifyHalo2Proof(srsPath: string, vkPath: string, proof: ArrayBuffer, publicInput: ArrayBuffer): boolean /*throws*/ {
+    return FfiConverterBool.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeMoproError.lift.bind(FfiConverterTypeMoproError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_mopro_umbra_2_fn_func_verify_halo2_proof(
+        FfiConverterString.lower(srsPath),
+        FfiConverterString.lower(vkPath),
+        FfiConverterArrayBuffer.lower(proof),
+        FfiConverterArrayBuffer.lower(publicInput),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+export function verifyNoirProof(circuitPath: string, proof: ArrayBuffer, onChain: boolean, vk: ArrayBuffer, lowMemoryMode: boolean): boolean /*throws*/ {
+    return FfiConverterBool.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeMoproError.lift.bind(FfiConverterTypeMoproError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_mopro_umbra_2_fn_func_verify_noir_proof(
+        FfiConverterString.lower(circuitPath),
+        FfiConverterArrayBuffer.lower(proof),
+        FfiConverterBool.lower(onChain),
+        FfiConverterArrayBuffer.lower(vk),
+        FfiConverterBool.lower(lowMemoryMode),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+
+
+
+
+
+
+
+
+export type CircomProof = {
+    a: G1,
+    b: G2,
+    c: G1,
+    protocol: string,
+    curve: string
+}
+
+/**
+ * Generated factory for {@link CircomProof} record objects.
+ */
+export const CircomProof = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<CircomProof, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link CircomProof}, with defaults specified
+         * in Rust, in the {@link mopro_umbra_2} crate.
+         */
+        create,
+
+        /**
+         * Create a frozen instance of {@link CircomProof}, with defaults specified
+         * in Rust, in the {@link mopro_umbra_2} crate.
+         */
+        new: create,
+
+        /**
+         * Defaults specified in the {@link mopro_umbra_2} crate.
+         */
+        defaults: () => Object.freeze(defaults()) as Partial<CircomProof>,
+    });
+})();
+
+const FfiConverterTypeCircomProof = (() => {
+    type TypeName = CircomProof;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                a: FfiConverterTypeG1.read(from), 
+                b: FfiConverterTypeG2.read(from), 
+                c: FfiConverterTypeG1.read(from), 
+                protocol: FfiConverterString.read(from), 
+                curve: FfiConverterString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterTypeG1.write(value.a, into);
+            FfiConverterTypeG2.write(value.b, into);
+            FfiConverterTypeG1.write(value.c, into);
+            FfiConverterString.write(value.protocol, into);
+            FfiConverterString.write(value.curve, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterTypeG1.allocationSize(value.a) + 
+            FfiConverterTypeG2.allocationSize(value.b) + 
+            FfiConverterTypeG1.allocationSize(value.c) + 
+            FfiConverterString.allocationSize(value.protocol) + 
+            FfiConverterString.allocationSize(value.curve);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type CircomProofResult = {
+    proof: CircomProof,
+    inputs: Array<string>
+}
+
+/**
+ * Generated factory for {@link CircomProofResult} record objects.
+ */
+export const CircomProofResult = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<CircomProofResult, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link CircomProofResult}, with defaults specified
+         * in Rust, in the {@link mopro_umbra_2} crate.
+         */
+        create,
+
+        /**
+         * Create a frozen instance of {@link CircomProofResult}, with defaults specified
+         * in Rust, in the {@link mopro_umbra_2} crate.
+         */
+        new: create,
+
+        /**
+         * Defaults specified in the {@link mopro_umbra_2} crate.
+         */
+        defaults: () => Object.freeze(defaults()) as Partial<CircomProofResult>,
+    });
+})();
+
+const FfiConverterTypeCircomProofResult = (() => {
+    type TypeName = CircomProofResult;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                proof: FfiConverterTypeCircomProof.read(from), 
+                inputs: FfiConverterArrayString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterTypeCircomProof.write(value.proof, into);
+            FfiConverterArrayString.write(value.inputs, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterTypeCircomProof.allocationSize(value.proof) + 
+            FfiConverterArrayString.allocationSize(value.inputs);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type G1 = {
+    x: string,
+    y: string,
+    z: string
+}
+
+/**
+ * Generated factory for {@link G1} record objects.
+ */
+export const G1 = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<G1, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link G1}, with defaults specified
+         * in Rust, in the {@link mopro_umbra_2} crate.
+         */
+        create,
+
+        /**
+         * Create a frozen instance of {@link G1}, with defaults specified
+         * in Rust, in the {@link mopro_umbra_2} crate.
+         */
+        new: create,
+
+        /**
+         * Defaults specified in the {@link mopro_umbra_2} crate.
+         */
+        defaults: () => Object.freeze(defaults()) as Partial<G1>,
+    });
+})();
+
+const FfiConverterTypeG1 = (() => {
+    type TypeName = G1;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                x: FfiConverterString.read(from), 
+                y: FfiConverterString.read(from), 
+                z: FfiConverterString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.x, into);
+            FfiConverterString.write(value.y, into);
+            FfiConverterString.write(value.z, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.x) + 
+            FfiConverterString.allocationSize(value.y) + 
+            FfiConverterString.allocationSize(value.z);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type G2 = {
+    x: Array<string>,
+    y: Array<string>,
+    z: Array<string>
+}
+
+/**
+ * Generated factory for {@link G2} record objects.
+ */
+export const G2 = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<G2, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link G2}, with defaults specified
+         * in Rust, in the {@link mopro_umbra_2} crate.
+         */
+        create,
+
+        /**
+         * Create a frozen instance of {@link G2}, with defaults specified
+         * in Rust, in the {@link mopro_umbra_2} crate.
+         */
+        new: create,
+
+        /**
+         * Defaults specified in the {@link mopro_umbra_2} crate.
+         */
+        defaults: () => Object.freeze(defaults()) as Partial<G2>,
+    });
+})();
+
+const FfiConverterTypeG2 = (() => {
+    type TypeName = G2;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                x: FfiConverterArrayString.read(from), 
+                y: FfiConverterArrayString.read(from), 
+                z: FfiConverterArrayString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterArrayString.write(value.x, into);
+            FfiConverterArrayString.write(value.y, into);
+            FfiConverterArrayString.write(value.z, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterArrayString.allocationSize(value.x) + 
+            FfiConverterArrayString.allocationSize(value.y) + 
+            FfiConverterArrayString.allocationSize(value.z);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type Halo2ProofResult = {
+    proof: ArrayBuffer,
+    inputs: ArrayBuffer
+}
+
+/**
+ * Generated factory for {@link Halo2ProofResult} record objects.
+ */
+export const Halo2ProofResult = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<Halo2ProofResult, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link Halo2ProofResult}, with defaults specified
+         * in Rust, in the {@link mopro_umbra_2} crate.
+         */
+        create,
+
+        /**
+         * Create a frozen instance of {@link Halo2ProofResult}, with defaults specified
+         * in Rust, in the {@link mopro_umbra_2} crate.
+         */
+        new: create,
+
+        /**
+         * Defaults specified in the {@link mopro_umbra_2} crate.
+         */
+        defaults: () => Object.freeze(defaults()) as Partial<Halo2ProofResult>,
+    });
+})();
+
+const FfiConverterTypeHalo2ProofResult = (() => {
+    type TypeName = Halo2ProofResult;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                proof: FfiConverterArrayBuffer.read(from), 
+                inputs: FfiConverterArrayBuffer.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterArrayBuffer.write(value.proof, into);
+            FfiConverterArrayBuffer.write(value.inputs, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterArrayBuffer.allocationSize(value.proof) + 
+            FfiConverterArrayBuffer.allocationSize(value.inputs);
+            
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+const stringConverter = {
+    stringToBytes: (s: string) =>
+        uniffiCaller.rustCall((status) => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_arraybuffer(s, status)),
+    bytesToString: (ab: UniffiByteArray) =>
+        uniffiCaller.rustCall((status) => nativeModule().ubrn_uniffi_internal_fn_func_ffi__arraybuffer_to_string(ab, status)),
+    stringByteLength: (s: string) =>
+        uniffiCaller.rustCall((status) => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(s, status)),
+};
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+
+// Error type: MoproError
+
+// Enum: MoproError
+export enum MoproError_Tags {
+    CircomError = "CircomError",
+    Halo2Error = "Halo2Error",
+    NoirError = "NoirError"
+}
+export const MoproError = (() => {
+    
+
+    type CircomError__interface = {
+        tag: MoproError_Tags.CircomError;
+        inner: Readonly<
+[string
+]>
+    };
+
+    
+    class CircomError_ extends UniffiError implements CircomError__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "MoproError";
+        readonly tag = MoproError_Tags.CircomError;
+        readonly inner: Readonly<
+[string
+]>;
+        constructor(v0: string) {
+            super("MoproError", "CircomError");
+            this.inner = Object.freeze([v0]);
+        }
+
+        static new(v0: string): CircomError_ {
+            return new CircomError_(v0);
+        }
+
+        static instanceOf(obj: any): obj is CircomError_ {
+            return obj.tag === MoproError_Tags.CircomError;
+        }
+
+        
+        static hasInner(obj: any): obj is CircomError_ {
+            return CircomError_.instanceOf(obj);
+        }
+
+        static getInner(obj: CircomError_): Readonly<
+[string
+]> {
+            return obj.inner;
+        }
+
+    }
+    
+
+    type Halo2Error__interface = {
+        tag: MoproError_Tags.Halo2Error;
+        inner: Readonly<
+[string
+]>
+    };
+
+    
+    class Halo2Error_ extends UniffiError implements Halo2Error__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "MoproError";
+        readonly tag = MoproError_Tags.Halo2Error;
+        readonly inner: Readonly<
+[string
+]>;
+        constructor(v0: string) {
+            super("MoproError", "Halo2Error");
+            this.inner = Object.freeze([v0]);
+        }
+
+        static new(v0: string): Halo2Error_ {
+            return new Halo2Error_(v0);
+        }
+
+        static instanceOf(obj: any): obj is Halo2Error_ {
+            return obj.tag === MoproError_Tags.Halo2Error;
+        }
+
+        
+        static hasInner(obj: any): obj is Halo2Error_ {
+            return Halo2Error_.instanceOf(obj);
+        }
+
+        static getInner(obj: Halo2Error_): Readonly<
+[string
+]> {
+            return obj.inner;
+        }
+
+    }
+    
+
+    type NoirError__interface = {
+        tag: MoproError_Tags.NoirError;
+        inner: Readonly<
+[string
+]>
+    };
+
+    
+    class NoirError_ extends UniffiError implements NoirError__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "MoproError";
+        readonly tag = MoproError_Tags.NoirError;
+        readonly inner: Readonly<
+[string
+]>;
+        constructor(v0: string) {
+            super("MoproError", "NoirError");
+            this.inner = Object.freeze([v0]);
+        }
+
+        static new(v0: string): NoirError_ {
+            return new NoirError_(v0);
+        }
+
+        static instanceOf(obj: any): obj is NoirError_ {
+            return obj.tag === MoproError_Tags.NoirError;
+        }
+
+        
+        static hasInner(obj: any): obj is NoirError_ {
+            return NoirError_.instanceOf(obj);
+        }
+
+        static getInner(obj: NoirError_): Readonly<
+[string
+]> {
+            return obj.inner;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is MoproError {
+        return obj[uniffiTypeNameSymbol] === "MoproError";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  CircomError: CircomError_, 
+  Halo2Error: Halo2Error_, 
+  NoirError: NoirError_
+    });
+
+})();
+
+
+
+export type MoproError = InstanceType<
+    typeof MoproError[keyof Omit<typeof MoproError, 'instanceOf'>]
+>;
+
+// FfiConverter for enum MoproError
+const FfiConverterTypeMoproError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = MoproError;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new MoproError.CircomError(FfiConverterString.read(from));
+                case 2: return new MoproError.Halo2Error(FfiConverterString.read(from));
+                case 3: return new MoproError.NoirError(FfiConverterString.read(from));
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case MoproError_Tags.CircomError: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner[0], into);
+                    return;
+                }
+                case MoproError_Tags.Halo2Error: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner[0], into);
+                    return;
+                }
+                case MoproError_Tags.NoirError: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner[0], into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that MoproError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case MoproError_Tags.CircomError: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner[0]);
+                    return size;
+                }
+                case MoproError_Tags.Halo2Error: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner[0]);
+                    return size;
+                }
+                case MoproError_Tags.NoirError: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterString.allocationSize(inner[0]);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+export enum ProofLib {
+    Arkworks,
+    Rapidsnark
+}
+
+const FfiConverterTypeProofLib = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = ProofLib;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ProofLib.Arkworks;
+                case 2: return ProofLib.Rapidsnark;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value) {
+                case ProofLib.Arkworks: return ordinalConverter.write(1, into);
+                case ProofLib.Rapidsnark: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+
+
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+
+// FfiConverter for Array<string>
+const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
+
+
+// FfiConverter for Map<string, Array<string>>
+const FfiConverterMapStringArrayString = new FfiConverterMap(FfiConverterString, FfiConverterArrayString);
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+    // Get the bindings contract version from our ComponentInterface
+    const bindingsContractVersion = 30;
+    // Get the scaffolding contract version by calling the into the dylib
+    const scaffoldingContractVersion = nativeModule().ubrn_ffi_mopro_umbra_2_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().ubrn_uniffi_mopro_umbra_2_checksum_func_generate_circom_proof() !== 55464) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_mopro_umbra_2_checksum_func_generate_circom_proof");
+    }
+    if (nativeModule().ubrn_uniffi_mopro_umbra_2_checksum_func_generate_halo2_proof() !== 46845) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_mopro_umbra_2_checksum_func_generate_halo2_proof");
+    }
+    if (nativeModule().ubrn_uniffi_mopro_umbra_2_checksum_func_generate_noir_proof() !== 28401) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_mopro_umbra_2_checksum_func_generate_noir_proof");
+    }
+    if (nativeModule().ubrn_uniffi_mopro_umbra_2_checksum_func_get_noir_verification_key() !== 30991) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_mopro_umbra_2_checksum_func_get_noir_verification_key");
+    }
+    if (nativeModule().ubrn_uniffi_mopro_umbra_2_checksum_func_mopro_hello_world() !== 25559) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_mopro_umbra_2_checksum_func_mopro_hello_world");
+    }
+    if (nativeModule().ubrn_uniffi_mopro_umbra_2_checksum_func_verify_circom_proof() !== 40361) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_mopro_umbra_2_checksum_func_verify_circom_proof");
+    }
+    if (nativeModule().ubrn_uniffi_mopro_umbra_2_checksum_func_verify_halo2_proof() !== 28169) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_mopro_umbra_2_checksum_func_verify_halo2_proof");
+    }
+    if (nativeModule().ubrn_uniffi_mopro_umbra_2_checksum_func_verify_noir_proof() !== 41390) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_mopro_umbra_2_checksum_func_verify_noir_proof");
+    }
+
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeCircomProof,
+    FfiConverterTypeCircomProofResult,
+    FfiConverterTypeG1,
+    FfiConverterTypeG2,
+    FfiConverterTypeHalo2ProofResult,
+    FfiConverterTypeMoproError,
+    FfiConverterTypeProofLib,
+  }
+});

package/src/index.tsx

@@ -0,0 +1,41 @@
+// Generated by uniffi-bindgen-react-native
+import installer from './NativeMoproFfi';
+
+// Register the rust crate with Hermes
+// - the boolean flag ensures this loads exactly once, even if the JS
+//   code is reloaded (e.g. during development with metro).
+let rustInstalled = false;
+if (!rustInstalled) {
+  installer.installRustCrate();
+  rustInstalled = true;
+}
+
+// Export the generated bindings to the app.
+export * from './generated/mopro_umbra_2';
+
+// Now import the bindings so we can:
+// - intialize them
+// - export them as namespaced objects as the default export.
+import * as mopro_umbra_2 from './generated/mopro_umbra_2';
+
+// Initialize the generated bindings: mostly checksums, but also callbacks.
+// - the boolean flag ensures this loads exactly once, even if the JS code
+//   is reloaded (e.g. during development with metro).
+let initialized = false;
+if (!initialized) {
+  mopro_umbra_2.default.initialize();
+  initialized = true;
+}
+
+// This provides parity with the index.web.ts version of this file.
+// The web version relies on an asynchronous fetch, which this doesn't
+// need, so we just no-op.
+export async function uniffiInitAsync() {
+  // NOOP.
+}
+
+// Export the crates as individually namespaced objects.
+export default {
+  mopro_umbra_2,
+};
+