zano-native 0.0.1

package/lib/src/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZano = void 0;
+const react_native_1 = require("react-native");
+const CppBridge_1 = require("./CppBridge");
+function makeZano() {
+    const { ZanoModule } = react_native_1.NativeModules;
+    if (ZanoModule == null) {
+        throw new Error('zano-native native module not linked');
+    }
+    return new CppBridge_1.CppBridge(ZanoModule);
+}
+exports.makeZano = makeZano;
+__exportStar(require("./types"), exports);

package/lib/src/load-addon.d.ts

@@ -0,0 +1,5 @@
+export interface NativeZanoAddon {
+    callZano: (method: string, args: string[]) => Promise<string>;
+    methodNames: () => string[];
+}
+export declare function loadNativeAddon(): NativeZanoAddon;

package/lib/src/load-addon.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadNativeAddon = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function candidatePaths() {
+    const here = __dirname;
+    const platform = `${process.platform}-${process.arch}`;
+    const out = [];
+    let dir = here;
+    for (let i = 0; i < 6; i++) {
+        out.push((0, path_1.join)(dir, 'prebuilds', platform, 'zano.node'));
+        out.push((0, path_1.join)(dir, 'build', 'Release', 'zano.node'));
+        const parent = (0, path_1.join)(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return out;
+}
+let cached;
+function loadNativeAddon() {
+    if (cached != null)
+        return cached;
+    const errors = [];
+    const missing = [];
+    for (const candidate of candidatePaths()) {
+        try {
+            if (!(0, fs_1.existsSync)(candidate)) {
+                missing.push(candidate);
+                continue;
+            }
+            // Native addon loaded at runtime when the .node binary exists.
+            const mod = require(candidate);
+            if (typeof mod.callZano !== 'function')
+                continue;
+            cached = mod;
+            return cached;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            errors.push(`${candidate}: ${message}`);
+        }
+    }
+    throw new Error('zano-native addon not found. Run `npm run build-native-host`. ' +
+        (errors.length > 0
+            ? errors.join('; ')
+            : `Looked in: ${missing.join(', ')}`));
+}
+exports.loadNativeAddon = loadNativeAddon;

package/lib/src/node.d.ts

@@ -0,0 +1,11 @@
+import type { NativeZanoModule } from './CppBridge';
+export type { NativeZanoModule } from './CppBridge';
+export interface MakeNodeZanoModuleOpts {
+    documentDirectory: string;
+}
+export type NodeZanoModule = NativeZanoModule;
+/**
+ * Node N-API implementation of the native Zano module.
+ * Same `callZano` contract as `NativeModules.ZanoModule`.
+ */
+export declare function makeNodeZanoModule(opts: MakeNodeZanoModuleOpts): NodeZanoModule;

package/lib/src/node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNodeZanoModule = void 0;
+const fs_1 = require("fs");
+const load_addon_1 = require("./load-addon");
+/** Directories the Zano SDK expects under documentDirectory. */
+const sdkFolders = ['app_config', 'logs', 'wallets'];
+/**
+ * Node N-API implementation of the native Zano module.
+ * Same `callZano` contract as `NativeModules.ZanoModule`.
+ */
+function makeNodeZanoModule(opts) {
+    const addon = (0, load_addon_1.loadNativeAddon)();
+    (0, fs_1.mkdirSync)(opts.documentDirectory, { recursive: true });
+    for (const name of sdkFolders) {
+        (0, fs_1.mkdirSync)(`${opts.documentDirectory}/${name}`, { recursive: true });
+    }
+    const methodNames = addon.methodNames();
+    return {
+        callZano: async (name, jsonArguments) => await addon.callZano(name, jsonArguments),
+        methodNames,
+        documentDirectory: opts.documentDirectory
+    };
+}
+exports.makeNodeZanoModule = makeNodeZanoModule;

package/lib/src/types.d.ts

@@ -0,0 +1,292 @@
+interface JsonRpcResponseBase {
+    id: number;
+    jsonrpc: string;
+}
+interface JsonRpcResponseSuccess<T> extends JsonRpcResponseBase {
+    result: T;
+}
+interface JsonRpcResponseError extends JsonRpcResponseBase {
+    error: {
+        code: string | number;
+        message: string;
+    };
+}
+export type JsonRpc<T> = JsonRpcResponseSuccess<T> | JsonRpcResponseError;
+/**
+ * An error from the native Zano library, carrying its API return code.
+ *
+ * The message keeps the exact `<code> <detail>` shape this library has
+ * always thrown, so callers matching on `error.message` substrings keep
+ * working.
+ */
+export declare class ZanoError extends Error {
+    /** The bare return code, with any packed detail stripped. */
+    readonly code: string;
+    constructor(rawCode: string, detail?: string);
+}
+export interface ReturnCode {
+    return_code: string;
+}
+export interface WalletFiles {
+    items: string[];
+}
+/**
+ * The shape `plain_wallet::get_address_info` actually returns. Note that
+ * `payment_id` is a boolean presence flag, not the id itself, and there is
+ * no `is_integrated` field -- the earlier declaration of both was fiction
+ * that no native version ever produced.
+ */
+export interface AddressInfo {
+    valid: boolean;
+    auditable: boolean;
+    payment_id: boolean;
+    wrap: boolean;
+}
+export interface ConnectivityStatus {
+    is_online: boolean;
+    is_remote_node_mode: boolean;
+    is_server_busy: boolean;
+    last_daemon_is_disconnected: boolean;
+    last_proxy_communicate_timestamp: number;
+}
+interface AssetInfo {
+    asset_id: string;
+    current_supply: number;
+    decimal_point: number;
+    full_name: string;
+    hidden_supply: boolean;
+    meta_info: string;
+    owner: string;
+    owner_eth_pub_key: string;
+    ticker: string;
+    total_max_supply: number;
+}
+interface AssetBalance {
+    asset_info: AssetInfo;
+    awaiting_in: number;
+    awaiting_out: number;
+    outs_amount_max: number;
+    outs_amount_min: number;
+    outs_count: number;
+    total: number;
+    unlocked: number;
+}
+export interface WalletDetails {
+    name: string;
+    pass: string;
+    private_spend_key: string;
+    private_view_key: string;
+    public_spend_key: string;
+    public_view_key: string;
+    recent_history: {
+        last_item_index: number;
+        total_history_items: number;
+    };
+    recovered: boolean;
+    seed: string;
+    wallet_file_size: number;
+    wallet_id: number;
+    wallet_local_bc_size: number;
+    wi: {
+        address: string;
+        balances: AssetBalance[];
+        has_bare_unspent_outputs: boolean;
+        is_auditable: boolean;
+        is_watch_only: boolean;
+        mined_total: number;
+        path: string;
+        view_sec_key: string;
+    };
+}
+declare enum WalletState {
+    SYNCING = 1,
+    SYNCED = 2,
+    ERROR = 3
+}
+export interface WalletStatus {
+    current_daemon_height: number;
+    current_wallet_height: number;
+    is_daemon_connected: boolean;
+    is_in_long_refresh: boolean;
+    progress: number;
+    wallet_state: WalletState;
+}
+export interface CloseResponse {
+    response: string;
+}
+export interface AsyncCallResponse {
+    job_id: number;
+}
+export type TryPullResultResponse<T> = {
+    status: 'canceled';
+} | {
+    status: 'idle';
+} | {
+    status: 'delivered';
+    result: T | {
+        error: {
+            code: number;
+            message: string;
+        };
+    };
+};
+export declare const asMaybeBusy: import("cleaners").Cleaner<{
+    error: {
+        message: any;
+    };
+} | undefined>;
+export interface WalletInfoExtended {
+    seed: string;
+    spend_private_key: string;
+    spend_public_key: string;
+    view_private_key: string;
+    view_public_key: string;
+}
+export declare enum FeePriority {
+    DEFAULT = 0,
+    UNIMPORTANT = 1,
+    NORMAL = 2,
+    ELEVATED = 3,
+    PRIORITY = 4
+}
+export interface GetSeedPhraseInfo {
+    error_code: string;
+    response_data: {
+        address: string;
+        hash_sum_matched: boolean;
+        require_password: boolean;
+        syntax_correct: boolean;
+        tracking: boolean;
+    };
+}
+interface AssetInfo {
+    asset_id: string;
+    current_supply: number;
+    decimal_point: number;
+    full_name: string;
+    hidden_supply: boolean;
+    meta_info: string;
+    owner: string;
+    owner_eth_pub_key: string;
+    ticker: string;
+    total_max_supply: number;
+}
+interface AssetBalance {
+    asset_info: AssetInfo;
+    awaiting_in: number;
+    awaiting_out: number;
+    outs_amount_max: number;
+    outs_amount_min: number;
+    outs_count: number;
+    total: number;
+    unlocked: number;
+}
+export interface GetBalancesResponse {
+    balance: number;
+    balances: AssetBalance[];
+    unlocked_balance: number;
+}
+export interface RecentTransaction {
+    comment?: string;
+    employed_entries: {
+        receive?: Array<{
+            amount: number;
+            asset_id: string;
+            index: number;
+            /**
+             * The intrinsic payment id as a raw integer, zero when absent. Treat
+             * it as a presence signal only: the value is a uint64 that can pass
+             * 2^53 and lose precision in JSON. Read actual ids from
+             * `subtransfers_by_pid`, which carries them as hex strings.
+             */
+            payment_id?: number;
+        }>;
+        spent?: Array<{
+            amount: number;
+            asset_id: string;
+            index: number;
+            payment_id?: number;
+        }>;
+    };
+    fee: number;
+    height: number;
+    is_mining: boolean;
+    is_mixing: boolean;
+    is_service: boolean;
+    /**
+     * Destination addresses recorded by the sending wallet, empty for
+     * incoming transfers. Wallet-local history, not chain data: a wallet
+     * restored from its seed has none of these.
+     */
+    remote_addresses?: string[];
+    show_sender: boolean;
+    /**
+     * Amounts grouped by intrinsic payment id and then by asset, the
+     * essential part of the entry since HF6. `payment_id` is hex, or the
+     * empty string for amounts that carry no id - a sender's own spent
+     * inputs and change always land in the empty-id group, so a sent
+     * transfer's recipient ids never appear here.
+     */
+    subtransfers_by_pid?: Array<{
+        payment_id: string;
+        subtransfers: Array<{
+            amount: number;
+            asset_id: string;
+            is_income: boolean;
+        }>;
+    }>;
+    timestamp: number;
+    transfer_internal_index: number;
+    tx_blob_size: number;
+    tx_hash: string;
+    tx_type: number;
+    unlock_time: number;
+}
+export interface GetRecentTransactionsResponse {
+    last_item_index: number;
+    pi: {
+        balance: number;
+        curent_height: number;
+        transfer_entries_count: number;
+        transfers_count: number;
+        unlocked_balance: number;
+    };
+    total_transfers: number;
+    transfers?: RecentTransaction[];
+}
+export interface WhitelistAssetsResponse {
+    global_whitelist: AssetInfo[];
+    local_whitelist: AssetInfo[];
+    own_assets: AssetInfo[];
+}
+export interface TransferParams {
+    transfers: Array<{
+        assetId: string;
+        nativeAmount: number;
+        recipient: string;
+    }>;
+    comment?: string;
+    fee: number;
+}
+export interface TransferResponse {
+    tx_hash: string;
+    tx_size: number;
+    tx_unsigned_hex: '';
+}
+export interface BurnAssetParams {
+    assetId: string;
+    burnAmount: number;
+    nativeAmount?: number;
+    pointTxToAddress?: string;
+    serviceEntries?: Array<{
+        body: string;
+        flags?: number;
+        instruction: string;
+        security?: string;
+        service_id: string;
+    }>;
+}
+export interface BurnAssetResponse {
+    tx_id: string;
+}
+export {};

package/lib/src/types.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeePriority = exports.asMaybeBusy = exports.ZanoError = void 0;
+const cleaners_1 = require("cleaners");
+/**
+ * An error from the native Zano library, carrying its API return code.
+ *
+ * The message keeps the exact `<code> <detail>` shape this library has
+ * always thrown, so callers matching on `error.message` substrings keep
+ * working.
+ */
+class ZanoError extends Error {
+    constructor(rawCode, detail = '') {
+        super(`${rawCode} ${detail}`);
+        this.name = 'ZanoError';
+        // The native layer packs detail into the code itself, as `FAIL:<what>`
+        // or `INTERNAL_ERROR, DESCRIPTION: <what>`:
+        this.code = rawCode.split(/[\s,:]/)[0];
+    }
+}
+exports.ZanoError = ZanoError;
+var WalletState;
+(function (WalletState) {
+    WalletState[WalletState["SYNCING"] = 1] = "SYNCING";
+    WalletState[WalletState["SYNCED"] = 2] = "SYNCED";
+    WalletState[WalletState["ERROR"] = 3] = "ERROR";
+})(WalletState || (WalletState = {}));
+exports.asMaybeBusy = (0, cleaners_1.asMaybe)((0, cleaners_1.asObject)({
+    error: (0, cleaners_1.asObject)({
+        message: (0, cleaners_1.asValue)('BUSY')
+    })
+}));
+var FeePriority;
+(function (FeePriority) {
+    FeePriority[FeePriority["DEFAULT"] = 0] = "DEFAULT";
+    FeePriority[FeePriority["UNIMPORTANT"] = 1] = "UNIMPORTANT";
+    FeePriority[FeePriority["NORMAL"] = 2] = "NORMAL";
+    FeePriority[FeePriority["ELEVATED"] = 3] = "ELEVATED";
+    FeePriority[FeePriority["PRIORITY"] = 4] = "PRIORITY";
+})(FeePriority = exports.FeePriority || (exports.FeePriority = {}));

package/lib/src/walletFilePassword.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Derives the password used to encrypt the wallet file on disk.
+ *
+ * Versions 0.3.0 and earlier encrypted the file with the seed passphrase,
+ * which is the empty string for most wallets, leaving the seed and spend
+ * keys effectively unencrypted on disk. The file is a local cache that can
+ * always be rebuilt from the mnemonic, so the only requirement here is
+ * stability: the same mnemonic must derive the same password on every
+ * device, forever.
+ *
+ * The mnemonic is normalized before hashing because callers store and pass
+ * whatever spacing the user or a scanner produced.
+ */
+export declare function deriveWalletFilePassword(mnemonic: string): string;

package/lib/src/walletFilePassword.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveWalletFilePassword = void 0;
+const rfc4648_1 = require("rfc4648");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+/**
+ * Domain separator for the wallet-file password.
+ *
+ * Changing this value (or anything else about the derivation) orphans every
+ * wallet file already encrypted with it, forcing a delete-and-restore. If
+ * the derivation must ever change, bump the version suffix and keep the old
+ * derivation in `startWallet`'s legacy-password list.
+ */
+const DOMAIN = 'react-native-zano:file-password:v1';
+/**
+ * Zano caps wallet-file passwords at 40 characters over a restricted
+ * alphabet (`PASSWORD_REGEXP` in Zano core, enforced by `wallet2::generate`).
+ * 16 bytes of hex is 32 characters, inside both limits.
+ */
+const PASSWORD_BYTES = 16;
+/**
+ * Encodes a string as UTF-8 without relying on Buffer or TextEncoder.
+ *
+ * This module runs both on the React Native JS thread and inside
+ * edge-currency-accountbased's plugin WebView, and `TextEncoder` is not
+ * guaranteed in every engine and polyfill combination those present. The
+ * derivation must produce identical bytes everywhere, forever, so it does
+ * not depend on a host global that may be absent.
+ */
+function utf8Bytes(text) {
+    const out = [];
+    for (let i = 0; i < text.length; ++i) {
+        let code = text.charCodeAt(i);
+        if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length) {
+            // Surrogate pair:
+            code = 0x10000 + ((code - 0xd800) << 10) + (text.charCodeAt(++i) - 0xdc00);
+        }
+        if (code < 0x80) {
+            out.push(code);
+        }
+        else if (code < 0x800) {
+            out.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+        }
+        else if (code < 0x10000) {
+            out.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+        }
+        else {
+            out.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+        }
+    }
+    return Uint8Array.from(out);
+}
+/**
+ * Derives the password used to encrypt the wallet file on disk.
+ *
+ * Versions 0.3.0 and earlier encrypted the file with the seed passphrase,
+ * which is the empty string for most wallets, leaving the seed and spend
+ * keys effectively unencrypted on disk. The file is a local cache that can
+ * always be rebuilt from the mnemonic, so the only requirement here is
+ * stability: the same mnemonic must derive the same password on every
+ * device, forever.
+ *
+ * The mnemonic is normalized before hashing because callers store and pass
+ * whatever spacing the user or a scanner produced.
+ */
+function deriveWalletFilePassword(mnemonic) {
+    const normalized = mnemonic.trim().replace(/\s+/g, ' ');
+    const digest = tweetnacl_1.default.hash(utf8Bytes(`${DOMAIN}|${normalized}`));
+    return rfc4648_1.base16.stringify(digest.subarray(0, PASSWORD_BYTES)).toLowerCase();
+}
+exports.deriveWalletFilePassword = deriveWalletFilePassword;

package/node.d.ts

@@ -0,0 +1,5 @@
+export {
+  makeNodeZanoModule,
+  type MakeNodeZanoModuleOpts,
+  type NodeZanoModule
+} from './lib/src/node'

package/node.js

@@ -0,0 +1,2 @@
+'use strict'
+module.exports = require('./lib/src/node.js')

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "zano-native",
+  "version": "0.0.1",
+  "description": "Native Zano wallet library for React Native and Node.js",
+  "homepage": "https://github.com/EdgeApp/zano-native",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:EdgeApp/zano-native.git"
+  },
+  "license": "MIT",
+  "author": "Airbitz Inc dba Edge",
+  "main": "lib/src/index.js",
+  "types": "lib/src/index.d.ts",
+  "files": [
+    "/android/build.gradle",
+    "/android/src/",
+    "/CHANGELOG.md",
+    "/ios/",
+    "/lib/",
+    "/LICENSE",
+    "/node.d.ts",
+    "/node.js",
+    "/package.json",
+    "/prebuilds/",
+    "/README.md",
+    "/src/node/",
+    "/src/zano-wrapper/zano-methods.hpp",
+    "/zano-native.podspec",
+    "!/android/src/main/jniLibs/armeabi-v7a"
+  ],
+  "lint-staged": {
+    "*.{js,ts}": "eslint"
+  },
+  "scripts": {
+    "build-native-arm64": "ZERO_AR_DATE=1 node -r sucrase/register ./scripts/update-sources.ts --arm64",
+    "build-native-host": "ZERO_AR_DATE=1 node -r sucrase/register ./scripts/build-native-host.ts",
+    "fix": "npm run lint -- --fix",
+    "lint": "eslint .",
+    "prepare": "husky install && rimraf lib && tsc",
+    "prepublishOnly": "npm run build-native-arm64 && npm run build-native-host",
+    "smoke-node": "node -r sucrase/register ./scripts/smoke-node.ts",
+    "test": "mocha",
+    "update-sources": "ZERO_AR_DATE=1 node -r sucrase/register ./scripts/update-sources.ts",
+    "verify": "npm run lint && npm test && tsc --noEmit -p tsconfig.eslint.json"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^14.14.7",
+    "@typescript-eslint/eslint-plugin": "^5.36.2",
+    "@typescript-eslint/parser": "^5.36.2",
+    "disklet": "^0.4.6",
+    "eslint": "^8.57.0",
+    "eslint-config-standard-kit": "0.15.1",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-prettier": "^3.1.4",
+    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-simple-import-sort": "^6.0.1",
+    "eslint-plugin-standard": "^4.0.1",
+    "husky": "^7.0.0",
+    "lint-staged": "^10.5.3",
+    "mocha": "^10.2.0",
+    "prettier": "^2.8.8",
+    "rimraf": "^3.0.2",
+    "sucrase": "^3.16.0",
+    "typescript": "5.0.4",
+    "node-gyp": "^11.5.0"
+  },
+  "dependencies": {
+    "cleaners": "^0.3.17",
+    "rfc4648": "^1.5.4",
+    "tweetnacl": "^1.0.3",
+    "node-addon-api": "^8.9.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/src/index.d.ts",
+      "react-native": "./lib/src/index.js",
+      "default": "./lib/src/index.js"
+    },
+    "./node": {
+      "types": "./lib/src/node.d.ts",
+      "default": "./lib/src/node.js"
+    },
+    "./package.json": "./package.json",
+    "./lib/src/CppBridge": {
+      "types": "./lib/src/CppBridge.d.ts",
+      "default": "./lib/src/CppBridge.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "node": [
+        "lib/src/node.d.ts"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "react-native": ">=0.47.0 <1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react-native": {
+      "optional": true
+    }
+  }
+}