@succinctlabs/react-native-zcam1 0.2.5

package/src/generated/zcam1_proving_utils.ts

@@ -0,0 +1,804 @@
+// 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!
+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,
+  type UniffiVTableCallbackInterfaceInitialized,
+} from "./zcam1_proving_utils-ffi";
+import {
+  type FfiConverter,
+  type UniffiByteArray,
+  type UniffiHandle,
+  type UniffiObjectFactory,
+  type UniffiReferenceHolder,
+  type UniffiRustArcPtr,
+  type UniffiRustCallStatus,
+  type UnsafeMutableRawPointer,
+  AbstractFfiConverterByteArray,
+  FfiConverterArrayBuffer,
+  FfiConverterBool,
+  FfiConverterCallback,
+  FfiConverterInt32,
+  FfiConverterObject,
+  FfiConverterOptional,
+  FfiConverterUInt64,
+  RustBuffer,
+  UniffiAbstractObject,
+  UniffiError,
+  UniffiInternalError,
+  UniffiResult,
+  UniffiRustCaller,
+  destructorGuardSymbol,
+  pointerLiteralSymbol,
+  uniffiCreateFfiConverterString,
+  uniffiCreateRecord,
+  uniffiRustCallAsync,
+  uniffiTraitInterfaceCall,
+  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 interface Initialized {
+  initialized(): void;
+}
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceInitialized: {
+  vtable: UniffiVTableCallbackInterfaceInitialized;
+  register: () => void;
+} = {
+  // Create the VTable using a series of closures.
+  // ts automatically converts these into C callback functions.
+  vtable: {
+    initialized: (uniffiHandle: bigint) => {
+      const uniffiMakeCall = (): void => {
+        const jsCallback = FfiConverterTypeInitialized.lift(uniffiHandle);
+        return jsCallback.initialized();
+      };
+      const uniffiResult = UniffiResult.ready<void>();
+      const uniffiHandleSuccess = (obj: any) => {};
+      const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCall(
+        /*makeCall:*/ uniffiMakeCall,
+        /*handleSuccess:*/ uniffiHandleSuccess,
+        /*handleError:*/ uniffiHandleError,
+        /*lowerString:*/ FfiConverterString.lower,
+      );
+      return uniffiResult;
+    },
+    uniffiFree: (uniffiHandle: UniffiHandle): void => {
+      // Initialized: this will throw a stale handle error if the handle isn't found.
+      FfiConverterTypeInitialized.drop(uniffiHandle);
+    },
+  },
+  register: () => {
+    nativeModule().ubrn_uniffi_zcam1_proving_utils_fn_init_callback_vtable_initialized(
+      uniffiCallbackInterfaceInitialized.vtable,
+    );
+  },
+};
+
+// FfiConverter protocol for callback interfaces
+const FfiConverterTypeInitialized = new FfiConverterCallback<Initialized>();
+
+export type IosProofRequestInputs = {
+  appAttestProduction: boolean;
+};
+
+/**
+ * Generated factory for {@link IosProofRequestInputs} record objects.
+ */
+export const IosProofRequestInputs = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<IosProofRequestInputs, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link IosProofRequestInputs}, with defaults specified
+     * in Rust, in the {@link zcam1_proving_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link IosProofRequestInputs}, with defaults specified
+     * in Rust, in the {@link zcam1_proving_utils} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link zcam1_proving_utils} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<IosProofRequestInputs>,
+  });
+})();
+
+const FfiConverterTypeIosProofRequestInputs = (() => {
+  type TypeName = IosProofRequestInputs;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        appAttestProduction: FfiConverterBool.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterBool.write(value.appAttestProduction, into);
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterBool.allocationSize(value.appAttestProduction);
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type ProofRequestStatus = {
+  fulfillmentStatus: FulfillmentStatus;
+  proof: ArrayBuffer | undefined;
+};
+
+/**
+ * Generated factory for {@link ProofRequestStatus} record objects.
+ */
+export const ProofRequestStatus = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ProofRequestStatus, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ProofRequestStatus}, with defaults specified
+     * in Rust, in the {@link zcam1_proving_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link ProofRequestStatus}, with defaults specified
+     * in Rust, in the {@link zcam1_proving_utils} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link zcam1_proving_utils} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<ProofRequestStatus>,
+  });
+})();
+
+const FfiConverterTypeProofRequestStatus = (() => {
+  type TypeName = ProofRequestStatus;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        fulfillmentStatus: FfiConverterTypeFulfillmentStatus.read(from),
+        proof: FfiConverterOptionalArrayBuffer.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypeFulfillmentStatus.write(value.fulfillmentStatus, into);
+      FfiConverterOptionalArrayBuffer.write(value.proof, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypeFulfillmentStatus.allocationSize(value.fulfillmentStatus) +
+        FfiConverterOptionalArrayBuffer.allocationSize(value.proof)
+      );
+    }
+  }
+  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);
+
+// Flat error type: Exception
+export enum Exception_Tags {
+  ProverNotInitialized = "ProverNotInitialized",
+  FailedToParseProofRequestId = "FailedToParseProofRequestId",
+  Io = "Io",
+  Sp1 = "Sp1",
+}
+export const Exception = (() => {
+  class ProverNotInitialized extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "Exception";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 1;
+
+    public readonly tag = Exception_Tags.ProverNotInitialized;
+
+    constructor(message: string) {
+      super("Exception", "ProverNotInitialized", message);
+    }
+
+    static instanceOf(e: any): e is ProverNotInitialized {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 1;
+    }
+  }
+  class FailedToParseProofRequestId extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "Exception";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 2;
+
+    public readonly tag = Exception_Tags.FailedToParseProofRequestId;
+
+    constructor(message: string) {
+      super("Exception", "FailedToParseProofRequestId", message);
+    }
+
+    static instanceOf(e: any): e is FailedToParseProofRequestId {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 2;
+    }
+  }
+  class Io extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "Exception";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 3;
+
+    public readonly tag = Exception_Tags.Io;
+
+    constructor(message: string) {
+      super("Exception", "Io", message);
+    }
+
+    static instanceOf(e: any): e is Io {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 3;
+    }
+  }
+  class Sp1 extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "Exception";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 4;
+
+    public readonly tag = Exception_Tags.Sp1;
+
+    constructor(message: string) {
+      super("Exception", "Sp1", message);
+    }
+
+    static instanceOf(e: any): e is Sp1 {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 4;
+    }
+  }
+
+  // Utility function which does not rely on instanceof.
+  function instanceOf(e: any): e is Exception {
+    return (e as any)[uniffiTypeNameSymbol] === "Exception";
+  }
+  return {
+    ProverNotInitialized,
+    FailedToParseProofRequestId,
+    Io,
+    Sp1,
+    instanceOf,
+  };
+})();
+
+// Union type for Exception error type.
+
+export type Exception = InstanceType<
+  (typeof Exception)[keyof Omit<typeof Exception, "instanceOf">]
+>;
+
+const FfiConverterTypeError = (() => {
+  const intConverter = FfiConverterInt32;
+  type TypeName = Exception;
+  class FfiConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (intConverter.read(from)) {
+        case 1:
+          return new Exception.ProverNotInitialized(FfiConverterString.read(from));
+
+        case 2:
+          return new Exception.FailedToParseProofRequestId(FfiConverterString.read(from));
+
+        case 3:
+          return new Exception.Io(FfiConverterString.read(from));
+
+        case 4:
+          return new Exception.Sp1(FfiConverterString.read(from));
+
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      const obj = value as any;
+      const index = obj[variantOrdinalSymbol] as number;
+      intConverter.write(index, into);
+    }
+    allocationSize(value: TypeName): number {
+      return intConverter.allocationSize(0);
+    }
+  }
+  return new FfiConverter();
+})();
+
+export enum FulfillmentStatus {
+  UnspecifiedFulfillmentStatus,
+  Requested,
+  Assigned,
+  Fulfilled,
+  Unfulfillable,
+}
+
+const FfiConverterTypeFulfillmentStatus = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = FulfillmentStatus;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return FulfillmentStatus.UnspecifiedFulfillmentStatus;
+        case 2:
+          return FulfillmentStatus.Requested;
+        case 3:
+          return FulfillmentStatus.Assigned;
+        case 4:
+          return FulfillmentStatus.Fulfilled;
+        case 5:
+          return FulfillmentStatus.Unfulfillable;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case FulfillmentStatus.UnspecifiedFulfillmentStatus:
+          return ordinalConverter.write(1, into);
+        case FulfillmentStatus.Requested:
+          return ordinalConverter.write(2, into);
+        case FulfillmentStatus.Assigned:
+          return ordinalConverter.write(3, into);
+        case FulfillmentStatus.Fulfilled:
+          return ordinalConverter.write(4, into);
+        case FulfillmentStatus.Unfulfillable:
+          return ordinalConverter.write(5, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Selects which prover network to connect to.
+ */
+export enum ProverNetworkMode {
+  /**
+   * Mainnet network using auction-based proving.
+   */
+  Mainnet,
+  /**
+   * Reserved capacity network for hosted/reserved proving.
+   */
+  Reserved,
+}
+
+const FfiConverterTypeProverNetworkMode = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = ProverNetworkMode;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return ProverNetworkMode.Mainnet;
+        case 2:
+          return ProverNetworkMode.Reserved;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case ProverNetworkMode.Mainnet:
+          return ordinalConverter.write(1, into);
+        case ProverNetworkMode.Reserved:
+          return ordinalConverter.write(2, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+export interface IosProvingClientInterface {
+  getProofStatus(
+    requestId: string,
+    asyncOpts_?: { signal: AbortSignal },
+  ) /*throws*/ : Promise<ProofRequestStatus>;
+  requestProof(
+    filePath: string,
+    format: string,
+    inputs: IosProofRequestInputs,
+    asyncOpts_?: { signal: AbortSignal },
+  ) /*throws*/ : Promise<string>;
+  vkHash() /*throws*/ : string;
+}
+
+export class IosProvingClient extends UniffiAbstractObject implements IosProvingClientInterface {
+  readonly [uniffiTypeNameSymbol] = "IosProvingClient";
+  readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+  constructor(
+    privateKey: string,
+    callback: Initialized | undefined = undefined,
+    networkMode: ProverNetworkMode | undefined,
+  ) {
+    super();
+    const pointer = uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_zcam1_proving_utils_fn_constructor_iosprovingclient_new(
+          FfiConverterString.lower(privateKey),
+          FfiConverterOptionalTypeInitialized.lower(callback),
+          FfiConverterOptionalTypeProverNetworkMode.lower(networkMode),
+          callStatus,
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    );
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeIosProvingClientObjectFactory.bless(pointer);
+  }
+
+  public static mock(callback: Initialized | undefined = undefined): IosProvingClientInterface {
+    return FfiConverterTypeIosProvingClient.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_zcam1_proving_utils_fn_constructor_iosprovingclient_mock(
+            FfiConverterOptionalTypeInitialized.lower(callback),
+            callStatus,
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift,
+      ),
+    );
+  }
+
+  public async getProofStatus(
+    requestId: string,
+    asyncOpts_?: { signal: AbortSignal },
+  ): Promise<ProofRequestStatus> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_zcam1_proving_utils_fn_method_iosprovingclient_get_proof_status(
+            uniffiTypeIosProvingClientObjectFactory.clonePointer(this),
+            FfiConverterString.lower(requestId),
+          );
+        },
+        /*pollFunc:*/ nativeModule().ubrn_ffi_zcam1_proving_utils_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule().ubrn_ffi_zcam1_proving_utils_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_zcam1_proving_utils_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule().ubrn_ffi_zcam1_proving_utils_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterTypeProofRequestStatus.lift.bind(
+          FfiConverterTypeProofRequestStatus,
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError),
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
+  public async requestProof(
+    filePath: string,
+    format: string,
+    inputs: IosProofRequestInputs,
+    asyncOpts_?: { signal: AbortSignal },
+  ): Promise<string> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_zcam1_proving_utils_fn_method_iosprovingclient_request_proof(
+            uniffiTypeIosProvingClientObjectFactory.clonePointer(this),
+            FfiConverterString.lower(filePath),
+            FfiConverterString.lower(format),
+            FfiConverterTypeIosProofRequestInputs.lower(inputs),
+          );
+        },
+        /*pollFunc:*/ nativeModule().ubrn_ffi_zcam1_proving_utils_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule().ubrn_ffi_zcam1_proving_utils_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_zcam1_proving_utils_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule().ubrn_ffi_zcam1_proving_utils_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterString.lift.bind(FfiConverterString),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError),
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
+  public vkHash(): string /*throws*/ {
+    return FfiConverterString.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_zcam1_proving_utils_fn_method_iosprovingclient_vk_hash(
+            uniffiTypeIosProvingClientObjectFactory.clonePointer(this),
+            callStatus,
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift,
+      ),
+    );
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeIosProvingClientObjectFactory.pointer(this);
+      uniffiTypeIosProvingClientObjectFactory.freePointer(pointer);
+      uniffiTypeIosProvingClientObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj: any): obj is IosProvingClient {
+    return uniffiTypeIosProvingClientObjectFactory.isConcreteType(obj);
+  }
+}
+
+const uniffiTypeIosProvingClientObjectFactory: UniffiObjectFactory<IosProvingClientInterface> =
+  (() => {
+    return {
+      create(pointer: UnsafeMutableRawPointer): IosProvingClientInterface {
+        const instance = Object.create(IosProvingClient.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "IosProvingClient";
+        return instance;
+      },
+
+      bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
+        return uniffiCaller.rustCall(
+          /*caller:*/ (status) =>
+            nativeModule().ubrn_uniffi_internal_fn_method_iosprovingclient_ffi__bless_pointer(
+              p,
+              status,
+            ),
+          /*liftString:*/ FfiConverterString.lift,
+        );
+      },
+
+      unbless(ptr: UniffiRustArcPtr) {
+        ptr.markDestroyed();
+      },
+
+      pointer(obj: IosProvingClientInterface): UnsafeMutableRawPointer {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+          throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+      },
+
+      clonePointer(obj: IosProvingClientInterface): UnsafeMutableRawPointer {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_zcam1_proving_utils_fn_clone_iosprovingclient(
+              pointer,
+              callStatus,
+            ),
+          /*liftString:*/ FfiConverterString.lift,
+        );
+      },
+
+      freePointer(pointer: UnsafeMutableRawPointer): void {
+        uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_zcam1_proving_utils_fn_free_iosprovingclient(
+              pointer,
+              callStatus,
+            ),
+          /*liftString:*/ FfiConverterString.lift,
+        );
+      },
+
+      isConcreteType(obj: any): obj is IosProvingClientInterface {
+        return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "IosProvingClient";
+      },
+    };
+  })();
+// FfiConverter for IosProvingClientInterface
+const FfiConverterTypeIosProvingClient = new FfiConverterObject(
+  uniffiTypeIosProvingClientObjectFactory,
+);
+
+// FfiConverter for ArrayBuffer | undefined
+const FfiConverterOptionalArrayBuffer = new FfiConverterOptional(FfiConverterArrayBuffer);
+
+// FfiConverter for Initialized | undefined
+const FfiConverterOptionalTypeInitialized = new FfiConverterOptional(FfiConverterTypeInitialized);
+
+// FfiConverter for ProverNetworkMode | undefined
+const FfiConverterOptionalTypeProverNetworkMode = new FfiConverterOptional(
+  FfiConverterTypeProverNetworkMode,
+);
+
+/**
+ * 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 = 29;
+  // Get the scaffolding contract version by calling the into the dylib
+  const scaffoldingContractVersion =
+    nativeModule().ubrn_ffi_zcam1_proving_utils_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(
+      scaffoldingContractVersion,
+      bindingsContractVersion,
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_proving_utils_checksum_method_iosprovingclient_get_proof_status() !==
+    21814
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_proving_utils_checksum_method_iosprovingclient_get_proof_status",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_proving_utils_checksum_method_iosprovingclient_request_proof() !==
+    27732
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_proving_utils_checksum_method_iosprovingclient_request_proof",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_proving_utils_checksum_method_iosprovingclient_vk_hash() !==
+    9850
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_proving_utils_checksum_method_iosprovingclient_vk_hash",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_proving_utils_checksum_constructor_iosprovingclient_mock() !==
+    63763
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_proving_utils_checksum_constructor_iosprovingclient_mock",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_proving_utils_checksum_constructor_iosprovingclient_new() !==
+    16631
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_proving_utils_checksum_constructor_iosprovingclient_new",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_proving_utils_checksum_method_initialized_initialized() !==
+    19597
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_proving_utils_checksum_method_initialized_initialized",
+    );
+  }
+
+  uniffiCallbackInterfaceInitialized.register();
+}
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeError,
+    FfiConverterTypeFulfillmentStatus,
+    FfiConverterTypeIosProofRequestInputs,
+    FfiConverterTypeIosProvingClient,
+    FfiConverterTypeProofRequestStatus,
+    FfiConverterTypeProverNetworkMode,
+  },
+});