zano-native 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,90 @@
+# zano-native
+
+## Unreleased
+
+## 0.5.1 (2026-08-28)
+
+- changed: `getTransactions` queries `get_recent_txs_and_info3`, the HF6-ready history endpoint. The old endpoint reported only the deprecated transaction-wide payment id - an empty string for every id created since HF6, when ids moved into individual outputs - and its legacy serializer refuses entries that carry more than one distinct per-output id, which the HF6 migration guide says to expect. `RecentTransaction` now exposes `subtransfers_by_pid`, amounts grouped by hex payment id, in place of the flat `subtransfers` list and the always-stale `payment_id` field, along with the sender-recorded `remote_addresses`.
+- fixed: Android runs native Zano calls on a dedicated thread instead of React Native's shared native-modules thread. On the legacy architecture that shared thread also executes UIManager's view commands, so a Zano call that blocked in C++ froze every view update in the app - taps dead, screens frozen - while native scrolling kept working. A blocked call now stalls only Zano.
+- fixed: Closing a wallet while it is catching up on blocks no longer deadlocks the native wallet manager permanently on Android. The SDK's `close_wallet` held the wallet-manager lock while waiting out the wallet's refresh worker, which needed that same lock to reach its stop flags, so the close, the worker, and every Zano call after them hung forever; the app's periodic mid-sync saves tripped this within minutes of importing a wallet. The Android build now rewrites `close_wallet` to detach the wallet from the manager before waiting on it. iOS links the prebuilt Zano framework and runs the same cycle without wedging, so it is unchanged.
+- fixed: A Zano wallet file the SDK cannot read - typically zero bytes, left by a crash during the file's very first write - no longer traps the wallet in a permanent open-retry loop. Such a file fails with `INVALID_FILE` before any password is consulted, which bypassed the password-recovery ladder entirely, so the engine retried the same doomed open every second forever. The file is now deleted and rebuilt from the mnemonic, costing one re-scan, under the same policy as a file no password opens: a wallet with a seed passphrase still refuses, since an unreadable file cannot corroborate the passphrase and a wrong one would rebuild a different wallet.
+
+## 0.5.0 (2026-08-25)
+
+- added: `runWallet`, which starts the refresh worker for an open wallet. `startWallet` rethrows `ALREADY_EXISTS` for its caller to adopt the already-open wallet, and an adopted wallet does not sync until it is run, so adopting callers need this without reimplementing the raw `run_wallet` response contract.
+- changed: `transfer` no longer takes a `paymentId`, and never sends the request-level payment id. Zano HF6 deprecated the transaction-wide payment id -- the node rejects any non-empty value -- and instead delivers payment ids per destination, embedded in integrated addresses, which the wallet attaches natively. Forwarding the option therefore failed every send that carried one. A caller holding a separate payment id must fold it into an integrated destination address before calling. The per-destination address-info loop is also gone: it read fields the native `get_address_info` has never returned, so it never did anything except spend a native round-trip per recipient.
+- changed: The `AddressInfo` type now matches the native response: `payment_id` is a boolean presence flag, and `is_integrated` does not exist. Both were previously declared with shapes no native version ever produced.
+- fixed: `startWallet` no longer freezes the app while a wallet catches up on blocks. Opening a wallet auto-started its refresh worker, which holds the per-wallet lock for the entire first scan, so the 0.4.0 re-key migration's `resetWalletPassword` blocked on that lock for the whole catch-up (minutes to hours) while sitting on React Native's shared native-module queue, and on iOS every native call in the app queued behind it. Wallets now open with the refresh worker postponed, the migration completes in milliseconds, and the worker is started explicitly for the one wallet `startWallet` returns.
+- fixed: Creating a wallet no longer freezes the app. `generateSeedPhrase` opened its temporary wallet without postponing the refresh worker, so the `closeWallet` that follows waited on the per-wallet lock, on the shared native-module queue, for the length of a refresh. A close that does not report OK now fails the call rather than deleting a file this process still holds open.
+- fixed: The iOS module now withholds its document directory when the wallet directory cannot be created or excluded from device backups, so the bridge fails at construction instead of letting the SDK write seed and spend keys somewhere a backup would capture.
+
+## 0.4.0 (2026-08-14)
+
+- added: `startWallet` accepts an optional `log` callback that reports wallet-file recovery and migration events.
+- added: A `ZanoError` class carrying the native API return code as `error.code`. Thrown error messages keep their existing `<code> <message>` shape.
+- added: A unit-test suite (`npm test`) that runs the bridge against a fake native module.
+- added: `update-sources.ts` fails the build if the Zano SDK declares a directory this package does not create and exclude from backups, so bumping the SDK pin cannot silently introduce an unprotected one.
+- changed: Update `zano_native_lib` to `91085c0` for Zano HF6 support.
+- changed: Build the iOS library against the prebuilt `libzano-plain-wallet` xcframework, since `zano_native_lib` no longer ships the raw `_libs_ios` OpenSSL and Boost archives.
+- changed: Fetch only the pinned commit and the Git LFS objects we build against, instead of cloning the full history along with every platform's prebuilt archives.
+- fixed: Native failures reported as success-shaped payloads (`INTERNAL_ERROR`, `UNINITIALIZED`) now throw instead of resolving with a wallet whose `wallet_id` is undefined.
+- fixed: `generateSeedPhrase` no longer leaves a temporary wallet file on disk, encrypted with the seed passphrase, as a side effect of generating a seed.
+- security: `startWallet` now encrypts the wallet file with a password derived from the mnemonic, instead of with the seed passphrase, which is the empty string for most wallets, leaving the seed and spend keys effectively unencrypted on disk. Files written by earlier versions are re-keyed in place the first time they open. A file that no known password opens is deleted and rebuilt from the mnemonic, costing one re-scan, unless the wallet has a seed passphrase. That case throws instead, since a passphrase that does not match the file would otherwise rebuild a different wallet over an intact one.
+- security: Exclude every iOS directory the SDK writes into -- `wallets`, `logs` and `app_config` -- from device backups, so the wallet files no longer reach an unencrypted Finder backup. Android stores these in private app storage and already sets `android:allowBackup="false"`.
+
+## 0.3.0 (2026-06-13)
+
+- changed: Convert the build tooling from Yarn to npm.
+- security: Upgrade dependencies per Socket security recommendations.
+
+## 0.2.8 (2026-02-23)
+
+- fixed: Remove invalid const qualifier from std::vector element types to fix Xcode 26 builds
+
+## 0.2.7 (2026-02-15)
+
+- fixed: Add missing `wrap` and `auditable` fields to `AddressInfo` type
+
+## 0.2.6 (2026-01-29)
+
+- changed: Update `zano_native_lib` to `239d4a39`
+
+## 0.2.5 (2025-11-17)
+
+- fixed: Show proper messages for C++ errors.
+
+## 0.2.4 (2025-09-19)
+
+- fixed: Re-publish with correctly-built binaries.
+
+## 0.2.3 (2025-09-18)
+
+- fixed: Fix `burnAsset` return value and types
+
+## 0.2.2 (2025-09-09)
+
+- added: Add `burnAsset` method
+
+## 0.2.1 (2025-07-21)
+
+- fixed: Support 16k pages for Android 15.
+
+## 0.2.0 (2025-05-26)
+
+- changed: `transfer` now accepts an array of destinations.
+
+## 0.1.3 (2025-05-05)
+
+- fixed: Shield symbols for iOS builds using partial linking and symbol encapsulation.
+
+## 0.1.2 (2025-04-29)
+
+- fixed: Republish with missing .so files
+
+## 0.1.1 (2025-04-25)
+
+- fixed: package.json types path
+
+## 0.1.0 (2025-04-25)
+
+- Initial release

