react-native-pirate-wallet 0.2.1

package/android/src/main/java/com/pirate/wallet/reactnative/PirateWalletReactNativeModule.kt

@@ -0,0 +1,96 @@
+package com.pirate.wallet.reactnative
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import java.io.File
+import org.json.JSONObject
+
+internal object NativeBridge {
+    init {
+        System.loadLibrary("pirate_ffi_native")
+    }
+
+    external fun invokeJson(requestJson: String, pretty: Boolean = false): String
+}
+
+class PirateWalletReactNativeModule(
+    reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName(): String = "PirateWalletReactNative"
+
+    @ReactMethod
+    fun invoke(requestJson: String, pretty: Boolean, promise: Promise) {
+        try {
+            promise.resolve(NativeBridge.invokeJson(requestJson, pretty))
+        } catch (t: Throwable) {
+            promise.reject("PIRATE_WALLET_INVOKE_ERROR", t.message, t)
+        }
+    }
+
+    @ReactMethod
+    fun configureAccountStorage(
+        accountId: String,
+        passphrase: String,
+        storagePath: String?,
+        promise: Promise,
+    ) {
+        try {
+            require(accountId.trim().isNotEmpty()) { "accountId must not be empty" }
+            require(passphrase.isNotEmpty()) { "passphrase must not be empty" }
+
+            val walletDbDir = accountStorageDirectory(reactApplicationContext, accountId, storagePath)
+            ensureDirectory(walletDbDir)
+
+            val requestJson = JSONObject()
+                .put("method", "configure_wallet_storage")
+                .put("base_dir", walletDbDir.absolutePath)
+                .put("passphrase", passphrase)
+                .toString()
+
+            promise.resolve(NativeBridge.invokeJson(requestJson, false))
+        } catch (t: Throwable) {
+            promise.reject("PIRATE_WALLET_CONFIGURE_STORAGE_ERROR", t.message, t)
+        }
+    }
+
+    private fun accountStorageDirectory(
+        context: ReactApplicationContext,
+        accountId: String,
+        storagePath: String?,
+    ): File {
+        if (!storagePath.isNullOrBlank()) {
+            return File(storagePath)
+        }
+
+        val accountsDir = File(File(context.filesDir, "pirate_wallet"), "accounts")
+        return File(accountsDir, sanitizeAccountId(accountId))
+    }
+
+    private fun ensureDirectory(walletDbDir: File) {
+        if (!walletDbDir.exists() && !walletDbDir.mkdirs()) {
+            throw IllegalStateException(
+                "Failed to create wallet database directory: ${walletDbDir.absolutePath}"
+            )
+        }
+    }
+
+    private fun sanitizeAccountId(accountId: String): String {
+        val trimmed = accountId.trim()
+        require(trimmed.isNotEmpty()) { "accountId must not be empty" }
+
+        val sanitized = buildString {
+            for (char in trimmed) {
+                append(
+                    if (char.isLetterOrDigit() || char == '_' || char == '-' || char == '.') {
+                        char
+                    } else {
+                        '_'
+                    }
+                )
+            }
+        }
+        return sanitized.ifEmpty { "account" }
+    }
+}

package/android/src/main/java/com/pirate/wallet/reactnative/PirateWalletReactNativePackage.kt

@@ -0,0 +1,14 @@
+package com.pirate.wallet.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PirateWalletReactNativePackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(PirateWalletReactNativeModule(reactContext))
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
+}

package/ios/PirateWalletReactNative.m

