react-native-zano 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# react-native-zano
+
+## Unreleased
+
+## 0.1.0 (2025-04-25)
+
+- Initial release

package/README.md

@@ -0,0 +1,56 @@
+# react-native-zano
+
+This library packages Zano C++ client for use on React Native.
+
+Supported platforms:
+
+- Android
+- iOS
+
+## Usage
+
+First, add this library to your React Native app using NPM or Yarn, and run `pod install` as necessary to integrate it with your app's native code.
+
+Here is a simple usage example:
+
+```js
+import { makeZano } from 'react-native-zano'
+
+const zano = makeZano()
+const version = await zano.getVersion()
+```
+
+We have types too, if you need those:
+
+```ts
+import type { CppBridge } from 'react-native-zano'
+```
+
+All methods available in Zano's `plain_wallet_api` are available here. In addition, there are convenience methods that provide higher-level abstractions by combining multiple raw asynchronous API calls and handling common error cases:
+
+- getSeedPhraseInfo - Returns information about a seed phrase
+- generateSeedPhrase - Creates a new seed phrase
+- startWallet - Opens an existing wallet or creates a new one if it doesn't exist
+- stopWallet - Safely closes a wallet
+- removeWallet - Deletes a wallet from the system
+- walletStatus - Gets the current status of a wallet
+- getBalances - Retrieves the balance information for a wallet
+- getTransactions - Fetches recent transactions for a wallet
+- whitelistAssets - Add assetIds to wallet's local whitelist
+- transfer - Sends funds to another wallet
+
+## Developing
+
+This library relies on a large amount of native C++ code from other repos. To integrate this code, you must run the following script before publishing this library to NPM:
+
+```sh
+npm run update-sources
+```
+
+This script does the following tasks:
+
+- Download third-party source code.
+- Compile shared libraries for Android.
+- Compile an iOS universal static library and put it into an XCFramework.
+
+The `update-sources` script is also the place to make edits when upgrading any of the third-party dependencies. The react-native-zano repo doesn't include these third-party C++ sources, since they are enormous.

package/android/build.gradle

@@ -0,0 +1,40 @@
+buildscript {
+  repositories {
+    mavenCentral()
+    google()
+  }
+
+  dependencies {
+    classpath 'com.android.tools.build:gradle:7.3.1'
+  }
+}
+
+apply plugin: 'com.android.library'
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+  compileSdkVersion safeExtGet('compileSdkVersion', 32)
+  defaultConfig {
+    minSdkVersion safeExtGet('minSdkVersion', 23)
+    targetSdkVersion safeExtGet('targetSdkVersion', 32)
+  }
+  lintOptions {
+    abortOnError false
+  }
+  namespace 'app.edge.rnzano'
+}
+
+repositories {
+  maven {
+    url('../node_modules/react-native/android')
+  }
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation 'com.facebook.react:react-native:+'
+}

package/android/src/main/java/app/edge/rnzano/RnZanoModule.java

@@ -0,0 +1,51 @@
+package app.edge.rnzano;
+
+import com.facebook.react.bridge.ReadableArray;
+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.util.HashMap;
+import java.util.Map;
+
+public class RnZanoModule extends ReactContextBaseJavaModule {
+  private native String callZanoJNI(String method, String[] arguments);
+
+  private native String[] getMethodNames();
+
+  static {
+    System.loadLibrary("rnzano");
+  }
+
+  public RnZanoModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public Map<String, Object> getConstants() {
+    final Map<String, Object> constants = new HashMap<>();
+    constants.put("methodNames", getMethodNames());
+    constants.put("documentDirectory", getReactApplicationContext().getFilesDir().getAbsolutePath());
+    return constants;
+  }
+
+  @Override
+  public String getName() {
+    return "ZanoModule";
+  }
+
+  @ReactMethod
+  public void callZano(String method, ReadableArray arguments, Promise promise) {
+    // Re-package the arguments:
+    String[] strings = new String[arguments.size()];
+    for (int i = 0; i < arguments.size(); ++i) {
+      strings[i] = arguments.getString(i);
+    }
+
+    try {
+      promise.resolve(callZanoJNI(method, strings));
+    } catch (Exception e) {
+      promise.reject("ZanoError", e);
+    }
+  }
+}

package/android/src/main/java/app/edge/rnzano/RnZanoPackage.java