package/LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2026 Airbitz, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+This package wraps Zano, which is MIT, and ships binaries compiled from it.
+Boost, OpenSSL and the other C++ dependencies the build fetches are also
+compiled in and remain under their own licenses.

package/README.md

@@ -0,0 +1,24 @@
+# zano-native
+
+Native Zano wallet library for React Native and Node.js.
+
+The compiled SDK lives in this package. React Native and Node are hosts.
+
+- GitHub: [EdgeApp/zano-native](https://github.com/EdgeApp/zano-native)
+- npm: `zano-native`
+
+## React Native
+
+```js
+import { makeZano } from 'zano-native'
+```
+
+Mobile binaries: `npm run update-sources`. Not run on `npm install`.
+
+## Node (CLI)
+
+```js
+import { makeNodeZanoModule } from 'zano-native/node'
+```
+
+Host addon: `npm run build-native-host` (explicit; `prepare` / `prepack` compile JavaScript only).

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,73 @@
+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;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class RnZanoModule extends ReactContextBaseJavaModule {
+  // Zano calls run on their own thread, never on the caller's. On the
+  // legacy architecture every @ReactMethod runs on the shared
+  // mqt_native_modules thread, which also executes UIManager's view
+  // commands - so a Zano call that blocks in C++ (a close waiting out a
+  // scan chunk, or the SDK's close-during-scan lock inversion) froze every
+  // view update in the app. Static, because the Zano SDK is one instance
+  // per process while React module instances are not: a JS reload builds a
+  // new module while a call from the old one may still be draining, and
+  // per-instance threads would let both drive the SDK at once. One
+  // process-wide thread keeps the strict global call ordering, across
+  // reloads too. Named, because this freeze was diagnosed from thread
+  // dumps, and "pool-1-thread-1" will not identify itself in the next one.
+  private static final ExecutorService executor =
+      Executors.newSingleThreadExecutor(r -> new Thread(r, "zano"));
+
+  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);
+    }
+
+    executor.execute(() -> {
+      try {
+        promise.resolve(callZanoJNI(method, strings));
+      } catch (Throwable e) {
+        // Throwable, not Exception: off the bridge thread an escaping Error
+        // reaches the default uncaught handler and kills the process with
+        // the promise unsettled; RN's own dispatcher used to catch it.
+        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,138 @@
+#import "ZanoModule.h"
+#import <React/RCTLog.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<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
+  );
+}
+
+/**
+ * Creates a directory the Zano SDK writes into, and keeps it out of
+ * device backups. The wallet files hold the seed and spend keys, so they
+ * must not reach an unencrypted Finder backup.
+ *
+ * The SDK creates these itself on first use, but only we can set the
+ * backup flag, and that requires the directory to already exist.
+ */
+static BOOL prepareZanoDirectory(NSURL *parent, NSString *name)
+{
+  NSURL *url = [parent URLByAppendingPathComponent:name isDirectory:YES];
+
+  NSError *error = nil;
+  if (![[NSFileManager defaultManager] createDirectoryAtURL:url
+        withIntermediateDirectories:YES
+        attributes:nil
+        error:&error]) {
+    RCTLogWarn(@"zano could not create %@: %@", name, error);
+    return NO;
+  }
+
+  if (![url setResourceValue:@YES
+        forKey:NSURLIsExcludedFromBackupKey
+        error:&error]) {
+    RCTLogWarn(@"zano could not exclude %@ from backups: %@", name, error);
+    return NO;
+  }
+
+  return YES;
+}
+
+- (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];
+  NSError *docsError = nil;
+  NSURL *docsDir = [fileManager URLForDirectory:NSDocumentDirectory
+    inDomain:NSUserDomainMask
+    appropriateForURL:nil
+    create:YES
+    error:&docsError];
+  if (docsDir == nil) {
+    RCTLogWarn(@"zano could not resolve the documents directory: %@", docsError);
+    return @{ @"methodNames": out };
+  }
+
+  // Every directory the SDK derives from the working directory we hand it.
+  // `scripts/update-sources.ts` fails the build if this list drifts from the
+  // folder names declared in the SDK's `plain_wallet_api.cpp`.
+  //
+  // `wallets` holds the seed and spend keys, so failing to create it or to
+  // mark it excluded from backups is fatal: withholding
+  // `documentDirectory` stops the bridge in its constructor instead of
+  // letting the SDK write keys somewhere an unencrypted Finder backup would
+  // pick up. `logs` and `app_config` carry no key material.
+  BOOL walletsReady = prepareZanoDirectory(docsDir, @"wallets");
+  prepareZanoDirectory(docsDir, @"logs");
+  prepareZanoDirectory(docsDir, @"app_config");
+  if (!walletsReady) {
+    return @{ @"methodNames": out };
+  }
+
+  return @{
+    @"methodNames": out,
+    @"documentDirectory": [docsDir path]
+  };
+}
+
+@end