@@ -0,0 +1,172 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+@import PirateWalletNative;
+
+@interface PirateWalletReactNative : NSObject <RCTBridgeModule>
+@end
+
+@implementation PirateWalletReactNative
+
+RCT_EXPORT_MODULE();
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+RCT_REMAP_METHOD(invoke,
+                 invoke:(NSString *)requestJson
+                 pretty:(BOOL)pretty
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+{
+  const char *requestCString = [requestJson UTF8String];
+  if (requestCString == NULL) {
+    reject(@"PIRATE_WALLET_INVOKE_ERROR", @"Request string was not valid UTF-8.", nil);
+    return;
+  }
+
+  char *responsePtr = pirate_wallet_service_invoke_json(requestCString, pretty);
+  if (responsePtr == NULL) {
+    reject(@"PIRATE_WALLET_INVOKE_ERROR", @"Wallet service returned a null response.", nil);
+    return;
+  }
+
+  NSString *response = [NSString stringWithUTF8String:responsePtr];
+  pirate_wallet_service_free_string(responsePtr);
+
+  if (response == nil) {
+    reject(@"PIRATE_WALLET_INVOKE_ERROR", @"Wallet service returned invalid UTF-8.", nil);
+    return;
+  }
+
+  resolve(response);
+}
+
+RCT_REMAP_METHOD(configureAccountStorage,
+                 configureAccountStorage:(NSString *)accountId
+                 passphrase:(NSString *)passphrase
+                 storagePath:(NSString *)storagePath
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+{
+  if ((id)storagePath == [NSNull null]) {
+    storagePath = nil;
+  }
+
+  if (accountId == nil || accountId.length == 0) {
+    reject(@"PIRATE_WALLET_CONFIGURE_STORAGE_ERROR", @"accountId must not be empty", nil);
+    return;
+  }
+  if (passphrase == nil || passphrase.length == 0) {
+    reject(@"PIRATE_WALLET_CONFIGURE_STORAGE_ERROR", @"passphrase must not be empty", nil);
+    return;
+  }
+
+  NSError *error = nil;
+  NSString *baseDir = [self storagePathForAccountId:accountId storagePath:storagePath error:&error];
+  if (baseDir == nil) {
+    reject(@"PIRATE_WALLET_CONFIGURE_STORAGE_ERROR", error.localizedDescription, error);
+    return;
+  }
+
+  NSDictionary *request = @{
+    @"method": @"configure_wallet_storage",
+    @"base_dir": baseDir,
+    @"passphrase": passphrase
+  };
+  NSData *requestData = [NSJSONSerialization dataWithJSONObject:request options:0 error:&error];
+  if (requestData == nil) {
+    reject(@"PIRATE_WALLET_CONFIGURE_STORAGE_ERROR", error.localizedDescription, error);
+    return;
+  }
+
+  NSString *requestJson = [[NSString alloc] initWithData:requestData encoding:NSUTF8StringEncoding];
+  if (requestJson == nil) {
+    reject(@"PIRATE_WALLET_CONFIGURE_STORAGE_ERROR", @"Storage configuration request was not valid UTF-8.", nil);
+    return;
+  }
+
+  const char *requestCString = [requestJson UTF8String];
+  char *responsePtr = pirate_wallet_service_invoke_json(requestCString, NO);
+  if (responsePtr == NULL) {
+    reject(@"PIRATE_WALLET_CONFIGURE_STORAGE_ERROR", @"Wallet service returned a null response.", nil);
+    return;
+  }
+
+  NSString *response = [NSString stringWithUTF8String:responsePtr];
+  pirate_wallet_service_free_string(responsePtr);
+
+  if (response == nil) {
+    reject(@"PIRATE_WALLET_CONFIGURE_STORAGE_ERROR", @"Wallet service returned invalid UTF-8.", nil);
+    return;
+  }
+
+  resolve(response);
+}
+
+- (NSString *)storagePathForAccountId:(NSString *)accountId
+                          storagePath:(NSString *)storagePath
+                                error:(NSError **)error
+{
+  if (storagePath != nil && storagePath.length > 0) {
+    return [self ensureStorageDirectory:storagePath error:error] ? storagePath : nil;
+  }
+
+  NSString *sanitized = [self sanitizedAccountId:accountId];
+  if (sanitized.length == 0) {
+    if (error != nil) {
+      *error = [NSError errorWithDomain:@"PirateWalletReactNative"
+                                   code:1
+                               userInfo:@{NSLocalizedDescriptionKey: @"accountId must not be empty"}];
+    }
+    return nil;
+  }
+
+  NSArray<NSURL *> *urls = [[NSFileManager defaultManager] URLsForDirectory:NSApplicationSupportDirectory
+                                                                  inDomains:NSUserDomainMask];
+  NSURL *applicationSupport = urls.firstObject;
+  if (applicationSupport == nil) {
+    if (error != nil) {
+      *error = [NSError errorWithDomain:@"PirateWalletReactNative"
+                                   code:2
+                               userInfo:@{NSLocalizedDescriptionKey: @"Application Support directory is unavailable"}];
+    }
+    return nil;
+  }
+
+  NSURL *base = [[applicationSupport URLByAppendingPathComponent:@"PirateWallet" isDirectory:YES]
+    URLByAppendingPathComponent:@"accounts" isDirectory:YES];
+  NSString *path = [[base URLByAppendingPathComponent:sanitized isDirectory:YES] path];
+  return [self ensureStorageDirectory:path error:error] ? path : nil;
+}
+
+- (BOOL)ensureStorageDirectory:(NSString *)path error:(NSError **)error
+{
+  return [[NSFileManager defaultManager] createDirectoryAtPath:path
+                                   withIntermediateDirectories:YES
+                                                    attributes:nil
+                                                         error:error];
+}
+
+- (NSString *)sanitizedAccountId:(NSString *)accountId
+{
+  NSString *trimmed = [accountId stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+  if (trimmed.length == 0) {
+    return @"";
+  }
+
+  NSMutableString *result = [NSMutableString stringWithCapacity:trimmed.length];
+  NSCharacterSet *allowed = [NSCharacterSet characterSetWithCharactersInString:@"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._-"];
+  for (NSUInteger index = 0; index < trimmed.length; index++) {
+    unichar character = [trimmed characterAtIndex:index];
+    if ([allowed characterIsMember:character]) {
+      [result appendFormat:@"%C", character];
+    } else {
+      [result appendString:@"_"];
+    }
+  }
+  return result;
+}
+
+@end

package/ios/PirateWalletReactNative.swift

@@ -0,0 +1,40 @@
+import Foundation
+import PirateWalletNative
+import React
+
+@objc(PirateWalletReactNative)
+final class PirateWalletReactNative: NSObject {
+  @objc
+  static func requiresMainQueueSetup() -> Bool {
+    false
+  }
+
+  @objc
+  func invoke(
+    _ requestJson: String,
+    pretty: Bool,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    guard let request = requestJson.cString(using: .utf8) else {
+      reject("PIRATE_WALLET_INVOKE_ERROR", "Request string was not valid UTF-8.", nil)
+      return
+    }
+
+    let pointer = request.withUnsafeBufferPointer { buffer in
+      pirate_wallet_service_invoke_json(buffer.baseAddress, pretty)
+    }
+
+    guard let pointer else {
+      reject("PIRATE_WALLET_INVOKE_ERROR", "Wallet service returned a null response.", nil)
+      return
+    }
+
+    defer {
+      pirate_wallet_service_free_string(pointer)
+    }
+
+    let response = String(cString: pointer)
+    resolve(response)
+  }
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "react-native-pirate-wallet",
+  "version": "0.2.1",
+  "description": "React Native wrapper for the Pirate Unified Wallet native SDK surfaces",
+  "keywords": [
+    "react-native",
+    "pirate-chain",
+    "cryptocurrency",
+    "wallet",
+    "privacy",
+    "shielded"
+  ],
+  "homepage": "https://github.com/PirateNetwork/Pirate-Unified-Light-Wallet/tree/main/bindings/react-native-pirate-wallet#readme",
+  "bugs": {
+    "url": "https://github.com/PirateNetwork/Pirate-Unified-Light-Wallet/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PirateNetwork/Pirate-Unified-Light-Wallet.git",
+    "directory": "bindings/react-native-pirate-wallet"
+  },
+  "author": "Pirate Chain Contributors",
+  "license": "MIT",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "files": [
+    "android/build.gradle",
+    "android/consumer-rules.pro",
+    "android/src/main/AndroidManifest.xml",
+    "android/src/main/java/",
+    "ios/PirateWalletReactNative.m",
+    "ios/PirateWalletReactNative.swift",
+    "src/",
+    "scripts/",
+    "test/",
+    "LICENSE-MIT",
+    "README.md",
+    "package.json",
+    "react-native.config.js",
+    "react-native-pirate-wallet.podspec"
+  ],
+  "scripts": {
+    "test": "node test/smoke.js",
+    "verify:package": "node scripts/verify-package.js",
+    "prepare:native": "node scripts/assemble-ios-framework.js",
+    "postinstall": "npm run prepare:native",
+    "prepack": "node scripts/verify-package.js --publish-layout"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.71.0 <1.0.0"
+  },
+  "optionalDependencies": {
+    "react-native-pirate-wallet-android": "0.2.1",
+    "react-native-pirate-wallet-android-x86_64": "0.2.1",
+    "react-native-pirate-wallet-ios-device": "0.2.1",
+    "react-native-pirate-wallet-ios-simulator": "0.2.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/react-native-pirate-wallet.podspec

@@ -0,0 +1,19 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = package["name"]
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.license      = package["license"]
+  s.homepage     = "https://github.com/piratenetwork/Pirate-Unified-Light-Wallet"
+  s.authors      = "Pirate Chain Contributors"
+
+  s.platform     = :ios, "15.0"
+  s.source       = { :path => "." }
+  s.source_files = "ios/PirateWalletReactNative.m"
+  s.vendored_frameworks = "ios/Frameworks/PirateWalletNative.xcframework"
+
+  s.dependency "React-Core"
+end

package/react-native.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: './android'
+      },
+      ios: {}
+    }
+  }
+}

package/scripts/assemble-ios-framework.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const packageRoot = path.resolve(__dirname, '..');
+const frameworkName = 'PirateWalletNative.xcframework';
+const iosPackages = [
+  {
+    name: 'react-native-pirate-wallet-ios-device',
+    slice: 'ios-arm64',
+  },
+  {
+    name: 'react-native-pirate-wallet-ios-simulator',
+    slice: 'ios-arm64_x86_64-simulator',
+  },
+];
+
+function candidatePackageJsonPaths(packageName) {
+  const candidates = [];
+  try {
+    candidates.push(
+      require.resolve(`${packageName}/package.json`, {
+        paths: [process.cwd(), packageRoot],
+      }),
+    );
+  } catch (_) {
+    // The monorepo package is resolved below before it has been published.
+  }
+  candidates.push(
+    path.resolve(packageRoot, '..', packageName, 'package.json'),
+  );
+  return [...new Set(candidates)];
+}
+
+function resolvePackage(packageName, expectedVersion) {
+  for (const packageJsonPath of candidatePackageJsonPaths(packageName)) {
+    if (!fs.statSync(packageJsonPath, {throwIfNoEntry: false})?.isFile()) {
+      continue;
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    if (packageJson.name !== packageName) {
+      continue;
+    }
+    if (packageJson.version !== expectedVersion) {
+      throw new Error(
+        `${packageName}@${packageJson.version} does not match ` +
+          `react-native-pirate-wallet@${expectedVersion}`,
+      );
+    }
+    return path.dirname(packageJsonPath);
+  }
+  throw new Error(
+    `${packageName}@${expectedVersion} is required to build ` +
+      'react-native-pirate-wallet for iOS',
+  );
+}
+
+function linkTree(source, destination) {
+  fs.mkdirSync(destination, {recursive: true});
+  for (const entry of fs.readdirSync(source, {withFileTypes: true})) {
+    const sourcePath = path.join(source, entry.name);
+    const destinationPath = path.join(destination, entry.name);
+    if (entry.isDirectory()) {
+      linkTree(sourcePath, destinationPath);
+      continue;
+    }
+    if (!entry.isFile()) {
+      throw new Error(`Unsupported iOS package entry: ${sourcePath}`);
+    }
+    try {
+      fs.linkSync(sourcePath, destinationPath);
+    } catch (error) {
+      if (!['EXDEV', 'EPERM', 'EACCES', 'EMLINK'].includes(error.code)) {
+        throw error;
+      }
+      fs.copyFileSync(sourcePath, destinationPath);
+    }
+  }
+}
+
+function assemble() {
+  if (process.platform !== 'darwin' && !process.argv.includes('--force')) {
+    return;
+  }
+
+  const wrapperPackage = JSON.parse(
+    fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'),
+  );
+  const resolved = iosPackages.map(({name, slice}) => {
+    const expectedVersion = wrapperPackage.optionalDependencies?.[name];
+    if (expectedVersion !== wrapperPackage.version) {
+      throw new Error(`${name} must use the exact wrapper version`);
+    }
+    const root = resolvePackage(name, expectedVersion);
+    return {
+      name,
+      slice,
+      framework: path.join(root, 'ios', 'Frameworks', frameworkName),
+    };
+  });
+
+  const infoPlists = resolved.map(({framework}) =>
+    fs.readFileSync(path.join(framework, 'Info.plist')),
+  );
+  if (!infoPlists.slice(1).every(data => data.equals(infoPlists[0]))) {
+    throw new Error('iOS binary packages contain different XCFramework metadata');
+  }
+
+  const output = path.join(packageRoot, 'ios', 'Frameworks', frameworkName);
+  fs.rmSync(output, {recursive: true, force: true});
+  fs.mkdirSync(output, {recursive: true});
+  fs.writeFileSync(path.join(output, 'Info.plist'), infoPlists[0]);
+
+  for (const {name, slice, framework} of resolved) {
+    const source = path.join(framework, slice);
+    if (!fs.statSync(source, {throwIfNoEntry: false})?.isDirectory()) {
+      throw new Error(`${name} is missing XCFramework slice ${slice}`);
+    }
+    linkTree(source, path.join(output, slice));
+  }
+}
+
+assemble();

package/scripts/resolve-android-packages.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const androidPackageNames = [
+  'react-native-pirate-wallet-android',
+  'react-native-pirate-wallet-android-x86_64',
+];
+const packageRoot = path.resolve(__dirname, '..');
+
+function candidatePackageJsonPaths(packageName) {
+  const candidates = [];
+  try {
+    candidates.push(
+      require.resolve(`${packageName}/package.json`, {
+        paths: [process.cwd(), packageRoot],
+      }),
+    );
+  } catch (_) {
+    // The monorepo package is resolved below before it has been published.
+  }
+  candidates.push(
+    path.resolve(packageRoot, '..', packageName, 'package.json'),
+  );
+  return [...new Set(candidates)];
+}
+
+function resolveAndroidJniLibsPaths() {
+  const wrapperPackage = JSON.parse(
+    fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'),
+  );
+
+  return androidPackageNames.map(packageName => {
+    const expectedVersion =
+      wrapperPackage.optionalDependencies?.[packageName];
+
+    for (const packageJsonPath of candidatePackageJsonPaths(packageName)) {
+      if (!fs.statSync(packageJsonPath, {throwIfNoEntry: false})?.isFile()) {
+        continue;
+      }
+
+      const androidPackage = JSON.parse(
+        fs.readFileSync(packageJsonPath, 'utf8'),
+      );
+      if (androidPackage.name !== packageName) {
+        continue;
+      }
+      if (androidPackage.version !== expectedVersion) {
+        throw new Error(
+          `${packageName}@${androidPackage.version} does not match ` +
+            `react-native-pirate-wallet@${wrapperPackage.version}`,
+        );
+      }
+
+      const jniLibsPath = path.join(
+        path.dirname(packageJsonPath),
+        'android',
+        'src',
+        'main',
+        'jniLibs',
+      );
+      if (fs.statSync(jniLibsPath, {throwIfNoEntry: false})?.isDirectory()) {
+        return jniLibsPath;
+      }
+    }
+
+    throw new Error(
+      `${packageName}@${expectedVersion} is required to build ` +
+        'react-native-pirate-wallet for Android',
+    );
+  });
+}
+
+module.exports = {resolveAndroidJniLibsPaths};