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

package/package.json

@@ -0,0 +1,146 @@
+{
+  "name": "@fedimint/react-native-bindings",
+  "version": "0.0.0-om-rn1-d72fdc108a01df2d7d64c2b85c8b1f9fd43927cb",
+  "description": "Fedimint Client SDK for React-Native",
+  "source": "./src/index.tsx",
+  "main": "./lib/commonjs/index.js",
+  "module": "./lib/module/index.js",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/module/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "scripts",
+    "cpp",
+    "plugin",
+    "patches",
+    "app.plugin.js",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!android/src/main/jniLibs",
+    "!plugin/src",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*",
+    "!*.xcframework"
+  ],
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fedimint/fedimint-sdk.git"
+  },
+  "author": "Fedimint Developers <reach.oms2004@gmail.com> (https://github.com/fedimint)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/fedimint/fedimint-sdk/issues"
+  },
+  "homepage": "https://github.com/fedimint/fedimint-sdk#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.29.0",
+    "@react-native-community/cli": "15.0.1",
+    "@types/jest": "^29.5.5",
+    "@types/react": "^19.0.8",
+    "del-cli": "^5.1.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.0.3",
+    "react": "19.2.0",
+    "react-native": "0.83.1",
+    "react-native-builder-bob": "^0.40.17",
+    "typescript": "^5.2.2"
+  },
+  "resolutions": {
+    "@types/react": "^19.0.8"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "codegen",
+      [
+        "commonjs",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "ReactNativeBindingsSpec",
+    "type": "all",
+    "jsSrcsDir": "src",
+    "outputDir": {
+      "android": "android/generated",
+      "ios": "ios/generated"
+    },
+    "android": {
+      "javaPackageName": "com.fedimint.reactnative"
+    },
+    "includesGeneratedCode": true
+  },
+  "create-react-native-library": {
+    "type": "module-new",
+    "languages": "cpp",
+    "version": "0.41.2"
+  },
+  "dependencies": {
+    "@expo/config-plugins": "^9.0.0",
+    "uniffi-bindgen-react-native": "0.29.3-1",
+    "@fedimint/types": "0.0.0-om-rn1-d72fdc108a01df2d7d64c2b85c8b1f9fd43927cb"
+  },
+  "checksums": {
+    "android": "2cf6baa1447a765337571e82dcfff25effc324fddfd9c65e81de5c7bce0a2d53",
+    "ios": "f04625c75e21b12c100beb47227a08f13a677003a165ac86647cd97c6c61128e"
+  },
+  "scripts": {
+    "ubrn:ios": "ubrn build ios --and-generate",
+    "ubrn:android": "ubrn build android --and-generate && patch -p0 --forward < patches/rn083_callinvoker.patch || true",
+    "ubrn:ios:release": "ubrn build ios --and-generate --release",
+    "ubrn:android:release": "ubrn build android --and-generate --release && patch -p0 --forward < patches/rn083_callinvoker.patch || true",
+    "ubrn:checkout": "ubrn checkout",
+    "ubrn:clean": "rm -rfv cpp/ android/CMakeLists.txt android/src/main/java android/*.cpp ios/ src/Native* src/index.*ts* src/generated/",
+    "clean:deep": "pnpm clean && rm -rfv cpp/ android/CMakeLists.txt android/src/main/java android/*.cpp ios/ src/Native* src/index.*ts* src/generated/",
+    "clean": "rm -rfv android/build example/android/build example/android/app/build example/ios/build lib plugin/build",
+    "build": "bob build && pnpm build:plugin",
+    "build:plugin": "cd plugin && tsc",
+    "typecheck": "tsc",
+    "postinstall": "node scripts/download-binaries.js"
+  }
+}

package/patches/rn083_callinvoker.patch