package/ios/ZanoModule.xcframework/Info.plist

@@ -0,0 +1,43 @@
+<?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-simulator</string>
+			<key>LibraryPath</key>
+			<string>libzano-module.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</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/build-native-host.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/scripts/build-native-host.js

@@ -0,0 +1,175 @@
+"use strict";
+// Run this script as `node -r sucrase/register ./scripts/build-native-host.ts`
+//
+// Builds a Node N-API addon for the current host:
+// - Fetches zano_native_lib (macOS plain-wallet xcframework via Git LFS)
+// - Compiles zano-methods.cpp and relocatable-links against the prebuilt
+// - Archives to zano-module.a, then node-gyp produces
+//   prebuilds/<platform>-<arch>/zano.node
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const common_1 = require("./utils/common");
+const ios_tools_1 = require("./utils/ios-tools");
+const srcPath = (0, path_1.join)(__dirname, '../src');
+const zanoNativeHash = '91085c0ebd95fcdae3327071a9e5f5b615d7da3d';
+/**
+ * Locates the slice of a prebuilt macOS xcframework that matches this arch.
+ */
+async function findMacosXcframeworkSlice(frameworkPath, arch) {
+    const plist = JSON.parse(await (0, common_1.captureExec)('plutil', [
+        '-convert',
+        'json',
+        '-o',
+        '-',
+        (0, path_1.join)(frameworkPath, 'Info.plist')
+    ]));
+    const slice = plist.AvailableLibraries.find(library => library.SupportedPlatform === 'macos' &&
+        library.SupportedArchitectures.includes(arch));
+    if (slice == null) {
+        throw new Error(`${frameworkPath} has no macos slice for ${arch}. It offers: ${plist.AvailableLibraries.map(library => library.LibraryIdentifier).join(', ')}`);
+    }
+    const slicePath = (0, path_1.join)(frameworkPath, slice.LibraryIdentifier);
+    const libraryPath = (0, path_1.join)(slicePath, slice.LibraryPath);
+    const archs = (await (0, common_1.captureExec)('lipo', ['-archs', libraryPath])).split(/\s+/);
+    if (!archs.includes(arch)) {
+        throw new Error(`${libraryPath} holds ${archs.join(', ')}, but we are building ${arch}`);
+    }
+    return {
+        headersPath: (0, path_1.join)(slicePath, slice.HeadersPath ?? 'Headers'),
+        libraryPath
+    };
+}
+async function downloadSources() {
+    await (0, common_1.getRepo)('zano_native_lib', 'https://github.com/hyle-team/zano_native_lib.git', zanoNativeHash, 
+    // Host builds only need the macOS plain-wallet prebuild (+ headers inside):
+    { lfsIncludes: ['_install_macosx/**'] });
+    // Rename the compress function in RIPEMD160.c,
+    // since that conflicts with Zlib (same patch as update-sources.ts):
+    const mdPath = (0, path_1.join)(common_1.tmpPath, 'zano_native_lib/Zano/src/crypto/RIPEMD160.h');
+    if (await (0, common_1.fileExists)(mdPath)) {
+        const mdText = await (0, promises_1.readFile)(mdPath, 'utf8');
+        if (!mdText.includes('#define compress md_compress')) {
+            await (0, promises_1.writeFile)(mdPath, '#define compress md_compress\n' + mdText);
+        }
+    }
+}
+/**
+ * Compiles the wrapper and links it against the prebuilt macOS
+ * libzano-plain-wallet static library into zano-module.a.
+ */
+async function buildHostStaticLib(arch) {
+    const working = (0, path_1.join)(common_1.tmpPath, `host-darwin-${arch}`);
+    await (0, promises_1.mkdir)(working, { recursive: true });
+    const { headersPath, libraryPath: zanoLib } = await findMacosXcframeworkSlice((0, path_1.join)(common_1.tmpPath, 'zano_native_lib/_install_macosx/libzano-plain-wallet.xcframework'), arch);
+    const ar = await (0, common_1.quietExec)('xcrun', ['--find', 'ar']);
+    const cxx = await (0, common_1.quietExec)('xcrun', ['--find', 'clang++']);
+    const ld = await (0, common_1.quietExec)('xcrun', ['--find', 'ld']);
+    const objcopy = await (0, ios_tools_1.getObjcopyPath)();
+    const sysroot = await (0, common_1.quietExec)('xcrun', ['--show-sdk-path']);
+    const sdkFlags = [
+        '-arch',
+        arch,
+        '-isysroot',
+        sysroot,
+        '-mmacosx-version-min=11.0'
+    ];
+    const cxxflags = [
+        `-I${headersPath}`,
+        '-O2',
+        '-std=c++17',
+        '-fPIC',
+        '-fexceptions'
+    ];
+    const source = 'zano-wrapper/zano-methods.cpp';
+    const object = (0, path_1.join)(working, 'zano-methods.o');
+    console.log(`Compiling ${source} for host-darwin-${arch}...`);
+    await (0, common_1.loudExec)(cxx, [
+        '-c',
+        ...cxxflags,
+        ...sdkFlags,
+        `-o${object}`,
+        (0, path_1.join)(srcPath, source)
+    ]);
+    // Relocatable link against the prebuilt plain-wallet archive
+    // (same approach as iOS in update-sources.ts):
+    console.log(`Linking zano-module.o for host-darwin-${arch}`);
+    const objectPath = (0, path_1.join)(working, 'zano-module.o');
+    await (0, common_1.loudExec)(ld, [
+        '-r',
+        '-arch',
+        arch,
+        '-o',
+        objectPath,
+        object,
+        zanoLib
+    ]);
+    // Localize all symbols except the ones we export to the N-API addon:
+    await (0, common_1.loudExec)(objcopy, [
+        objectPath,
+        '-w',
+        '-L*',
+        '-L!_zanoMethods',
+        '-L!_zanoMethodCount'
+    ]);
+    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, objectPath]);
+    console.log(`Built ${library}`);
+    return library;
+}
+async function buildNodeAddon(staticLib) {
+    const prebuildDir = (0, path_1.join)(__dirname, '../prebuilds', `${process.platform}-${process.arch}`);
+    await (0, promises_1.mkdir)(prebuildDir, { recursive: true });
+    const napiInclude = String(
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    require((0, path_1.join)(__dirname, '../node_modules/node-addon-api')).include).replace(/"/g, '');
+    const gypDir = (0, path_1.join)(common_1.tmpPath, 'nodeaddon');
+    await (0, promises_1.mkdir)(gypDir, { recursive: true });
+    // node-gyp/make cannot compile sources given as absolute paths.
+    await (0, promises_1.copyFile)((0, path_1.join)(__dirname, '../src/node/zano-napi.cpp'), (0, path_1.join)(gypDir, 'zano-napi.cpp'));
+    const gyp = {
+        targets: [
+            {
+                target_name: 'zano',
+                sources: ['zano-napi.cpp'],
+                include_dirs: [napiInclude, (0, path_1.join)(__dirname, '../src/zano-wrapper')],
+                defines: ['NAPI_CPP_EXCEPTIONS'],
+                'cflags!': ['-fno-exceptions'],
+                'cflags_cc!': ['-fno-exceptions'],
+                cflags_cc: ['-std=c++17', '-fPIC'],
+                libraries: [staticLib],
+                xcode_settings: {
+                    GCC_ENABLE_CPP_EXCEPTIONS: 'YES',
+                    CLANG_CXX_LANGUAGE_STANDARD: 'c++17',
+                    MACOSX_DEPLOYMENT_TARGET: '11.0',
+                    OTHER_LDFLAGS: ['-lc++', '-lz']
+                }
+            }
+        ]
+    };
+    await (0, promises_1.writeFile)((0, path_1.join)(gypDir, 'binding.gyp'), JSON.stringify(gyp, null, 2));
+    const nodeGyp = (0, path_1.join)(__dirname, '../node_modules/.bin/node-gyp');
+    await (0, common_1.loudExec)(nodeGyp, ['rebuild'], { cwd: gypDir });
+    const built = (0, path_1.join)(gypDir, 'build/Release/zano.node');
+    await (0, common_1.loudExec)('cp', [built, (0, path_1.join)(prebuildDir, 'zano.node')]);
+    // Remove local and debug symbols. The addon is loaded through its
+    // registration entry point, which is global and survives `-x`.
+    await (0, common_1.loudExec)('strip', ['-x', (0, path_1.join)(prebuildDir, 'zano.node')]);
+    console.log(`Wrote ${(0, path_1.join)(prebuildDir, 'zano.node')}`);
+}
+async function main() {
+    if (process.platform !== 'darwin') {
+        throw new Error(`Host Zano builds are currently only supported on darwin (got ${process.platform}). ` +
+            'Linux would need _install_linux plain-wallet libs from zano_native_lib.');
+    }
+    const arch = process.arch === 'arm64' ? 'arm64' : 'x86_64';
+    await (0, promises_1.mkdir)(common_1.tmpPath, { recursive: true });
+    await downloadSources();
+    const staticLib = await buildHostStaticLib(arch);
+    await buildNodeAddon(staticLib);
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/lib/scripts/smoke-node.d.ts

@@ -0,0 +1 @@
+export {};