@getpara/react-native-wallet 0.1.0

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Wed Jan 29 16:28:26 PST 2025
+gradle.version=8.9

package/android/build.gradle

@@ -0,0 +1,76 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["ReactNativeWallet_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeWallet_" + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+}
+
+repositories {
+  mavenCentral()
+  google()
+  maven { url 'https://jitpack.io' }
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation 'com.github.briancorbin:aar-testing:0.0.4@aar'
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "ReactNativeWallet"
+    codegenJavaPackageName = "com.para.reactnativewallet"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+ReactNativeWallet_kotlinVersion=1.7.0
+ReactNativeWallet_minSdkVersion=21
+ReactNativeWallet_targetSdkVersion=31
+ReactNativeWallet_compileSdkVersion=31
+ReactNativeWallet_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.para.reactnativewallet">
+
+</manifest>

package/android/src/main/java/com/para/reactnativewallet/ParaSignerModule.java

@@ -0,0 +1,294 @@
+package com.para.reactnativewallet;
+
+import android.util.Log;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+import signer.Signer;
+
+public class ParaSignerModule extends ReactContextBaseJavaModule {
+  static final String TAG = "ParaSignerModule";
+
+  String ids = "[\"USER\",\"CAPSULE\"]";
+  String serverUrl;
+  String wsServerUrl;
+  String configBase =
+    "{\"ServerUrl\": \"%s\", \"WalletId\": \"%s\", \"Id\":\"%s\", \"Ids\":%s, \"Threshold\":1}";
+  String configDKLSBase =
+    "{\"walletId\": \"%s\", \"id\":\"USER\", \"otherId\":\"CAPSULE\", \"isReceiver\": false}";
+
+  ParaSignerModule(ReactApplicationContext context) {
+    super(context);
+  }
+
+  @Override
+  public String getName() {
+    return "ParaSignerModule";
+  }
+
+  @ReactMethod
+  public void setServerUrl(String serverUrl) {
+    this.serverUrl = serverUrl;
+  }
+
+  @ReactMethod
+  public void setWsServerUrl(String wsServerUrl) {
+    this.wsServerUrl = wsServerUrl;
+  }
+
+  private String getServerAddress(String userID) {
+    return String.format("%susers/%s/mpc-network", this.serverUrl, userID);
+  }
+
+  private String getWsServerAddress() {
+    return this.wsServerUrl;
+  }
+
+  /**
+   * Perform distributed key generation with the Para server
+   *
+   * @param protocolId
+   * @return
+   */
+  @ReactMethod
+  public void createAccount(
+    String walletId,
+    String protocolId,
+    String id,
+    String userId,
+    Promise promise
+  ) {
+    String signerConfig = String.format(
+      configBase,
+      this.getServerAddress(userId),
+      walletId,
+      id,
+      ids
+    );
+    (
+      new Thread(
+        () -> {
+          String res = Signer.createAccount(
+            this.getServerAddress(userId),
+            signerConfig,
+            protocolId
+          );
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void getAddress(String serializedSigner, Promise promise) {
+    (
+      new Thread(
+        () -> {
+          String res = Signer.getAddress(serializedSigner);
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void sendTransaction(
+    String protocolId,
+    String serializedSigner,
+    String transaction,
+    String userId,
+    Promise promise
+  ) {
+    (
+      new Thread(
+        () -> {
+          String res = Signer.sendTransaction(
+            this.getServerAddress(userId),
+            serializedSigner,
+            transaction,
+            protocolId
+          );
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void signMessage(
+    String protocolId,
+    String serializedSigner,
+    String message,
+    String userId,
+    Promise promise
+  ) {
+    (
+      new Thread(
+        () -> {
+          String res = Signer.signMessage(
+            this.getServerAddress(userId),
+            serializedSigner,
+            message,
+            protocolId
+          );
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void refresh(String protocolId, String serializedSigner, String userId, Promise promise) {
+    (
+      new Thread(
+        () -> {
+          String res = Signer.refresh(this.getServerAddress(userId), serializedSigner, protocolId);
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void dklsCreateAccount(
+    String walletId,
+    String protocolId,
+    String id,
+    String userId,
+    Promise promise
+  ) {
+    String signerConfig = String.format(
+      configDKLSBase,
+      walletId
+    );
+    (
+      new Thread(
+        () -> {
+          String res = Signer.dklsCreateAccount(
+            this.getWsServerAddress(),
+            signerConfig,
+            protocolId
+          );
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void dklsGetAddress(String serializedSigner, Promise promise) {
+    (
+      new Thread(
+        () -> {
+          String res = Signer.dklsGetAddress(serializedSigner);
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void dklsSendTransaction(
+    String protocolId,
+    String serializedSigner,
+    String transaction,
+    String userId,
+    Promise promise
+  ) {
+    (
+      new Thread(
+        () -> {
+          String res = Signer.dklsSendTransaction(
+            this.getWsServerAddress(),
+            serializedSigner,
+            transaction,
+            protocolId
+          );
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void dklsSignMessage(
+    String protocolId,
+    String serializedSigner,
+    String message,
+    String userId,
+    Promise promise
+  ) {
+    (
+      new Thread(
+        () -> {
+          String res = Signer.dklsSignMessage(
+            this.getWsServerAddress(),
+            serializedSigner,
+            message,
+            protocolId
+          );
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void dklsRefresh(String protocolId, String serializedSigner, String userId, Promise promise) {
+    (
+      new Thread(
+        () -> {
+          String res = Signer.dklsRefresh(this.getWsServerAddress(), serializedSigner, protocolId);
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void ed25519CreateAccount(
+    String walletId,
+    String protocolId,
+    Promise promise
+  ) {
+    (
+      new Thread(
+        () -> {
+          String res = Signer.eD25519CreateAccount(
+            this.getWsServerAddress(),
+            walletId,
+            protocolId
+          );
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+
+  @ReactMethod
+  public void ed25519Sign(
+    String protocolId,
+    String serializedSigner,
+    String message,
+    Promise promise
+  ) {
+    (
+      new Thread(
+        () -> {
+          String res = Signer.eD25519Sign(
+            serializedSigner,
+            message,
+            protocolId
+          );
+          promise.resolve(res);
+        }
+      )
+    ).start();
+  }
+}

package/android/src/main/java/com/para/reactnativewallet/ParaSignerPackage.java

@@ -0,0 +1,30 @@
+package com.para.reactnativewallet;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class CapsuleSignerPackage implements ReactPackage {
+
+  @Override
+  public List<ViewManager> createViewManagers(
+    ReactApplicationContext reactContext
+  ) {
+    return Collections.emptyList();
+  }
+
+  @Override
+  public List<NativeModule> createNativeModules(
+    ReactApplicationContext reactContext
+  ) {
+    List<NativeModule> modules = new ArrayList<>();
+
+    modules.add(new ParaSignerModule(reactContext));
+
+    return modules;
+  }
+}

package/capsule-react-native-wallet.podspec

@@ -0,0 +1,36 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "para-react-native-wallet"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "11.0" }
+  s.source       = { :git => "https://getpara.com.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+  s.vendored_frameworks = "signer.xcframework"
+
+  s.dependency "React-Core"
+
+  # Don't install the dependencies when we run `pod install` in the old architecture.
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+    s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+    }
+    s.dependency "React-Codegen"
+    s.dependency "RCT-Folly"
+    s.dependency "RCTRequired"
+    s.dependency "RCTTypeSafety"
+    s.dependency "ReactCommon/turbomodule/core"
+  end
+end

package/dist/AsyncStorage.d.ts

@@ -0,0 +1,10 @@
+import { StorageUtils } from '@getpara/web-sdk';
+/**
+ * Implements `StorageUtils` using React Native Async Storage.
+ */
+export declare class AsyncStorage implements StorageUtils {
+    clear(prefix: string): Promise<void>;
+    get(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+    set(key: string, value: string): Promise<void>;
+}

package/dist/AsyncStorage.js

@@ -0,0 +1,41 @@
+// Copyright (c) Capsule Labs Inc. All rights reserved.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import RNAsyncStorage from '@react-native-async-storage/async-storage';
+/**
+ * Implements `StorageUtils` using React Native Async Storage.
+ */
+export class AsyncStorage {
+    clear(prefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keys = yield RNAsyncStorage.getAllKeys();
+            for (const key of keys) {
+                if (key.startsWith(prefix)) {
+                    yield RNAsyncStorage.removeItem(key);
+                }
+            }
+        });
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return RNAsyncStorage.getItem(key);
+        });
+    }
+    removeItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield RNAsyncStorage.removeItem(key);
+        });
+    }
+    set(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield RNAsyncStorage.setItem(key, value);
+        });
+    }
+}

package/dist/KeychainStorage.d.ts

@@ -0,0 +1,10 @@
+import { StorageUtils } from '@getpara/web-sdk';
+/**
+ * Implements `StorageUtils` using React Native `Keychain`.
+ */
+export declare class KeychainStorage implements StorageUtils {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/KeychainStorage.js

@@ -0,0 +1,72 @@
+// Copyright (c) Capsule Labs Inc. All rights reserved.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Keychain from 'react-native-keychain';
+const USERNAME = '@CAPSULE';
+const KEYCHAIN_USER_CANCELLED_ERRORS = [
+    'user canceled the operation',
+    'error: code: 13, msg: cancel',
+    'error: code: 10, msg: fingerprint operation canceled by the user',
+];
+function isUserCancelledError(error) {
+    return KEYCHAIN_USER_CANCELLED_ERRORS.some(userCancelledError => error.toString().toLowerCase().includes(userCancelledError));
+}
+/**
+ * Implements `StorageUtils` using React Native `Keychain`.
+ */
+export class KeychainStorage {
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const item = yield Keychain.getGenericPassword({
+                    service: key,
+                });
+                if (!item) {
+                    return null;
+                }
+                return item.password;
+            }
+            catch (error) {
+                if (error instanceof Error && !isUserCancelledError(error)) {
+                    // triggered when biometry verification fails and user cancels the action
+                    throw new Error('Error retrieving stored item ' + error.message);
+                }
+                throw error;
+            }
+        });
+    }
+    set(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield Keychain.setGenericPassword(USERNAME, value, {
+                service: key,
+                accessible: Keychain.ACCESSIBLE.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY,
+                securityLevel: Keychain.SECURITY_LEVEL.ANY,
+            });
+            if (!result) {
+                throw new Error('Failed to store key ' + key);
+            }
+        });
+    }
+    removeItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Keychain.resetGenericPassword({ service: key });
+        });
+    }
+    clear(prefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const services = yield Keychain.getAllGenericPasswordServices();
+            for (const key of services) {
+                if (key && key.startsWith(prefix)) {
+                    yield Keychain.resetGenericPassword({ service: key });
+                }
+            }
+        });
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+import { Environment } from '@getpara/web-sdk';
+export declare function getBaseMPCNetworkWSUrl(env: Environment): string;
+export declare let userManagementServer: string;
+export declare let portalBase: string;
+export declare let mpcNetworkWSServer: string;
+export declare function setEnv(env: Environment): void;
+export declare const DEBUG_MODE_ENABLED = false;

package/dist/config.js

@@ -0,0 +1,61 @@
+// Copyright (c) Capsule Labs Inc. All rights reserved.
+import { NativeModules } from 'react-native';
+import { Environment } from '@getpara/web-sdk';
+function getPortalBaseURL(env) {
+    switch (env) {
+        case Environment.DEV:
+            return 'http://localhost:3003';
+        case Environment.SANDBOX:
+            return 'https://app.sandbox.usecapsule.com';
+        case Environment.BETA:
+            return 'https://app.beta.usecapsule.com';
+        case Environment.PROD:
+            return 'https://app.usecapsule.com';
+        default:
+            throw new Error(`env: ${env} not supported`);
+    }
+}
+function getBaseUrl(env) {
+    switch (env) {
+        case Environment.DEV:
+            return 'http://localhost:8080/';
+        case Environment.SANDBOX:
+            return 'https://api.sandbox.getpara.com/';
+        case Environment.BETA:
+            return 'https://api.beta.getpara.com/';
+        case Environment.PROD:
+            return 'https://api.getpara.com/';
+        default:
+            throw new Error(`unsupported env: ${env}`);
+    }
+}
+export function getBaseMPCNetworkWSUrl(env) {
+    switch (env) {
+        case Environment.DEV:
+            return `ws://localhost:3000`;
+        case Environment.SANDBOX:
+            return `wss://mpc-network.sandbox.getpara.com`;
+        case Environment.BETA:
+            return `wss://mpc-network.beta.getpara.com`;
+        case Environment.PROD:
+            return `wss://mpc-network.getpara.com`;
+        default:
+            throw new Error(`unsupported env: ${env}`);
+    }
+}
+export let userManagementServer = getBaseUrl(Environment.BETA);
+export let portalBase = getPortalBaseURL(Environment.BETA);
+export let mpcNetworkWSServer = getBaseMPCNetworkWSUrl(Environment.BETA);
+export function setEnv(env) {
+    userManagementServer = getBaseUrl(env);
+    portalBase = getPortalBaseURL(env);
+    mpcNetworkWSServer = getBaseMPCNetworkWSUrl(env);
+    init();
+}
+const { CapsuleSignerModule } = NativeModules;
+export const DEBUG_MODE_ENABLED = false;
+function init() {
+    CapsuleSignerModule.setServerUrl(userManagementServer);
+    CapsuleSignerModule.setWsServerUrl(mpcNetworkWSServer);
+}
+init();

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from '@getpara/web-sdk';
+export { ParaMobile } from './react-native/ParaMobile.js';