@baerae/zkap-zkp-react-native 0.1.4 → 0.1.6

package/src/generated/zkap_uniffi_bindings.ts

@@ -0,0 +1,1015 @@
+// 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 UniffiForeignFutureDroppedCallback,
+  type UniffiForeignFutureDroppedCallbackStruct,
+  type UniffiForeignFutureResultU8,
+  type UniffiForeignFutureCompleteU8,
+  type UniffiForeignFutureResultI8,
+  type UniffiForeignFutureCompleteI8,
+  type UniffiForeignFutureResultU16,
+  type UniffiForeignFutureCompleteU16,
+  type UniffiForeignFutureResultI16,
+  type UniffiForeignFutureCompleteI16,
+  type UniffiForeignFutureResultU32,
+  type UniffiForeignFutureCompleteU32,
+  type UniffiForeignFutureResultI32,
+  type UniffiForeignFutureCompleteI32,
+  type UniffiForeignFutureResultU64,
+  type UniffiForeignFutureCompleteU64,
+  type UniffiForeignFutureResultI64,
+  type UniffiForeignFutureCompleteI64,
+  type UniffiForeignFutureResultF32,
+  type UniffiForeignFutureCompleteF32,
+  type UniffiForeignFutureResultF64,
+  type UniffiForeignFutureCompleteF64,
+  type UniffiForeignFutureResultRustBuffer,
+  type UniffiForeignFutureCompleteRustBuffer,
+  type UniffiForeignFutureResultVoid,
+  type UniffiForeignFutureCompleteVoid,
+} from "./zkap_uniffi_bindings-ffi";
+import {
+  type UniffiByteArray,
+  AbstractFfiConverterByteArray,
+  FfiConverterArray,
+  FfiConverterInt32,
+  FfiConverterUInt64,
+  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.
+
+/**
+ * Generate a Poseidon threshold anchor from a list of JWT credential secrets.
+ */
+export function generateAnchor(config: ZkapCircuitConfig, secrets: Array<ZkapSecret>): ZkapAnchorResult /*throws*/ {
+    return FfiConverterTypeZkapAnchorResult.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeZkapError.lift.bind(FfiConverterTypeZkapError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_zkap_uniffi_bindings_fn_func_generate_anchor(
+        FfiConverterTypeZkapCircuitConfig.lower(config),
+        FfiConverterArrayTypeZkapSecret.lower(secrets),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Compute per-audience hashes and the combined audience-list hash.
+ */
+export function generateAudHash(config: ZkapCircuitConfig, audList: Array<string>): ZkapAudHashResult /*throws*/ {
+    return FfiConverterTypeZkapAudHashResult.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeZkapError.lift.bind(FfiConverterTypeZkapError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_zkap_uniffi_bindings_fn_func_generate_aud_hash(
+        FfiConverterTypeZkapCircuitConfig.lower(config),
+        FfiConverterArrayString.lower(audList),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Compute a Poseidon hash of one or more field-element strings (hex or decimal).
+ *
+ * Returns the result as a 0x-prefixed hex string.
+ */
+export function generateHash(messages: Array<string>): string /*throws*/ {
+    return FfiConverterString.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeZkapError.lift.bind(FfiConverterTypeZkapError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_zkap_uniffi_bindings_fn_func_generate_hash(
+        FfiConverterArrayString.lower(messages),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Compute the Merkle leaf hash for an issuer + RSA public-key modulus (base64-encoded).
+ *
+ * Returns the leaf field element as a 0x-prefixed hex string.
+ */
+export function generateLeafHash(config: ZkapCircuitConfig, iss: string, pkB64: string): string /*throws*/ {
+    return FfiConverterString.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeZkapError.lift.bind(FfiConverterTypeZkapError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_zkap_uniffi_bindings_fn_func_generate_leaf_hash(
+        FfiConverterTypeZkapCircuitConfig.lower(config),
+        FfiConverterString.lower(iss),
+        FfiConverterString.lower(pkB64),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Prepare the manifest-verified inputs required by the iOS WKWebView
+ * witness runner. This does not synthesize a witness or generate a proof.
+ */
+export function prepareWitnessInputs(config: ZkapCircuitConfig, request: ZkapProofRequest): ZkapPreparedWitnessInputs /*throws*/ {
+    return FfiConverterTypeZkapPreparedWitnessInputs.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeZkapError.lift.bind(FfiConverterTypeZkapError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_zkap_uniffi_bindings_fn_func_prepare_witness_inputs(
+        FfiConverterTypeZkapCircuitConfig.lower(config),
+        FfiConverterTypeZkapProofRequest.lower(request),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Generate Groth16 proofs.
+ *
+ * Loads the manifest-validated CRS bundle from `request.manifest_dir`,
+ * runs witness synthesis inside the release-provided `witness_gen.wasm`,
+ * then runs the circuit-agnostic
+ * `ark_ar1cs::prove_with_mode(..., VerifyAfter)` against the bundled proving key.
+ */
+export function prove(config: ZkapCircuitConfig, request: ZkapProofRequest): ZkapProofOutput /*throws*/ {
+    return FfiConverterTypeZkapProofOutput.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeZkapError.lift.bind(FfiConverterTypeZkapError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_zkap_uniffi_bindings_fn_func_prove(
+        FfiConverterTypeZkapCircuitConfig.lower(config),
+        FfiConverterTypeZkapProofRequest.lower(request),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Generate Groth16 proofs from a canonical serialized `Vec<WitnessBundle>`
+ * file produced outside Rust. The file is removed after it is read.
+ */
+export function proveFromWitnessBundleFile(config: ZkapCircuitConfig, request: ZkapProofRequest, witness: ZkapWitnessBundleFile): ZkapProofOutput /*throws*/ {
+    return FfiConverterTypeZkapProofOutput.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeZkapError.lift.bind(FfiConverterTypeZkapError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_zkap_uniffi_bindings_fn_func_prove_from_witness_bundle_file(
+        FfiConverterTypeZkapCircuitConfig.lower(config),
+        FfiConverterTypeZkapProofRequest.lower(request),
+        FfiConverterTypeZkapWitnessBundleFile.lower(witness),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+/**
+ * Generate Groth16 proofs from canonical serialized `Vec<WitnessBundle>`
+ * bytes produced outside Rust, e.g. by the iOS WKWebView witness runner.
+ */
+export function proveFromWitnessBundles(config: ZkapCircuitConfig, request: ZkapProofRequest, witness: ZkapWitnessBundleBytes): ZkapProofOutput /*throws*/ {
+    return FfiConverterTypeZkapProofOutput.lift(
+        uniffiCaller.rustCallWithError(
+            /*liftError:*/ FfiConverterTypeZkapError.lift.bind(FfiConverterTypeZkapError),
+            /*caller:*/ (callStatus) => {
+                return nativeModule().ubrn_uniffi_zkap_uniffi_bindings_fn_func_prove_from_witness_bundles(
+        FfiConverterTypeZkapCircuitConfig.lower(config),
+        FfiConverterTypeZkapProofRequest.lower(request),
+        FfiConverterTypeZkapWitnessBundleBytes.lower(witness),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift,
+    ));
+    }
+
+
+
+
+export type ZkapAnchorResult = {
+    evaluations: Array<string>
+}
+
+/**
+ * Generated factory for {@link ZkapAnchorResult} record objects.
+ */
+export const ZkapAnchorResult = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ZkapAnchorResult, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ZkapAnchorResult>,
+
+    });
+})();
+
+const FfiConverterTypeZkapAnchorResult = (() => {
+    type TypeName = ZkapAnchorResult;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                evaluations: FfiConverterArrayString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterArrayString.write(value.evaluations, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterArrayString.allocationSize(value.evaluations);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type ZkapAudHashResult = {
+    audHashes: Array<string>,
+    hAudList: string
+}
+
+/**
+ * Generated factory for {@link ZkapAudHashResult} record objects.
+ */
+export const ZkapAudHashResult = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ZkapAudHashResult, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ZkapAudHashResult>,
+
+    });
+})();
+
+const FfiConverterTypeZkapAudHashResult = (() => {
+    type TypeName = ZkapAudHashResult;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                audHashes: FfiConverterArrayString.read(from),
+                hAudList: FfiConverterString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterArrayString.write(value.audHashes, into);
+            FfiConverterString.write(value.hAudList, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterArrayString.allocationSize(value.audHashes) +
+            FfiConverterString.allocationSize(value.hAudList);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type ZkapCircuitConfig = {
+    maxJwtB64Len: /*u64*/bigint,
+    maxPayloadB64Len: /*u64*/bigint,
+    maxAudLen: /*u64*/bigint,
+    maxExpLen: /*u64*/bigint,
+    maxIssLen: /*u64*/bigint,
+    maxNonceLen: /*u64*/bigint,
+    maxSubLen: /*u64*/bigint,
+    n: /*u64*/bigint,
+    k: /*u64*/bigint,
+    treeHeight: /*u64*/bigint,
+    numAudienceLimit: /*u64*/bigint,
+    claims: Array<string>,
+    forbiddenString: string
+}
+
+/**
+ * Generated factory for {@link ZkapCircuitConfig} record objects.
+ */
+export const ZkapCircuitConfig = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ZkapCircuitConfig, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ZkapCircuitConfig>,
+
+    });
+})();
+
+const FfiConverterTypeZkapCircuitConfig = (() => {
+    type TypeName = ZkapCircuitConfig;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                maxJwtB64Len: FfiConverterUInt64.read(from),
+                maxPayloadB64Len: FfiConverterUInt64.read(from),
+                maxAudLen: FfiConverterUInt64.read(from),
+                maxExpLen: FfiConverterUInt64.read(from),
+                maxIssLen: FfiConverterUInt64.read(from),
+                maxNonceLen: FfiConverterUInt64.read(from),
+                maxSubLen: FfiConverterUInt64.read(from),
+                n: FfiConverterUInt64.read(from),
+                k: FfiConverterUInt64.read(from),
+                treeHeight: FfiConverterUInt64.read(from),
+                numAudienceLimit: FfiConverterUInt64.read(from),
+                claims: FfiConverterArrayString.read(from),
+                forbiddenString: FfiConverterString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterUInt64.write(value.maxJwtB64Len, into);
+            FfiConverterUInt64.write(value.maxPayloadB64Len, into);
+            FfiConverterUInt64.write(value.maxAudLen, into);
+            FfiConverterUInt64.write(value.maxExpLen, into);
+            FfiConverterUInt64.write(value.maxIssLen, into);
+            FfiConverterUInt64.write(value.maxNonceLen, into);
+            FfiConverterUInt64.write(value.maxSubLen, into);
+            FfiConverterUInt64.write(value.n, into);
+            FfiConverterUInt64.write(value.k, into);
+            FfiConverterUInt64.write(value.treeHeight, into);
+            FfiConverterUInt64.write(value.numAudienceLimit, into);
+            FfiConverterArrayString.write(value.claims, into);
+            FfiConverterString.write(value.forbiddenString, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterUInt64.allocationSize(value.maxJwtB64Len) +
+            FfiConverterUInt64.allocationSize(value.maxPayloadB64Len) +
+            FfiConverterUInt64.allocationSize(value.maxAudLen) +
+            FfiConverterUInt64.allocationSize(value.maxExpLen) +
+            FfiConverterUInt64.allocationSize(value.maxIssLen) +
+            FfiConverterUInt64.allocationSize(value.maxNonceLen) +
+            FfiConverterUInt64.allocationSize(value.maxSubLen) +
+            FfiConverterUInt64.allocationSize(value.n) +
+            FfiConverterUInt64.allocationSize(value.k) +
+            FfiConverterUInt64.allocationSize(value.treeHeight) +
+            FfiConverterUInt64.allocationSize(value.numAudienceLimit) +
+            FfiConverterArrayString.allocationSize(value.claims) +
+            FfiConverterString.allocationSize(value.forbiddenString);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type ZkapPreparedWitnessInputs = {
+    manifestDir: string,
+    wasmBase64: string,
+    requestJsonBase64: string,
+    configJsonBase64: string,
+    witnessGenSha256: string,
+    requestJsonSha256: string,
+    configJsonSha256: string,
+    wasmByteLength: /*u64*/bigint,
+    requestJsonByteLength: /*u64*/bigint,
+    configJsonByteLength: /*u64*/bigint
+}
+
+/**
+ * Generated factory for {@link ZkapPreparedWitnessInputs} record objects.
+ */
+export const ZkapPreparedWitnessInputs = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ZkapPreparedWitnessInputs, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ZkapPreparedWitnessInputs>,
+
+    });
+})();
+
+const FfiConverterTypeZkapPreparedWitnessInputs = (() => {
+    type TypeName = ZkapPreparedWitnessInputs;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                manifestDir: FfiConverterString.read(from),
+                wasmBase64: FfiConverterString.read(from),
+                requestJsonBase64: FfiConverterString.read(from),
+                configJsonBase64: FfiConverterString.read(from),
+                witnessGenSha256: FfiConverterString.read(from),
+                requestJsonSha256: FfiConverterString.read(from),
+                configJsonSha256: FfiConverterString.read(from),
+                wasmByteLength: FfiConverterUInt64.read(from),
+                requestJsonByteLength: FfiConverterUInt64.read(from),
+                configJsonByteLength: FfiConverterUInt64.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.manifestDir, into);
+            FfiConverterString.write(value.wasmBase64, into);
+            FfiConverterString.write(value.requestJsonBase64, into);
+            FfiConverterString.write(value.configJsonBase64, into);
+            FfiConverterString.write(value.witnessGenSha256, into);
+            FfiConverterString.write(value.requestJsonSha256, into);
+            FfiConverterString.write(value.configJsonSha256, into);
+            FfiConverterUInt64.write(value.wasmByteLength, into);
+            FfiConverterUInt64.write(value.requestJsonByteLength, into);
+            FfiConverterUInt64.write(value.configJsonByteLength, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.manifestDir) +
+            FfiConverterString.allocationSize(value.wasmBase64) +
+            FfiConverterString.allocationSize(value.requestJsonBase64) +
+            FfiConverterString.allocationSize(value.configJsonBase64) +
+            FfiConverterString.allocationSize(value.witnessGenSha256) +
+            FfiConverterString.allocationSize(value.requestJsonSha256) +
+            FfiConverterString.allocationSize(value.configJsonSha256) +
+            FfiConverterUInt64.allocationSize(value.wasmByteLength) +
+            FfiConverterUInt64.allocationSize(value.requestJsonByteLength) +
+            FfiConverterUInt64.allocationSize(value.configJsonByteLength);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type ZkapProofOutput = {
+    /**
+     * Solidity-compatible proof components per credential: [ax, ay, bx_c1, bx_c0, by_c1, by_c0, cx, cy]
+     */
+    proofs: Array<Array<string>>,
+    sharedInputs: Array<string>,
+    partialRhsList: Array<string>,
+    jwtExpList: Array<string>
+}
+
+/**
+ * Generated factory for {@link ZkapProofOutput} record objects.
+ */
+export const ZkapProofOutput = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ZkapProofOutput, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ZkapProofOutput>,
+
+    });
+})();
+
+const FfiConverterTypeZkapProofOutput = (() => {
+    type TypeName = ZkapProofOutput;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                proofs: FfiConverterArrayArrayString.read(from),
+                sharedInputs: FfiConverterArrayString.read(from),
+                partialRhsList: FfiConverterArrayString.read(from),
+                jwtExpList: FfiConverterArrayString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterArrayArrayString.write(value.proofs, into);
+            FfiConverterArrayString.write(value.sharedInputs, into);
+            FfiConverterArrayString.write(value.partialRhsList, into);
+            FfiConverterArrayString.write(value.jwtExpList, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterArrayArrayString.allocationSize(value.proofs) +
+            FfiConverterArrayString.allocationSize(value.sharedInputs) +
+            FfiConverterArrayString.allocationSize(value.partialRhsList) +
+            FfiConverterArrayString.allocationSize(value.jwtExpList);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+/**
+ * Inputs for [`prove`].
+ *
+ * Replaces the legacy `pk_path` + flat per-credential vectors with
+ * the post-migration shape: caller points us at the manifest-validated
+ * CRS bundle directory, then supplies the [`crate::ProveRequest`]
+ * fields. Hanchor and audience-list hashes are computed internally
+ * from `anchor` and the credentials.
+ */
+export type ZkapProofRequest = {
+    /**
+     * Directory containing `manifest.json` + the CRS bundle. The
+     * manifest is sha256-validated by `ArtifactSet::load`; witness
+     * generation runs inside the release-provided `witness_gen.wasm`.
+     * `ar1cs_prove` always runs natively against the bundled proving key.
+     */
+    manifestDir: string,
+    /**
+     * Randomness salt — BN254 Fr (hex/decimal).
+     */
+    random: string,
+    /**
+     * Hash of the signed user-op payload — BN254 Fr (hex/decimal).
+     */
+    hSignUserOp: string,
+    /**
+     * Anchor polynomial evaluations (length = `config.n - config.k + 1`).
+     */
+    anchor: Array<string>,
+    /**
+     * Issuer-key Merkle tree root — BN254 Fr (hex/decimal).
+     */
+    merkleRoot: string,
+    /**
+     * One entry per JWT credential; length must equal `config.k`.
+     */
+    credentials: Array<ZkapProveCredential>
+}
+
+/**
+ * Generated factory for {@link ZkapProofRequest} record objects.
+ */
+export const ZkapProofRequest = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ZkapProofRequest, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ZkapProofRequest>,
+
+    });
+})();
+
+const FfiConverterTypeZkapProofRequest = (() => {
+    type TypeName = ZkapProofRequest;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                manifestDir: FfiConverterString.read(from),
+                random: FfiConverterString.read(from),
+                hSignUserOp: FfiConverterString.read(from),
+                anchor: FfiConverterArrayString.read(from),
+                merkleRoot: FfiConverterString.read(from),
+                credentials: FfiConverterArrayTypeZkapProveCredential.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.manifestDir, into);
+            FfiConverterString.write(value.random, into);
+            FfiConverterString.write(value.hSignUserOp, into);
+            FfiConverterArrayString.write(value.anchor, into);
+            FfiConverterString.write(value.merkleRoot, into);
+            FfiConverterArrayTypeZkapProveCredential.write(value.credentials, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.manifestDir) +
+            FfiConverterString.allocationSize(value.random) +
+            FfiConverterString.allocationSize(value.hSignUserOp) +
+            FfiConverterArrayString.allocationSize(value.anchor) +
+            FfiConverterString.allocationSize(value.merkleRoot) +
+            FfiConverterArrayTypeZkapProveCredential.allocationSize(value.credentials);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+/**
+ * Per-credential prove inputs (one per JWT participating in the batch).
+ */
+export type ZkapProveCredential = {
+    /**
+     * JWT compact serialization (`header.payload.signature`).
+     */
+    jwt: string,
+    /**
+     * Base64 of the 256-byte RSA-2048 modulus of the issuer key.
+     */
+    rsaModulusB64: string,
+    /**
+     * Merkle authentication path siblings — BN254 Fr hex/decimal.
+     */
+    merklePath: Array<string>,
+    /**
+     * Leaf index in the issuer-key Merkle tree.
+     */
+    merkleLeafIdx: /*u64*/bigint
+}
+
+/**
+ * Generated factory for {@link ZkapProveCredential} record objects.
+ */
+export const ZkapProveCredential = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ZkapProveCredential, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ZkapProveCredential>,
+
+    });
+})();
+
+const FfiConverterTypeZkapProveCredential = (() => {
+    type TypeName = ZkapProveCredential;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                jwt: FfiConverterString.read(from),
+                rsaModulusB64: FfiConverterString.read(from),
+                merklePath: FfiConverterArrayString.read(from),
+                merkleLeafIdx: FfiConverterUInt64.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.jwt, into);
+            FfiConverterString.write(value.rsaModulusB64, into);
+            FfiConverterArrayString.write(value.merklePath, into);
+            FfiConverterUInt64.write(value.merkleLeafIdx, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.jwt) +
+            FfiConverterString.allocationSize(value.rsaModulusB64) +
+            FfiConverterArrayString.allocationSize(value.merklePath) +
+            FfiConverterUInt64.allocationSize(value.merkleLeafIdx);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type ZkapSecret = {
+    sub: string,
+    iss: string,
+    aud: string
+}
+
+/**
+ * Generated factory for {@link ZkapSecret} record objects.
+ */
+export const ZkapSecret = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ZkapSecret, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ZkapSecret>,
+
+    });
+})();
+
+const FfiConverterTypeZkapSecret = (() => {
+    type TypeName = ZkapSecret;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                sub: FfiConverterString.read(from),
+                iss: FfiConverterString.read(from),
+                aud: FfiConverterString.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.sub, into);
+            FfiConverterString.write(value.iss, into);
+            FfiConverterString.write(value.aud, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.sub) +
+            FfiConverterString.allocationSize(value.iss) +
+            FfiConverterString.allocationSize(value.aud);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type ZkapWitnessBundleBytes = {
+    witnessBundlesBase64: string,
+    sha256: string,
+    byteLength: /*u64*/bigint
+}
+
+/**
+ * Generated factory for {@link ZkapWitnessBundleBytes} record objects.
+ */
+export const ZkapWitnessBundleBytes = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ZkapWitnessBundleBytes, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ZkapWitnessBundleBytes>,
+
+    });
+})();
+
+const FfiConverterTypeZkapWitnessBundleBytes = (() => {
+    type TypeName = ZkapWitnessBundleBytes;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                witnessBundlesBase64: FfiConverterString.read(from),
+                sha256: FfiConverterString.read(from),
+                byteLength: FfiConverterUInt64.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.witnessBundlesBase64, into);
+            FfiConverterString.write(value.sha256, into);
+            FfiConverterUInt64.write(value.byteLength, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.witnessBundlesBase64) +
+            FfiConverterString.allocationSize(value.sha256) +
+            FfiConverterUInt64.allocationSize(value.byteLength);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+export type ZkapWitnessBundleFile = {
+    witnessBundlePath: string,
+    sha256: string,
+    byteLength: /*u64*/bigint
+}
+
+/**
+ * Generated factory for {@link ZkapWitnessBundleFile} record objects.
+ */
+export const ZkapWitnessBundleFile = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ZkapWitnessBundleFile, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ZkapWitnessBundleFile>,
+
+    });
+})();
+
+const FfiConverterTypeZkapWitnessBundleFile = (() => {
+    type TypeName = ZkapWitnessBundleFile;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            return {
+                witnessBundlePath: FfiConverterString.read(from),
+                sha256: FfiConverterString.read(from),
+                byteLength: FfiConverterUInt64.read(from)
+            };
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            FfiConverterString.write(value.witnessBundlePath, into);
+            FfiConverterString.write(value.sha256, into);
+            FfiConverterUInt64.write(value.byteLength, into);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.witnessBundlePath) +
+            FfiConverterString.allocationSize(value.sha256) +
+            FfiConverterUInt64.allocationSize(value.byteLength);
+
+        }
+    };
+    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: ZkapError
+
+// Enum: ZkapError
+export enum ZkapError_Tags {
+    ApplicationError = "ApplicationError"
+}
+export const ZkapError = (() => {
+
+
+    type ApplicationError__interface = {
+        tag: ZkapError_Tags.ApplicationError;
+        inner: Readonly<{message: string}>
+    };
+
+
+    class ApplicationError_ extends UniffiError implements ApplicationError__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ZkapError";
+        readonly tag = ZkapError_Tags.ApplicationError;
+        readonly inner: Readonly<{message: string}>;
+        constructor(inner: { message: string }) {
+            super("ZkapError", "ApplicationError");
+            this.inner = Object.freeze(inner);
+        }
+
+        static new(inner: { message: string }): ApplicationError_ {
+            return new ApplicationError_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ApplicationError_ {
+            return obj.tag === ZkapError_Tags.ApplicationError;
+        }
+
+
+
+        static hasInner(obj: any): obj is ApplicationError_ {
+            return ApplicationError_.instanceOf(obj);
+        }
+
+        static getInner(obj: ApplicationError_): Readonly<{message: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is ZkapError {
+        return obj[uniffiTypeNameSymbol] === "ZkapError";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  ApplicationError: ApplicationError_
+    });
+
+})();
+
+
+
+export type ZkapError = InstanceType<
+    typeof ZkapError[keyof Omit<typeof ZkapError, 'instanceOf'>]
+>;
+
+// FfiConverter for enum ZkapError
+const FfiConverterTypeZkapError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    type TypeName = ZkapError;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        read(from: RustBuffer): TypeName {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new ZkapError.ApplicationError({message: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value: TypeName, into: RustBuffer): void {
+            switch (value.tag) {
+                case ZkapError_Tags.ApplicationError: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.message, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that ZkapError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case ZkapError_Tags.ApplicationError: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.message);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+
+// FfiConverter for Array<ZkapProveCredential>
+const FfiConverterArrayTypeZkapProveCredential = new FfiConverterArray(FfiConverterTypeZkapProveCredential);
+
+
+// FfiConverter for Array<ZkapSecret>
+const FfiConverterArrayTypeZkapSecret = new FfiConverterArray(FfiConverterTypeZkapSecret);
+
+
+// FfiConverter for Array<string>
+const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
+
+
+// FfiConverter for Array<Array<string>>
+const FfiConverterArrayArrayString = new FfiConverterArray(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_zkap_uniffi_bindings_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().ubrn_uniffi_zkap_uniffi_bindings_checksum_func_generate_anchor() !== 10088) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_zkap_uniffi_bindings_checksum_func_generate_anchor");
+    }
+    if (nativeModule().ubrn_uniffi_zkap_uniffi_bindings_checksum_func_generate_aud_hash() !== 42467) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_zkap_uniffi_bindings_checksum_func_generate_aud_hash");
+    }
+    if (nativeModule().ubrn_uniffi_zkap_uniffi_bindings_checksum_func_generate_hash() !== 6188) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_zkap_uniffi_bindings_checksum_func_generate_hash");
+    }
+    if (nativeModule().ubrn_uniffi_zkap_uniffi_bindings_checksum_func_generate_leaf_hash() !== 28430) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_zkap_uniffi_bindings_checksum_func_generate_leaf_hash");
+    }
+    if (nativeModule().ubrn_uniffi_zkap_uniffi_bindings_checksum_func_prepare_witness_inputs() !== 50971) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_zkap_uniffi_bindings_checksum_func_prepare_witness_inputs");
+    }
+    if (nativeModule().ubrn_uniffi_zkap_uniffi_bindings_checksum_func_prove() !== 35511) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_zkap_uniffi_bindings_checksum_func_prove");
+    }
+    if (nativeModule().ubrn_uniffi_zkap_uniffi_bindings_checksum_func_prove_from_witness_bundle_file() !== 12913) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_zkap_uniffi_bindings_checksum_func_prove_from_witness_bundle_file");
+    }
+    if (nativeModule().ubrn_uniffi_zkap_uniffi_bindings_checksum_func_prove_from_witness_bundles() !== 37306) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_zkap_uniffi_bindings_checksum_func_prove_from_witness_bundles");
+    }
+
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeZkapAnchorResult,
+    FfiConverterTypeZkapAudHashResult,
+    FfiConverterTypeZkapCircuitConfig,
+    FfiConverterTypeZkapError,
+    FfiConverterTypeZkapPreparedWitnessInputs,
+    FfiConverterTypeZkapProofOutput,
+    FfiConverterTypeZkapProofRequest,
+    FfiConverterTypeZkapProveCredential,
+    FfiConverterTypeZkapSecret,
+    FfiConverterTypeZkapWitnessBundleBytes,
+    FfiConverterTypeZkapWitnessBundleFile,
+  }
+});