@succinctlabs/react-native-zcam1 0.2.5

package/src/generated/zcam1_verify_utils-ffi.ts

@@ -0,0 +1,196 @@
+// 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 {
+  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_zcam1_verify_utils_fn_func_verify_bindings_from_manifest(
+    bindings: Uint8Array,
+    normalizedMetadata: Uint8Array,
+    photoHash: Uint8Array,
+    production: number,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_uniffi_zcam1_verify_utils_fn_func_verify_groth16(
+    proof: Uint8Array,
+    publicInputs: Uint8Array,
+    sp1VkHash: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_uniffi_zcam1_verify_utils_checksum_func_verify_bindings_from_manifest(): number;
+  ubrn_uniffi_zcam1_verify_utils_checksum_func_verify_groth16(): number;
+  ubrn_ffi_zcam1_verify_utils_uniffi_contract_version(): number;
+}
+
+// Casting globalThis to any allows us to look for `NativeZcam1VerifyUtils`
+// if it was added via JSI.
+//
+// We use a getter here rather than simply `globalThis.NativeZcam1VerifyUtils` so that
+// if/when the startup sequence isn't just so, an empty value isn't inadvertantly cached.
+const getter: () => NativeModuleInterface = () => (globalThis as any).NativeZcam1VerifyUtils;
+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/zcam1_verify_utils.ts

@@ -0,0 +1,372 @@
+// 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,
+} from "./zcam1_verify_utils-ffi";
+import { type DeviceBindings } from "./zcam1_c2pa_utils";
+import {
+  type UniffiByteArray,
+  AbstractFfiConverterByteArray,
+  FfiConverterArrayBuffer,
+  FfiConverterBool,
+  FfiConverterInt32,
+  RustBuffer,
+  UniffiError,
+  UniffiInternalError,
+  UniffiRustCaller,
+  uniffiCreateFfiConverterString,
+  uniffiTypeNameSymbol,
+  variantOrdinalSymbol,
+} from "uniffi-bindgen-react-native";
+
+// Get converters from the other files, if any.
+import uniffiZcam1C2paUtilsModule from "./zcam1_c2pa_utils";
+const { FfiConverterTypeDeviceBindings } = uniffiZcam1C2paUtilsModule.converters;
+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 verifyBindingsFromManifest(
+  bindings: DeviceBindings,
+  normalizedMetadata: string,
+  photoHash: ArrayBuffer,
+  production: boolean,
+): boolean /*throws*/ {
+  return FfiConverterBool.lift(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeVerifyError.lift.bind(FfiConverterTypeVerifyError),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_zcam1_verify_utils_fn_func_verify_bindings_from_manifest(
+          FfiConverterTypeDeviceBindings.lower(bindings),
+          FfiConverterString.lower(normalizedMetadata),
+          FfiConverterArrayBuffer.lower(photoHash),
+          FfiConverterBool.lower(production),
+          callStatus,
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    ),
+  );
+}
+/**
+ * Wrapper around [`sp1_verifier::Groth16Verifier::verify`].
+ *
+ * We hardcode the Groth16 VK bytes to only verify SP1 proofs.
+ */
+export function verifyGroth16(
+  proof: ArrayBuffer,
+  publicInputs: ArrayBuffer,
+  sp1VkHash: string,
+): boolean /*throws*/ {
+  return FfiConverterBool.lift(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeVerifyError.lift.bind(FfiConverterTypeVerifyError),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_zcam1_verify_utils_fn_func_verify_groth16(
+          FfiConverterArrayBuffer.lower(proof),
+          FfiConverterArrayBuffer.lower(publicInputs),
+          FfiConverterString.lower(sp1VkHash),
+          callStatus,
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    ),
+  );
+}
+
+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: VerifyError
+export enum VerifyError_Tags {
+  C2pa = "C2pa",
+  AppAttest = "AppAttest",
+  Base64 = "Base64",
+  Io = "Io",
+  Groth16 = "Groth16",
+  ProofNotFound = "ProofNotFound",
+}
+export const VerifyError = (() => {
+  class C2pa extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "VerifyError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 1;
+
+    public readonly tag = VerifyError_Tags.C2pa;
+
+    constructor(message: string) {
+      super("VerifyError", "C2pa", message);
+    }
+
+    static instanceOf(e: any): e is C2pa {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 1;
+    }
+  }
+  class AppAttest extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "VerifyError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 2;
+
+    public readonly tag = VerifyError_Tags.AppAttest;
+
+    constructor(message: string) {
+      super("VerifyError", "AppAttest", message);
+    }
+
+    static instanceOf(e: any): e is AppAttest {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 2;
+    }
+  }
+  class Base64 extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "VerifyError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 3;
+
+    public readonly tag = VerifyError_Tags.Base64;
+
+    constructor(message: string) {
+      super("VerifyError", "Base64", message);
+    }
+
+    static instanceOf(e: any): e is Base64 {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 3;
+    }
+  }
+  class Io extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "VerifyError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 4;
+
+    public readonly tag = VerifyError_Tags.Io;
+
+    constructor(message: string) {
+      super("VerifyError", "Io", message);
+    }
+
+    static instanceOf(e: any): e is Io {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 4;
+    }
+  }
+  class Groth16 extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "VerifyError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 5;
+
+    public readonly tag = VerifyError_Tags.Groth16;
+
+    constructor(message: string) {
+      super("VerifyError", "Groth16", message);
+    }
+
+    static instanceOf(e: any): e is Groth16 {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 5;
+    }
+  }
+  class ProofNotFound extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "VerifyError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 6;
+
+    public readonly tag = VerifyError_Tags.ProofNotFound;
+
+    constructor(message: string) {
+      super("VerifyError", "ProofNotFound", message);
+    }
+
+    static instanceOf(e: any): e is ProofNotFound {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 6;
+    }
+  }
+
+  // Utility function which does not rely on instanceof.
+  function instanceOf(e: any): e is VerifyError {
+    return (e as any)[uniffiTypeNameSymbol] === "VerifyError";
+  }
+  return {
+    C2pa,
+    AppAttest,
+    Base64,
+    Io,
+    Groth16,
+    ProofNotFound,
+    instanceOf,
+  };
+})();
+
+// Union type for VerifyError error type.
+
+export type VerifyError = InstanceType<
+  (typeof VerifyError)[keyof Omit<typeof VerifyError, "instanceOf">]
+>;
+
+const FfiConverterTypeVerifyError = (() => {
+  const intConverter = FfiConverterInt32;
+  type TypeName = VerifyError;
+  class FfiConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (intConverter.read(from)) {
+        case 1:
+          return new VerifyError.C2pa(FfiConverterString.read(from));
+
+        case 2:
+          return new VerifyError.AppAttest(FfiConverterString.read(from));
+
+        case 3:
+          return new VerifyError.Base64(FfiConverterString.read(from));
+
+        case 4:
+          return new VerifyError.Io(FfiConverterString.read(from));
+
+        case 5:
+          return new VerifyError.Groth16(FfiConverterString.read(from));
+
+        case 6:
+          return new VerifyError.ProofNotFound(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();
+})();
+
+/**
+ * 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_verify_utils_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(
+      scaffoldingContractVersion,
+      bindingsContractVersion,
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_verify_utils_checksum_func_verify_bindings_from_manifest() !==
+    62750
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_verify_utils_checksum_func_verify_bindings_from_manifest",
+    );
+  }
+  if (nativeModule().ubrn_uniffi_zcam1_verify_utils_checksum_func_verify_groth16() !== 13082) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_verify_utils_checksum_func_verify_groth16",
+    );
+  }
+}
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeVerifyError,
+  },
+});

package/src/index.ts

@@ -0,0 +1,73 @@
+export type {
+  ManifestEditorInterface,
+  ManifestInterface,
+  ManifestStoreInterface,
+} from "./bindings";
+export {
+  AuthenticityData,
+  AuthenticityStatus,
+  authenticityStatus,
+  buildSelfSignedCertificate,
+  C2paError,
+  C2paError_Tags,
+  Claim,
+  computeHash,
+  computeHashFromBuffer,
+  DepthData,
+  DepthDataStatistics,
+  DeviceBindings,
+  Exclusion,
+  extractManifest,
+  FilmStyleInfo,
+  formatFromPath,
+  Manifest,
+  ManifestEditor,
+  ManifestStore,
+  PhotoMetadataInfo,
+  Proof,
+  SelfSignedCertChain,
+  VerifyError,
+  VerifyError_Tags,
+  VideoMetadataInfo,
+} from "./bindings";
+
+/**
+ * Camera component for capturing photos with secure enclave integration.
+ */
+export type {
+  CameraFilmStyle,
+  CaptureFormat,
+  FilmStyleEffect,
+  FilmStyleRecipe,
+  HighlightShadowConfig,
+  MonochromeConfig,
+  TakePhotoOptions,
+  WhiteBalanceConfig,
+  ZCameraProps,
+} from "./camera";
+export { ZCamera } from "./camera";
+export type { CaptureInfo, DeviceOrientation } from "./capture";
+export { initCapture } from "./capture";
+
+/**
+ * Core cryptographic key types and secure enclave utilities.
+ */
+export type { ECKey } from "./common";
+export { getContentPublicKey, getSecureEnclaveKeyId } from "./common";
+export type { PhotoGallery, PrivateFolder, ZImagePickerProps } from "./picker";
+
+/**
+ * Image picker and private directory utilities for secure media selection.\
+ */
+export { privateDirectory, ZImagePicker } from "./picker";
+
+/**
+* Verification utilities for validating media authenticity and capture metadata.
+
+ */
+export { type CaptureMetadata, VerifiableFile } from "./verify";
+
+/**
+ * Flash mode for photo capture.
+ */
+export { type FlashMode } from "./NativeZcam1Capture";