@@ -0,0 +1,21 @@
+package app.edge.rnzano;
+
+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.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class RnZanoPackage implements ReactPackage {
+  @Override
+  public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+    return Arrays.<NativeModule>asList(new RnZanoModule(reactContext));
+  }
+
+  @Override
+  public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/ios/ZanoModule.h

@@ -0,0 +1,4 @@
+#import <React/RCTBridgeModule.h>
+
+@interface ZanoModule : NSObject <RCTBridgeModule>
+@end

package/ios/ZanoModule.mm

@@ -0,0 +1,86 @@
+#import "ZanoModule.h"
+#include "zano-methods.hpp"
+
+@implementation ZanoModule
+
+RCT_EXPORT_MODULE();
+
++ (BOOL)requiresMainQueueSetup { return NO; }
+
+RCT_REMAP_METHOD(
+  callZano,
+  callZanoMethod:(NSString *)method
+  arguments:(NSArray *)arguments
+  resolver:(RCTPromiseResolveBlock)resolve
+  rejecter:(RCTPromiseRejectBlock)reject
+) {
+  const std::string methodString = [method UTF8String];
+
+  // Re-package the arguments:
+  NSUInteger length = [arguments count];
+  std::vector<const std::string> strings;
+  strings.reserve(length);
+  for (NSUInteger i = 0; i < length; ++i) {
+    NSString *string = [arguments objectAtIndex:i];
+    strings.push_back([string UTF8String]);
+  }
+
+  // Find the named method:
+  for (int i = 0; i < zanoMethodCount; ++i) {
+    if (zanoMethods[i].name != methodString) continue;
+
+    // Validate the argument count:
+    if (zanoMethods[i].argc != strings.size()) {
+      reject(@"Error", @"zano incorrect C++ argument count", nil);
+      return;
+    }
+
+    // Call the method, with error handling:
+    try {
+      const std::string out = zanoMethods[i].method(strings);
+      resolve(
+        [NSString stringWithCString:out.c_str() encoding:NSUTF8StringEncoding]
+      );
+    } catch (std::exception e) {
+      reject(
+        @"Error",
+        [NSString stringWithCString:e.what() encoding:NSUTF8StringEncoding],
+        nil
+      );
+    } catch (...) {
+      reject(@"Error", @"zano threw a C++ exception", nil);
+    }
+    return;
+  }
+
+  reject(
+    @"TypeError",
+    [NSString stringWithFormat:@"No zano C++ method %@", method],
+    nil
+  );
+}
+
+- (NSDictionary *)constantsToExport
+{
+  NSMutableArray *out = [NSMutableArray arrayWithCapacity:zanoMethodCount];
+  for (int i = 0; i < zanoMethodCount; ++i) {
+    NSString *name = [NSString stringWithCString:zanoMethods[i].name
+      encoding:NSUTF8StringEncoding];
+    out[i] = name;
+  }
+  
+  NSFileManager *fileManager = [NSFileManager defaultManager];
+  NSURL *docsDir = [fileManager URLForDirectory:NSDocumentDirectory 
+    inDomain:NSUserDomainMask 
+    appropriateForURL:nil 
+    create:YES 
+    error:nil];
+  NSString *docsPath = [docsDir path];
+  
+  return @{ 
+    @"methodNames": out,
+    @"documentDirectory": docsPath
+  };
+}
+
+@end

package/ios/ZanoModule.xcframework/Info.plist

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libzano-module.a</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>libzano-module.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libzano-module.a</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>libzano-module.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/ios/react-native-zano.xcodeproj/project.pbxproj

@@ -0,0 +1 @@
+// Placeholder so react-native autolinking can find us.

package/lib/scripts/update-sources.d.ts

@@ -0,0 +1 @@
+export declare const srcPath: string;

package/lib/scripts/update-sources.js