@@ -0,0 +1,50 @@
+--- android/cpp-adapter.cpp.orig	2026-02-04 04:45:17
++++ android/cpp-adapter.cpp	2026-02-04 04:45:39
+@@ -1,6 +1,7 @@
+ // Generated by uniffi-bindgen-react-native
+ #include <jni.h>
+ #include <jsi/jsi.h>
++#include <fbjni/fbjni.h>
+ #include <ReactCommon/CallInvokerHolder.h>
+ #include "fedimint-react-native.h"
+ 
+@@ -24,33 +25,13 @@
+     jlong rtPtr,
+     jobject callInvokerHolderJavaObj
+ ) {
+-    // https://github.com/realm/realm-js/blob/main/packages/realm/binding/android/src/main/cpp/io_realm_react_RealmReactModule.cpp#L122-L145
+-    // React Native uses the fbjni library for handling JNI, which has the concept of "hybrid objects",
+-    // which are Java objects containing a pointer to a C++ object. The CallInvokerHolder, which has the
+-    // invokeAsync method we want access to, is one such hybrid object.
+-    // Rather than reworking our code to use fbjni throughout, this code unpacks the C++ object from the Java
+-    // object `callInvokerHolderJavaObj` manually, based on reverse engineering the fbjni code.
++    // React Native 0.77+ uses fbjni HybridClass for CallInvokerHolder
++    // Use the proper fbjni API to extract the CallInvoker
++    auto callInvokerHolder = facebook::jni::wrap_alias(
++        reinterpret_cast<facebook::react::CallInvokerHolder::javaobject>(callInvokerHolderJavaObj)
++    )->cthis();
++    auto jsCallInvoker = callInvokerHolder->getCallInvoker();
+ 
+-    // 1. Get the Java object referred to by the mHybridData field of the Java holder object
+-    auto callInvokerHolderClass = env->GetObjectClass(callInvokerHolderJavaObj);
+-    auto hybridDataField = env->GetFieldID(callInvokerHolderClass, "mHybridData", "Lcom/facebook/jni/HybridData;");
+-    auto hybridDataObj = env->GetObjectField(callInvokerHolderJavaObj, hybridDataField);
+-
+-    // 2. Get the destructor Java object referred to by the mDestructor field from the myHybridData Java object
+-    auto hybridDataClass = env->FindClass("com/facebook/jni/HybridData");
+-    auto destructorField =
+-        env->GetFieldID(hybridDataClass, "mDestructor", "Lcom/facebook/jni/HybridData$Destructor;");
+-    auto destructorObj = env->GetObjectField(hybridDataObj, destructorField);
+-
+-    // 3. Get the mNativePointer field from the mDestructor Java object
+-    auto destructorClass = env->FindClass("com/facebook/jni/HybridData$Destructor");
+-    auto nativePointerField = env->GetFieldID(destructorClass, "mNativePointer", "J");
+-    auto nativePointerValue = env->GetLongField(destructorObj, nativePointerField);
+-
+-    // 4. Cast the mNativePointer back to its C++ type
+-    auto nativePointer = reinterpret_cast<facebook::react::CallInvokerHolder*>(nativePointerValue);
+-    auto jsCallInvoker = nativePointer->getCallInvoker();
+-
+     auto runtime = reinterpret_cast<jsi::Runtime *>(rtPtr);
+     return fedimint_reactnative::installRustCrate(*runtime, jsCallInvoker);
+ }

package/plugin/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "outDir": "./build",
+    "rootDir": "./src",
+    "declaration": true,
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "build"]
+}

package/react-native.config.js

@@ -0,0 +1,15 @@
+/**
+ * @fedimint/react-native-bindings configuration
+ * @type {import('@react-native-community/cli-types').UserDependencyConfig}
+ */
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        cmakeListsPath: 'generated/android/app/build/generated/source/codegen/jni/CMakeLists.txt',
+        packageImportPath: 'import com.fedimint.reactnative.ReactNativeBindingsPackage;',
+        packageInstance: 'new ReactNativeBindingsPackage()',
+      },
+    },
+  },
+};

package/scripts/download-binaries.js

