@fedimint/react-native-bindings 0.0.0-om-rn1-d72fdc108a01df2d7d64c2b85c8b1f9fd43927cb

package/src/generated/fedimint_client_uniffi.ts

@@ -0,0 +1,651 @@
+// 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 UniffiVTableCallbackInterfaceRpcCallback,
+} from './fedimint_client_uniffi-ffi'
+import {
+  type FfiConverter,
+  type UniffiByteArray,
+  type UniffiHandle,
+  type UniffiObjectFactory,
+  type UniffiReferenceHolder,
+  type UniffiRustArcPtr,
+  type UniffiRustCallStatus,
+  type UnsafeMutableRawPointer,
+  AbstractFfiConverterByteArray,
+  FfiConverterCallback,
+  FfiConverterInt32,
+  FfiConverterObject,
+  FfiConverterUInt64,
+  RustBuffer,
+  UniffiAbstractObject,
+  UniffiError,
+  UniffiInternalError,
+  UniffiResult,
+  UniffiRustCaller,
+  destructorGuardSymbol,
+  pointerLiteralSymbol,
+  uniffiCreateFfiConverterString,
+  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 RpcCallback {
+  onResponse(responseJson: string): void
+}
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceRpcCallback: {
+  vtable: UniffiVTableCallbackInterfaceRpcCallback
+  register: () => void
+} = {
+  // Create the VTable using a series of closures.
+  // ts automatically converts these into C callback functions.
+  vtable: {
+    onResponse: (uniffiHandle: bigint, responseJson: Uint8Array) => {
+      const uniffiMakeCall = (): void => {
+        const jsCallback = FfiConverterTypeRpcCallback.lift(uniffiHandle)
+        return jsCallback.onResponse(FfiConverterString.lift(responseJson))
+      }
+      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 => {
+      // RpcCallback: this will throw a stale handle error if the handle isn't found.
+      FfiConverterTypeRpcCallback.drop(uniffiHandle)
+    },
+  },
+  register: () => {
+    nativeModule().ubrn_uniffi_fedimint_client_uniffi_fn_init_callback_vtable_rpccallback(
+      uniffiCallbackInterfaceRpcCallback.vtable,
+    )
+  },
+}
+
+// FfiConverter protocol for callback interfaces
+const FfiConverterTypeRpcCallback = new FfiConverterCallback<RpcCallback>()
+
+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: FedimintError
+
+// Enum: FedimintError
+export enum FedimintError_Tags {
+  DatabaseError = 'DatabaseError',
+  NetworkingError = 'NetworkingError',
+  RuntimeError = 'RuntimeError',
+  InvalidRequest = 'InvalidRequest',
+  General = 'General',
+}
+export const FedimintError = (() => {
+  type DatabaseError__interface = {
+    tag: FedimintError_Tags.DatabaseError
+    inner: Readonly<{ msg: string }>
+  }
+
+  class DatabaseError_ extends UniffiError implements DatabaseError__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'FedimintError'
+    readonly tag = FedimintError_Tags.DatabaseError
+    readonly inner: Readonly<{ msg: string }>
+    constructor(inner: { msg: string }) {
+      super('FedimintError', 'DatabaseError')
+      this.inner = Object.freeze(inner)
+    }
+
+    static new(inner: { msg: string }): DatabaseError_ {
+      return new DatabaseError_(inner)
+    }
+
+    static instanceOf(obj: any): obj is DatabaseError_ {
+      return obj.tag === FedimintError_Tags.DatabaseError
+    }
+
+    static hasInner(obj: any): obj is DatabaseError_ {
+      return DatabaseError_.instanceOf(obj)
+    }
+
+    static getInner(obj: DatabaseError_): Readonly<{ msg: string }> {
+      return obj.inner
+    }
+  }
+
+  type NetworkingError__interface = {
+    tag: FedimintError_Tags.NetworkingError
+    inner: Readonly<{ msg: string }>
+  }
+
+  class NetworkingError_
+    extends UniffiError
+    implements NetworkingError__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'FedimintError'
+    readonly tag = FedimintError_Tags.NetworkingError
+    readonly inner: Readonly<{ msg: string }>
+    constructor(inner: { msg: string }) {
+      super('FedimintError', 'NetworkingError')
+      this.inner = Object.freeze(inner)
+    }
+
+    static new(inner: { msg: string }): NetworkingError_ {
+      return new NetworkingError_(inner)
+    }
+
+    static instanceOf(obj: any): obj is NetworkingError_ {
+      return obj.tag === FedimintError_Tags.NetworkingError
+    }
+
+    static hasInner(obj: any): obj is NetworkingError_ {
+      return NetworkingError_.instanceOf(obj)
+    }
+
+    static getInner(obj: NetworkingError_): Readonly<{ msg: string }> {
+      return obj.inner
+    }
+  }
+
+  type RuntimeError__interface = {
+    tag: FedimintError_Tags.RuntimeError
+    inner: Readonly<{ msg: string }>
+  }
+
+  class RuntimeError_ extends UniffiError implements RuntimeError__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'FedimintError'
+    readonly tag = FedimintError_Tags.RuntimeError
+    readonly inner: Readonly<{ msg: string }>
+    constructor(inner: { msg: string }) {
+      super('FedimintError', 'RuntimeError')
+      this.inner = Object.freeze(inner)
+    }
+
+    static new(inner: { msg: string }): RuntimeError_ {
+      return new RuntimeError_(inner)
+    }
+
+    static instanceOf(obj: any): obj is RuntimeError_ {
+      return obj.tag === FedimintError_Tags.RuntimeError
+    }
+
+    static hasInner(obj: any): obj is RuntimeError_ {
+      return RuntimeError_.instanceOf(obj)
+    }
+
+    static getInner(obj: RuntimeError_): Readonly<{ msg: string }> {
+      return obj.inner
+    }
+  }
+
+  type InvalidRequest__interface = {
+    tag: FedimintError_Tags.InvalidRequest
+    inner: Readonly<{ msg: string }>
+  }
+
+  class InvalidRequest_
+    extends UniffiError
+    implements InvalidRequest__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'FedimintError'
+    readonly tag = FedimintError_Tags.InvalidRequest
+    readonly inner: Readonly<{ msg: string }>
+    constructor(inner: { msg: string }) {
+      super('FedimintError', 'InvalidRequest')
+      this.inner = Object.freeze(inner)
+    }
+
+    static new(inner: { msg: string }): InvalidRequest_ {
+      return new InvalidRequest_(inner)
+    }
+
+    static instanceOf(obj: any): obj is InvalidRequest_ {
+      return obj.tag === FedimintError_Tags.InvalidRequest
+    }
+
+    static hasInner(obj: any): obj is InvalidRequest_ {
+      return InvalidRequest_.instanceOf(obj)
+    }
+
+    static getInner(obj: InvalidRequest_): Readonly<{ msg: string }> {
+      return obj.inner
+    }
+  }
+
+  type General__interface = {
+    tag: FedimintError_Tags.General
+    inner: Readonly<{ msg: string }>
+  }
+
+  class General_ extends UniffiError implements General__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'FedimintError'
+    readonly tag = FedimintError_Tags.General
+    readonly inner: Readonly<{ msg: string }>
+    constructor(inner: { msg: string }) {
+      super('FedimintError', 'General')
+      this.inner = Object.freeze(inner)
+    }
+
+    static new(inner: { msg: string }): General_ {
+      return new General_(inner)
+    }
+
+    static instanceOf(obj: any): obj is General_ {
+      return obj.tag === FedimintError_Tags.General
+    }
+
+    static hasInner(obj: any): obj is General_ {
+      return General_.instanceOf(obj)
+    }
+
+    static getInner(obj: General_): Readonly<{ msg: string }> {
+      return obj.inner
+    }
+  }
+
+  function instanceOf(obj: any): obj is FedimintError {
+    return obj[uniffiTypeNameSymbol] === 'FedimintError'
+  }
+
+  return Object.freeze({
+    instanceOf,
+    DatabaseError: DatabaseError_,
+    NetworkingError: NetworkingError_,
+    RuntimeError: RuntimeError_,
+    InvalidRequest: InvalidRequest_,
+    General: General_,
+  })
+})()
+
+export type FedimintError = InstanceType<
+  (typeof FedimintError)[keyof Omit<typeof FedimintError, 'instanceOf'>]
+>
+
+// FfiConverter for enum FedimintError
+const FfiConverterTypeFedimintError = (() => {
+  const ordinalConverter = FfiConverterInt32
+  type TypeName = FedimintError
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new FedimintError.DatabaseError({
+            msg: FfiConverterString.read(from),
+          })
+        case 2:
+          return new FedimintError.NetworkingError({
+            msg: FfiConverterString.read(from),
+          })
+        case 3:
+          return new FedimintError.RuntimeError({
+            msg: FfiConverterString.read(from),
+          })
+        case 4:
+          return new FedimintError.InvalidRequest({
+            msg: FfiConverterString.read(from),
+          })
+        case 5:
+          return new FedimintError.General({
+            msg: FfiConverterString.read(from),
+          })
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase()
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case FedimintError_Tags.DatabaseError: {
+          ordinalConverter.write(1, into)
+          const inner = value.inner
+          FfiConverterString.write(inner.msg, into)
+          return
+        }
+        case FedimintError_Tags.NetworkingError: {
+          ordinalConverter.write(2, into)
+          const inner = value.inner
+          FfiConverterString.write(inner.msg, into)
+          return
+        }
+        case FedimintError_Tags.RuntimeError: {
+          ordinalConverter.write(3, into)
+          const inner = value.inner
+          FfiConverterString.write(inner.msg, into)
+          return
+        }
+        case FedimintError_Tags.InvalidRequest: {
+          ordinalConverter.write(4, into)
+          const inner = value.inner
+          FfiConverterString.write(inner.msg, into)
+          return
+        }
+        case FedimintError_Tags.General: {
+          ordinalConverter.write(5, into)
+          const inner = value.inner
+          FfiConverterString.write(inner.msg, into)
+          return
+        }
+        default:
+          // Throwing from here means that FedimintError_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase()
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case FedimintError_Tags.DatabaseError: {
+          const inner = value.inner
+          let size = ordinalConverter.allocationSize(1)
+          size += FfiConverterString.allocationSize(inner.msg)
+          return size
+        }
+        case FedimintError_Tags.NetworkingError: {
+          const inner = value.inner
+          let size = ordinalConverter.allocationSize(2)
+          size += FfiConverterString.allocationSize(inner.msg)
+          return size
+        }
+        case FedimintError_Tags.RuntimeError: {
+          const inner = value.inner
+          let size = ordinalConverter.allocationSize(3)
+          size += FfiConverterString.allocationSize(inner.msg)
+          return size
+        }
+        case FedimintError_Tags.InvalidRequest: {
+          const inner = value.inner
+          let size = ordinalConverter.allocationSize(4)
+          size += FfiConverterString.allocationSize(inner.msg)
+          return size
+        }
+        case FedimintError_Tags.General: {
+          const inner = value.inner
+          let size = ordinalConverter.allocationSize(5)
+          size += FfiConverterString.allocationSize(inner.msg)
+          return size
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase()
+      }
+    }
+  }
+  return new FFIConverter()
+})()
+
+export interface RpcHandlerInterface {
+  rpc(requestJson: string, callback: RpcCallback) /*throws*/ : void
+}
+
+export class RpcHandler
+  extends UniffiAbstractObject
+  implements RpcHandlerInterface
+{
+  readonly [uniffiTypeNameSymbol] = 'RpcHandler'
+  readonly [destructorGuardSymbol]: UniffiRustArcPtr
+  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer
+  constructor(dbPath: string) /*throws*/ {
+    super()
+    const pointer = uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeFedimintError.lift.bind(
+        FfiConverterTypeFedimintError,
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_fedimint_client_uniffi_fn_constructor_rpchandler_new(
+          FfiConverterString.lower(dbPath),
+          callStatus,
+        )
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    )
+    this[pointerLiteralSymbol] = pointer
+    this[destructorGuardSymbol] =
+      uniffiTypeRpcHandlerObjectFactory.bless(pointer)
+  }
+
+  public rpc(requestJson: string, callback: RpcCallback): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeFedimintError.lift.bind(
+        FfiConverterTypeFedimintError,
+      ),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_fedimint_client_uniffi_fn_method_rpchandler_rpc(
+          uniffiTypeRpcHandlerObjectFactory.clonePointer(this),
+          FfiConverterString.lower(requestJson),
+          FfiConverterTypeRpcCallback.lower(callback),
+          callStatus,
+        )
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    )
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol]
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeRpcHandlerObjectFactory.pointer(this)
+      uniffiTypeRpcHandlerObjectFactory.freePointer(pointer)
+      uniffiTypeRpcHandlerObjectFactory.unbless(ptr)
+      delete (this as any)[destructorGuardSymbol]
+    }
+  }
+
+  static instanceOf(obj: any): obj is RpcHandler {
+    return uniffiTypeRpcHandlerObjectFactory.isConcreteType(obj)
+  }
+}
+
+const uniffiTypeRpcHandlerObjectFactory: UniffiObjectFactory<RpcHandlerInterface> =
+  (() => {
+    return {
+      create(pointer: UnsafeMutableRawPointer): RpcHandlerInterface {
+        const instance = Object.create(RpcHandler.prototype)
+        instance[pointerLiteralSymbol] = pointer
+        instance[destructorGuardSymbol] = this.bless(pointer)
+        instance[uniffiTypeNameSymbol] = 'RpcHandler'
+        return instance
+      },
+
+      bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
+        return uniffiCaller.rustCall(
+          /*caller:*/ (status) =>
+            nativeModule().ubrn_uniffi_internal_fn_method_rpchandler_ffi__bless_pointer(
+              p,
+              status,
+            ),
+          /*liftString:*/ FfiConverterString.lift,
+        )
+      },
+
+      unbless(ptr: UniffiRustArcPtr) {
+        ptr.markDestroyed()
+      },
+
+      pointer(obj: RpcHandlerInterface): UnsafeMutableRawPointer {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+          throw new UniffiInternalError.UnexpectedNullPointer()
+        }
+        return (obj as any)[pointerLiteralSymbol]
+      },
+
+      clonePointer(obj: RpcHandlerInterface): UnsafeMutableRawPointer {
+        const pointer = this.pointer(obj)
+        return uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_fedimint_client_uniffi_fn_clone_rpchandler(
+              pointer,
+              callStatus,
+            ),
+          /*liftString:*/ FfiConverterString.lift,
+        )
+      },
+
+      freePointer(pointer: UnsafeMutableRawPointer): void {
+        uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_fedimint_client_uniffi_fn_free_rpchandler(
+              pointer,
+              callStatus,
+            ),
+          /*liftString:*/ FfiConverterString.lift,
+        )
+      },
+
+      isConcreteType(obj: any): obj is RpcHandlerInterface {
+        return (
+          obj[destructorGuardSymbol] &&
+          obj[uniffiTypeNameSymbol] === 'RpcHandler'
+        )
+      },
+    }
+  })()
+// FfiConverter for RpcHandlerInterface
+const FfiConverterTypeRpcHandler = new FfiConverterObject(
+  uniffiTypeRpcHandlerObjectFactory,
+)
+
+/**
+ * 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_fedimint_client_uniffi_uniffi_contract_version()
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(
+      scaffoldingContractVersion,
+      bindingsContractVersion,
+    )
+  }
+  if (
+    nativeModule().ubrn_uniffi_fedimint_client_uniffi_checksum_method_rpchandler_rpc() !==
+    11869
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_fedimint_client_uniffi_checksum_method_rpchandler_rpc',
+    )
+  }
+  if (
+    nativeModule().ubrn_uniffi_fedimint_client_uniffi_checksum_constructor_rpchandler_new() !==
+    44077
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_fedimint_client_uniffi_checksum_constructor_rpchandler_new',
+    )
+  }
+  if (
+    nativeModule().ubrn_uniffi_fedimint_client_uniffi_checksum_method_rpccallback_on_response() !==
+    7989
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_fedimint_client_uniffi_checksum_method_rpccallback_on_response',
+    )
+  }
+
+  uniffiCallbackInterfaceRpcCallback.register()
+}
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeFedimintError,
+    FfiConverterTypeRpcHandler,
+  },
+})

package/src/index.tsx

@@ -0,0 +1,41 @@
+// Generated by uniffi-bindgen-react-native
+import installer from './NativeReactNativeBindings';
+
+// 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/fedimint_client_uniffi';
+
+// Now import the bindings so we can:
+// - intialize them
+// - export them as namespaced objects as the default export.
+import * as fedimint_client_uniffi from './generated/fedimint_client_uniffi';
+
+// 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) {
+  fedimint_client_uniffi.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 {
+  fedimint_client_uniffi,
+};
+