@@ -0,0 +1,308 @@
+"use strict";
+// Run this script as `node -r sucrase/register ./scripts/update-sources.ts`
+//
+// It will:
+// - Download third-party source code.
+// - Assemble Android shared libraries for each platform.
+// - Assemble an iOS universal static xcframework.
+//
+// Here is where each puzzle piece comes from:
+//
+// |         | Zano  | OpenSSL           | Boost             |
+// |---------|-------|-------------------|-------------------|
+// | Android | CMake | zano_native_lib   | Boost-for-Android |
+// | iOS     | CMake | OpenSSL-Universal | zano_native_lib   |
+//
+// For both iOS and Android, we build Zano by invoking CMake directly.
+// The zano_native_lib build scripts aren't really useful,
+// since the aren't geared towards React Native auto-linking.
+// Calling CMake ourselves isn't that hard.
+//
+// On Android, the zano_native_lib OpenSSL libraries in are fine,
+// but we have to use Boost-for-Android to get the right STL version.
+//
+// On iOS, the boost libraries are fine,
+// but their OpenSSL is just a re-packaged copy OpenSSL-Universal,
+// so it's simpler to pull that in from CocoaPods directly.
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.srcPath = void 0;
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const path_1 = require("path");
+const android_tools_1 = require("./utils/android-tools");
+const common_1 = require("./utils/common");
+exports.srcPath = (0, path_1.join)(__dirname, '../src');
+async function main() {
+    await (0, promises_1.mkdir)(common_1.tmpPath, { recursive: true });
+    await downloadSources();
+    // Android:
+    await buildAndroidBoost();
+    for (const platform of androidPlatforms) {
+        await buildAndroidZano(platform);
+    }
+    // iOS:
+    for (const platform of iosPlatforms) {
+        await buildIosZano(platform);
+    }
+    await packageIosZano();
+}
+async function downloadSources() {
+    await (0, common_1.getRepo)('zano_native_lib', 'https://github.com/hyle-team/zano_native_lib.git', '391a965d1d609f917cc97908b9d354a7f54e0258');
+    await (0, common_1.getRepo)('Boost-for-Android', 'https://github.com/moritz-wundke/Boost-for-Android.git', '51924ec5533a4fefb5edf99feaeded794c06a4fb');
+}
+// Compiler options:
+const includePaths = ['zano_native_lib/Zano/src/wallet'];
+// Source list (from src/):
+const sources = ['zano-wrapper/zano-methods.cpp'];
+// .a files from Zano:
+const zanoLibs = ['common', 'crypto', 'currency_core', 'wallet', 'z'];
+// .a files from boost:
+const boostLibs = [
+    'atomic',
+    'chrono',
+    'date_time',
+    'filesystem',
+    'program_options',
+    'regex',
+    'serialization',
+    'system',
+    'thread',
+    'timer'
+];
+const androidPlatforms = [
+    { arch: 'arm64-v8a', triple: 'aarch64-linux-android33' },
+    { arch: 'armeabi-v7a', triple: 'armv7a-linux-androideabi23' },
+    { arch: 'x86', triple: 'i686-linux-android23' },
+    { arch: 'x86_64', triple: 'x86_64-linux-android23' }
+];
+// Phones and simulators we need to support:
+const iosPlatforms = [
+    { sdk: 'iphoneos', arch: 'arm64', cmakePlatform: 'OS64' },
+    { sdk: 'iphonesimulator', arch: 'arm64', cmakePlatform: 'SIMULATORARM64' },
+    { sdk: 'iphonesimulator', arch: 'x86_64', cmakePlatform: 'SIMULATOR64' }
+    // Zano does not support these:
+    // { sdk: 'iphoneos', arch: 'armv7' },
+    // { sdk: 'iphoneos', arch: 'armv7s' },
+];
+const iosSdkTriples = {
+    iphoneos: '%arch%-apple-ios9.0',
+    iphonesimulator: '%arch%-apple-ios9.0-simulator'
+};
+/**
+ * We compile our own Boost for Android,
+ * because the Zano one is linking with the static STL library,
+ * but we need to link with the shared STL library.
+ */
+async function buildAndroidBoost() {
+    const boostExists = await (0, common_1.fileExists)((0, path_1.join)(common_1.tmpPath, 'Boost-for-Android/build/out/arm64-v8a/lib/libboost_atomic.a'));
+    if (boostExists)
+        return;
+    const ndkPath = await (0, android_tools_1.getNdkPath)();
+    await (0, common_1.loudExec)('./build-android.sh', [
+        `--arch=${androidPlatforms.map(platform => platform.arch).join(',')}`,
+        '--boost=1.84.0',
+        `--with-libraries=${boostLibs.join(',')}`,
+        '--layout=system',
+        ndkPath
+    ], { cwd: (0, path_1.join)(common_1.tmpPath, 'Boost-for-Android') });
+}
+/**
+ * Invokes CMake to build Zano,
+ * followed by clang++ to build the shared library.
+ */
+async function buildAndroidZano(platform) {
+    const { arch, triple } = platform;
+    const ndkPath = await (0, android_tools_1.getNdkPath)();
+    const working = (0, path_1.join)(common_1.tmpPath, `android-${arch}`);
+    const boostPath = (0, path_1.join)(common_1.tmpPath, 'Boost-for-Android/build/out/', arch);
+    const sslPath = (0, path_1.join)(common_1.tmpPath, 'zano_native_lib/_libs_android/openssl');
+    const zanoLibPath = (0, path_1.join)(common_1.tmpPath, `android-${arch}/${arch}/lib/`);
+    // Build Zano itself:
+    await (0, common_1.loudExec)('cmake', [
+        // Source directory:
+        `-S${(0, path_1.join)(common_1.tmpPath, 'zano_native_lib/Zano')}`,
+        // Build directory:
+        `-B${(0, path_1.join)(working, 'cmake')}`,
+        // Build options:
+        `-DBoost_INCLUDE_DIRS=${(0, path_1.join)(boostPath, 'include')}`,
+        `-DBoost_LIBRARY_DIRS=${(0, path_1.join)(boostPath, 'lib')}`,
+        `-DBoost_VERSION="1.84.0"`,
+        `-DCMAKE_ANDROID_ARCH_ABI=${arch}`,
+        `-DCMAKE_ANDROID_NDK=${ndkPath}`,
+        `-DCMAKE_ANDROID_STL_TYPE=c++_shared`,
+        `-DCMAKE_BUILD_TYPE=Release`,
+        `-DCMAKE_INSTALL_PREFIX=${working}`,
+        `-DCMAKE_SYSTEM_NAME=Android`,
+        `-DCMAKE_SYSTEM_VERSION=23`,
+        `-DDISABLE_TOR=TRUE`,
+        `-DOPENSSL_CRYPTO_LIBRARY=${(0, path_1.join)(sslPath, arch, 'lib/libcrypto.a')}`,
+        `-DOPENSSL_INCLUDE_DIR=${(0, path_1.join)(sslPath, 'include')}`,
+        `-DOPENSSL_SSL_LIBRARY=${(0, path_1.join)(sslPath, arch, 'lib/libssl.a')}`
+    ]);
+    await (0, common_1.loudExec)('cmake', [
+        '--build',
+        (0, path_1.join)(working, 'cmake'),
+        '--config',
+        'Release',
+        '--target',
+        'install',
+        '--',
+        `-j${(0, os_1.cpus)().length}`
+    ]);
+    // Build the library:
+    const cxxPath = (0, path_1.join)(ndkPath, `toolchains/llvm/prebuilt/darwin-x86_64/bin/${triple}-clang++`);
+    const outPath = (0, path_1.join)(common_1.tmpPath, '../android/src/main/jniLibs/', arch);
+    await (0, promises_1.mkdir)(outPath, { recursive: true });
+    const jniSources = [...sources, 'jni/jni.cpp'];
+    const sslLibs = ['crypto', 'ssl'];
+    console.log(`Linking librnzano.so for Android ${arch}`);
+    await (0, common_1.loudExec)(cxxPath, [
+        '-shared',
+        '-fPIC',
+        `-o${(0, path_1.join)(outPath, 'librnzano.so')}`,
+        ...includePaths.map(path => `-I${(0, path_1.join)(common_1.tmpPath, path)}`),
+        ...jniSources.map(source => (0, path_1.join)(exports.srcPath, source)),
+        ...boostLibs.map(name => (0, path_1.join)(boostPath, `/lib/libboost_${name}.a`)),
+        ...sslLibs.map(name => (0, path_1.join)(sslPath, `${arch}/lib/lib${name}.a`)),
+        ...zanoLibs.map(name => (0, path_1.join)(zanoLibPath, `lib${name}.a`)),
+        '-llog',
+        `-Wl,--version-script=${(0, path_1.join)(exports.srcPath, 'jni/exports.map')}`,
+        '-Wl,--no-undefined'
+    ]);
+}
+/**
+ * Invokes CMake to build Zano, then breaks open the resulting .a files
+ * and re-assembles them into one giant .a file.
+ */
+async function buildIosZano(platform) {
+    const { sdk, arch, cmakePlatform } = platform;
+    const working = (0, path_1.join)(common_1.tmpPath, `${sdk}-${arch}`);
+    await (0, promises_1.mkdir)(working, { recursive: true });
+    // Find platform tools:
+    const ar = await (0, common_1.quietExec)('xcrun', ['--sdk', sdk, '--find', 'ar']);
+    const cc = await (0, common_1.quietExec)('xcrun', ['--sdk', sdk, '--find', 'clang']);
+    const cxx = await (0, common_1.quietExec)('xcrun', ['--sdk', sdk, '--find', 'clang++']);
+    const sdkFlags = [
+        '-arch',
+        arch,
+        '-target',
+        iosSdkTriples[sdk].replace('%arch%', arch),
+        '-isysroot',
+        await (0, common_1.quietExec)('xcrun', ['--sdk', sdk, '--show-sdk-path'])
+    ];
+    const cflags = [
+        ...includePaths.map(path => `-I${(0, path_1.join)(common_1.tmpPath, path)}`),
+        '-miphoneos-version-min=9.0',
+        '-O2',
+        '-Werror=partial-availability'
+    ];
+    const cxxflags = [...cflags, '-std=c++11'];
+    // Compile our sources:
+    const objects = [];
+    for (const source of sources) {
+        console.log(`Compiling ${source} for ${sdk}-${arch}...`);
+        // Figure out the object file name:
+        const object = (0, path_1.join)(working, source.replace(/^.*\//, '').replace(/\.c$|\.cc$|\.cpp$/, '.o'));
+        objects.push(object);
+        const useCxx = /\.cpp$|\.cc$/.test(source);
+        await (0, common_1.loudExec)(useCxx ? cxx : cc, [
+            '-c',
+            ...(useCxx ? cxxflags : cflags),
+            ...sdkFlags,
+            `-o${object}`,
+            (0, path_1.join)(exports.srcPath, source)
+        ]);
+    }
+    // Build Zano itself:
+    const boostPath = (0, path_1.join)(common_1.tmpPath, `zano_native_lib/_libs_ios/boost`);
+    const sslPath = (0, path_1.join)(common_1.tmpPath, `zano_native_lib/_libs_ios/OpenSSL/${sdk}`);
+    const iosToolchain = (0, path_1.join)(common_1.tmpPath, 'zano_native_lib/ios-cmake/ios.toolchain.cmake');
+    await (0, common_1.loudExec)('cmake', [
+        // Source directory:
+        `-S${(0, path_1.join)(common_1.tmpPath, 'zano_native_lib/Zano')}`,
+        // Build directory:
+        `-B${(0, path_1.join)(working, 'cmake')}`,
+        // Build options:
+        `-DBoost_INCLUDE_DIRS=${(0, path_1.join)(boostPath, 'include')}`,
+        `-DBoost_LIBRARY_DIRS=${(0, path_1.join)(boostPath, `stage/${sdk}/${arch}`)}`,
+        `-DBoost_VERSION="1.84.0"`,
+        `-DCMAKE_BUILD_TYPE=Release`,
+        `-DCMAKE_INSTALL_PREFIX=${working}`,
+        `-DCMAKE_SYSTEM_NAME=iOS`,
+        `-DCMAKE_TOOLCHAIN_FILE=${iosToolchain}`,
+        `-DCMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH=NO`,
+        `-DDISABLE_TOR=TRUE`,
+        `-DOPENSSL_CRYPTO_LIBRARY=${(0, path_1.join)(sslPath, 'lib/libcrypto.a')}`,
+        `-DOPENSSL_INCLUDE_DIR=${(0, path_1.join)(sslPath, 'include')}`,
+        `-DOPENSSL_SSL_LIBRARY=${(0, path_1.join)(sslPath, 'lib/libssl.a')}`,
+        `-DPLATFORM=${cmakePlatform}`,
+        `-GXcode`
+    ]);
+    await (0, common_1.loudExec)('cmake', [
+        '--build',
+        (0, path_1.join)(working, 'cmake'),
+        '--config',
+        'Release',
+        '--target',
+        'install'
+    ]);
+    // Explode Zano archives and gather the objects:
+    async function unpackLib(libPath, name) {
+        console.log(`Unpacking lib${name}.a`);
+        const outPath = (0, path_1.join)(working, `unpack/${name}`);
+        await (0, promises_1.rm)(outPath, { recursive: true, force: true });
+        await (0, promises_1.mkdir)(outPath, { recursive: true });
+        await (0, common_1.loudExec)('ar', ['-x', libPath], { cwd: outPath });
+        // Add object files to the list:
+        for (const file of await (0, promises_1.readdir)(outPath)) {
+            if (file.endsWith('.o'))
+                objects.push((0, path_1.join)(outPath, file));
+        }
+    }
+    for (const lib of zanoLibs) {
+        await unpackLib((0, path_1.join)(working, `lib/lib${lib}.a`), lib);
+    }
+    for (const lib of boostLibs) {
+        await unpackLib((0, path_1.join)(common_1.tmpPath, `zano_native_lib/_libs_ios/boost/stage/${sdk}/${arch}/libboost_${lib}.a`), `boost_${lib}`);
+    }
+    // Generate a static library:
+    console.log(`Building static library for ${sdk}-${arch}...`);
+    const library = (0, path_1.join)(working, `libzano-module.a`);
+    await (0, promises_1.rm)(library, { force: true });
+    await (0, common_1.loudExec)(ar, ['rcs', library, ...objects]);
+}
+/**
+ * Creates a unified xcframework file out of the per-platform
+ * static libraries that `buildIosZano` creates.
+ */
+async function packageIosZano() {
+    const sdks = new Set(iosPlatforms.map(row => row.sdk));
+    // Merge the platforms into a fat library:
+    const merged = [];
+    for (const sdk of sdks) {
+        console.log(`Merging libraries for ${sdk}...`);
+        const outPath = (0, path_1.join)(common_1.tmpPath, `${sdk}-lipo`);
+        await (0, promises_1.mkdir)(outPath, { recursive: true });
+        const output = (0, path_1.join)(outPath, 'libzano-module.a');
+        await (0, common_1.loudExec)('lipo', [
+            '-create',
+            '-output',
+            output,
+            ...iosPlatforms
+                .filter(platform => platform.sdk === sdk)
+                .map(({ sdk, arch }) => (0, path_1.join)(common_1.tmpPath, `${sdk}-${arch}`, `libzano-module.a`))
+        ]);
+        merged.push('-library', output);
+    }
+    // Bundle those into an XCFramework:
+    console.log('Creating XCFramework...');
+    await (0, promises_1.rm)('ios/ZanoModule.xcframework', { recursive: true, force: true });
+    await (0, common_1.loudExec)('xcodebuild', [
+        '-create-xcframework',
+        ...merged,
+        '-output',
+        (0, path_1.join)(__dirname, '../ios/ZanoModule.xcframework')
+    ]);
+}
+main().catch(error => console.log(error));

package/lib/scripts/utils/android-tools.d.ts

@@ -0,0 +1 @@
+export declare function getNdkPath(): Promise<string>;

package/lib/scripts/utils/android-tools.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNdkPath = void 0;
+const path_1 = require("path");
+const common_1 = require("./common");
+// Matches the Edge app NDK version
+// The Zano build used '27.2.12479018', so we could try upgrading.
+const NDK_VERSION = '26.1.10909125';
+async function getNdkPath() {
+    const { ANDROID_HOME } = process.env;
+    if (ANDROID_HOME == null) {
+        throw new Error('ANDROID_HOME is not set in the environment.');
+    }
+    // Find the NDK:
+    const ndkPath = (0, path_1.join)(ANDROID_HOME, 'ndk', NDK_VERSION);
+    const hasNdk = await (0, common_1.fileExists)(ndkPath);
+    // Install the NDK if we need it:
+    if (!hasNdk) {
+        console.log(`Installing NDK ${NDK_VERSION}...`);
+        const sdkManagerPath = (0, path_1.join)(ANDROID_HOME, 'cmdline-tools/latest/bin/sdkmanager');
+        await (0, common_1.loudExec)(sdkManagerPath, [`"ndk;${NDK_VERSION}"`]);
+    }
+    return ndkPath;
+}
+exports.getNdkPath = getNdkPath;