@@ -0,0 +1,111 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+const crypto = require('crypto');
+
+const pkg = require('../package.json');
+
+// Check if we should skip
+if (process.env.EXPO_PUBLIC_SKIP_POSTINSTALL) {
+    console.log('Skipping postinstall due to EXPO_PUBLIC_SKIP_POSTINSTALL');
+    process.exit(0);
+}
+
+// Check if artifacts already exist (simple check)
+const androidLibCheck = path.join(__dirname, '../android/src/main/jniLibs');
+const iosFrameworkCheck = path.join(__dirname, '../FedimintReactNativeBindingsFramework.xcframework');
+
+if (fs.existsSync(androidLibCheck) && fs.existsSync(iosFrameworkCheck)) {
+    console.log('Binaries already present, skipping download.');
+    process.exit(0);
+}
+
+const REPO = 'https://github.com/fedimint/fedimint-sdk';
+let TAG = `v${pkg.version}`;
+if (pkg.version.includes('-') || pkg.version.includes('snapshot')) {
+    TAG = 'snapshot';
+}
+const ANDROID_CHECKSUM = pkg.checksums ? pkg.checksums.android : null;
+const IOS_CHECKSUM = pkg.checksums ? pkg.checksums.ios : null;
+
+if (!ANDROID_CHECKSUM || !IOS_CHECKSUM) {
+    console.warn("Checksums not found in package.json. Skipping download (assume local dev or first install).");
+    process.exit(0);
+}
+
+const downloadFile = (url, dest) => {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (response) => {
+            if (response.statusCode === 302 || response.statusCode === 301) {
+                downloadFile(response.headers.location, dest).then(resolve).catch(reject);
+                return;
+            }
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close(resolve);
+            });
+        }).on('error', (err) => {
+            fs.unlink(dest, () => { });
+            reject(err);
+        });
+    });
+};
+
+const verifyChecksum = (file, expected) => {
+    const fileBuffer = fs.readFileSync(file);
+    const hashSum = crypto.createHash('sha256');
+    hashSum.update(fileBuffer);
+    const hex = hashSum.digest('hex');
+    return hex === expected;
+};
+
+const unzip = (file, dest) => {
+    try {
+        execSync(`unzip -o ${file} -d ${dest}`);
+    } catch (e) {
+        console.error(`Failed to unzip ${file}: ${e.message}`);
+        throw e;
+    }
+};
+
+const main = async () => {
+    const androidUrl = `${REPO}/releases/download/${TAG}/android-artifacts.zip`;
+    const iosUrl = `${REPO}/releases/download/${TAG}/ios-artifacts.zip`;
+
+    console.log(`Downloading Android artifacts from ${androidUrl}...`);
+    await downloadFile(androidUrl, 'android-artifacts.zip');
+
+    if (!verifyChecksum('android-artifacts.zip', ANDROID_CHECKSUM)) {
+        console.error('Android checkum mismatch!');
+        process.exit(1);
+    }
+
+    console.log('Extracting Android artifacts...');
+    // Adjust destination if needed based on zip structure
+    unzip('android-artifacts.zip', path.join(__dirname, '../'));
+    fs.unlinkSync('android-artifacts.zip');
+
+
+    console.log(`Downloading iOS artifacts from ${iosUrl}...`);
+    await downloadFile(iosUrl, 'ios-artifacts.zip');
+
+    if (!verifyChecksum('ios-artifacts.zip', IOS_CHECKSUM)) {
+        console.error('iOS checkum mismatch!');
+        process.exit(1);
+    }
+
+    console.log('Extracting iOS artifacts...');
+    unzip('ios-artifacts.zip', path.join(__dirname, '../'));
+    fs.unlinkSync('ios-artifacts.zip');
+
+    console.log('Binaries downloaded and installed successfully.');
+};
+
+main().catch(err => {
+    console.error('Error downloading binaries:', err);
+    // Don't fail install in case of network error, just warn? 
+    // Or fail strictly? The user requested script did `exit 1` on checksum fail, so we might want to fail.
+    process.exit(1);
+});

package/src/NativeReactNativeBindings.ts

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

package/src/generated/fedimint_client_uniffi-ffi.ts

@@ -0,0 +1,221 @@
+// 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_fedimint_client_uniffi_fn_clone_rpchandler(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint
+  ubrn_uniffi_fedimint_client_uniffi_fn_free_rpchandler(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): void
+  ubrn_uniffi_fedimint_client_uniffi_fn_constructor_rpchandler_new(
+    dbPath: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint
+  ubrn_uniffi_fedimint_client_uniffi_fn_method_rpchandler_rpc(
+    ptr: bigint,
+    requestJson: Uint8Array,
+    callback: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): void
+  ubrn_uniffi_fedimint_client_uniffi_fn_init_callback_vtable_rpccallback(
+    vtable: UniffiVTableCallbackInterfaceRpcCallback,
+  ): void
+  ubrn_uniffi_fedimint_client_uniffi_checksum_method_rpchandler_rpc(): number
+  ubrn_uniffi_fedimint_client_uniffi_checksum_constructor_rpchandler_new(): number
+  ubrn_uniffi_fedimint_client_uniffi_checksum_method_rpccallback_on_response(): number
+  ubrn_ffi_fedimint_client_uniffi_uniffi_contract_version(): number
+  ubrn_uniffi_internal_fn_method_rpchandler_ffi__bless_pointer(
+    pointer: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): UniffiRustArcPtr
+}
+
+// Casting globalThis to any allows us to look for `NativeFedimintClientUniffi`
+// if it was added via JSI.
+//
+// We use a getter here rather than simply `globalThis.NativeFedimintClientUniffi` so that
+// if/when the startup sequence isn't just so, an empty value isn't inadvertantly cached.
+const getter: () => NativeModuleInterface = () =>
+  (globalThis as any).NativeFedimintClientUniffi
+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
+type UniffiCallbackInterfaceRpcCallbackMethod0 = (
+  uniffiHandle: bigint,
+  responseJson: Uint8Array,
+) => UniffiResult<void>
+export type UniffiVTableCallbackInterfaceRpcCallback = {
+  onResponse: UniffiCallbackInterfaceRpcCallbackMethod0
+  uniffiFree: UniffiCallbackInterfaceFree
+}
+
+// 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