react-native-zano 0.1.0

package/lib/scripts/utils/common.d.ts

@@ -0,0 +1,19 @@
+export declare const tmpPath: string;
+/**
+ * Clones a git repo and checks our a hash.
+ */
+export declare function getRepo(name: string, uri: string, hash: string): Promise<void>;
+/**
+ * Downloads & unpacks a zip file.
+ */
+export declare function getZip(name: string, uri: string): Promise<void>;
+export declare function fileExists(path: string): Promise<boolean>;
+export declare function loudExec(command: string, args: string[], opts?: {
+    cwd?: string;
+}): Promise<void>;
+/**
+ * Runs a command and returns its results.
+ */
+export declare function quietExec(command: string, args: string[], opts?: {
+    cwd?: string;
+}): Promise<string>;

package/lib/scripts/utils/common.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quietExec = exports.loudExec = exports.fileExists = exports.getZip = exports.getRepo = exports.tmpPath = void 0;
+const child_process_1 = require("child_process");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+exports.tmpPath = (0, path_1.join)(__dirname, '../../tmp');
+/**
+ * Clones a git repo and checks our a hash.
+ */
+async function getRepo(name, uri, hash) {
+    const path = (0, path_1.join)(exports.tmpPath, name);
+    // Clone (if needed):
+    if (!(await fileExists(path))) {
+        console.log(`Cloning ${name}...`);
+        await loudExec('git', ['clone', uri, name]);
+    }
+    // Checkout:
+    console.log(`Checking out ${name}...`);
+    await loudExec('git', ['checkout', '-f', hash], { cwd: path });
+    // Checkout submodules:
+    await loudExec('git', ['submodule', 'update', '--init', '--recursive'], {
+        cwd: path
+    });
+}
+exports.getRepo = getRepo;
+/**
+ * Downloads & unpacks a zip file.
+ */
+async function getZip(name, uri) {
+    const path = (0, path_1.join)(exports.tmpPath, name);
+    if (!(await fileExists(path))) {
+        console.log(`Getting ${name}...`);
+        await loudExec('curl', ['-L', '-o', path, uri]);
+    }
+    // Unzip:
+    await loudExec('unzip', ['-u', path]);
+}
+exports.getZip = getZip;
+async function fileExists(path) {
+    return await (0, promises_1.access)(path).then(() => true, () => false);
+}
+exports.fileExists = fileExists;
+async function loudExec(command, args, opts = {}) {
+    const { cwd = exports.tmpPath } = opts;
+    return await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: 'inherit',
+            env: process.env
+        });
+        child.on('error', reject);
+        child.on('exit', code => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`${command} exited with code ${String(code)}`));
+            }
+        });
+    });
+}
+exports.loudExec = loudExec;
+/**
+ * Runs a command and returns its results.
+ */
+async function quietExec(command, args, opts = {}) {
+    const { cwd = exports.tmpPath } = opts;
+    return (0, child_process_1.execSync)(command + ' ' + args.join(' '), {
+        cwd,
+        encoding: 'utf8'
+    }).replace(/\n$/, '');
+}
+exports.quietExec = quietExec;

package/lib/src/CppBridge.d.ts

@@ -0,0 +1,69 @@
+import { AddressInfo, AsyncCallResponse, CloseResponse, ConnectivityStatus, FeePriority, GetBalancesResponse, GetRecentTransactionsResponse, GetSeedPhraseInfo, JsonRpc, ReturnCode, TryPullResultResponse, WalletDetails, WalletFiles, WalletInfoExtended, WalletStatus } from './types';
+/**
+ * The shape of the native C++ module exposed to React Native.
+ *
+ * You do not normally need this, but it is accessible as
+ * `require('react-native').NativeModules.ZanoModule`.
+ *
+ * Pass this object to the `CppBridge` constructor to re-assemble the API.
+ */
+export interface NativeZanoModule {
+    readonly callZano: (name: string, jsonArguments: string[]) => Promise<string>;
+    readonly methodNames: string[];
+    readonly documentDirectory: string;
+}
+export declare class CppBridge {
+    private readonly module;
+    constructor(zanoModule: NativeZanoModule);
+    init(rpcAddress: string, logLevel: number): Promise<JsonRpc<ReturnCode>>;
+    initWithIpPort(ip: string, port: string, logLevel: number): Promise<JsonRpc<ReturnCode>>;
+    reset(): Promise<JsonRpc<ReturnCode>>;
+    setLogLevel(logLevel: number): Promise<string>;
+    getVersion(): Promise<string>;
+    getWalletFiles(): Promise<WalletFiles | {}>;
+    getExportPrivateInfo(targetDir: string): Promise<JsonRpc<ReturnCode>>;
+    deleteWallet(fileName: string): Promise<JsonRpc<ReturnCode>>;
+    getAddressInfo(addr: string): Promise<AddressInfo>;
+    getAppconfig(encryptionKey: string): Promise<object>;
+    setAppconfig(confStr: string, encryptionKey: string): Promise<JsonRpc<ReturnCode>>;
+    generateRandomKey(length: number): Promise<string>;
+    getLogsBuffer(): Promise<string>;
+    truncateLog(): Promise<JsonRpc<ReturnCode>>;
+    getConnectivityStatus(): Promise<ConnectivityStatus>;
+    open(path: string, password: string): Promise<JsonRpc<WalletDetails>>;
+    restore(seed: string, path: string, password: string, seedPassword: string): Promise<JsonRpc<WalletDetails>>;
+    generate(path: string, password: string): Promise<JsonRpc<WalletDetails>>;
+    getOpenedWallets(): Promise<JsonRpc<WalletDetails[]>>;
+    getWalletStatus(walletId: number): Promise<WalletStatus>;
+    closeWallet(walletId: number): Promise<CloseResponse>;
+    invoke(walletId: number, params: string): Promise<string>;
+    asyncCall(methodName: string, instanceId: number, params: string): Promise<AsyncCallResponse>;
+    tryPullResult<T>(arg: number): Promise<TryPullResultResponse<T>>;
+    syncCall(methodName: string, instanceId: number, params: string): Promise<string>;
+    isWalletExist(path: string): Promise<boolean>;
+    getWalletInfo(walletId: number): Promise<{
+        wi: WalletDetails['wi'];
+        wi_extended: WalletInfoExtended;
+    }>;
+    resetWalletPassword(walletId: number, password: string): Promise<string>;
+    getCurrentTxFee(priority: FeePriority): Promise<number>;
+    getSeedPhraseInfo(seed: string, seedPassword: string): Promise<GetSeedPhraseInfo>;
+    generateSeedPhrase(rpcAddress: string, storagePath: string, seedPassword: string, logLevel?: number): Promise<WalletDetails>;
+    startWallet(mnemonicSeed: string, seedPassword: string, storagePath: string): Promise<WalletDetails>;
+    stopWallet(walletId: number): Promise<string>;
+    removeWallet(walletId: number): Promise<void>;
+    walletStatus(walletId: number): Promise<WalletStatus>;
+    getBalances(walletId: number): Promise<GetBalancesResponse>;
+    getTransactions(walletId: number, offset?: number): Promise<GetRecentTransactionsResponse>;
+    whitelistAssets(walletId: number, assetIds: string[]): Promise<void>;
+    transfer(walletId: number, transferOpts: {
+        assetId: string;
+        fee: number;
+        nativeAmount: number;
+        recipient: string;
+        comment?: string;
+        paymentId?: string;
+    }): Promise<string>;
+    private handleRpcResponse;
+    private _asyncCallWithRetry;
+}

package/lib/src/CppBridge.js

@@ -0,0 +1,328 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CppBridge = void 0;
+const types_1 = require("./types");
+class CppBridge {
+    constructor(zanoModule) {
+        this.module = zanoModule;
+    }
+    // -----------------------------------------------------------------------------
+    // Raw API
+    // -----------------------------------------------------------------------------
+    async init(rpcAddress, logLevel) {
+        const response = await this.module.callZano('init', [
+            rpcAddress,
+            this.module.documentDirectory,
+            logLevel.toFixed()
+        ]);
+        return JSON.parse(response);
+    }
+    async initWithIpPort(ip, port, logLevel) {
+        const response = await this.module.callZano('initWithIpPort', [
+            ip,
+            port,
+            this.module.documentDirectory,
+            logLevel.toFixed()
+        ]);
+        return JSON.parse(response);
+    }
+    async reset() {
+        const response = await this.module.callZano('reset', []);
+        return JSON.parse(response);
+    }
+    async setLogLevel(logLevel) {
+        return await this.module.callZano('setLogLevel', [logLevel.toFixed()]);
+    }
+    async getVersion() {
+        return await this.module.callZano('getVersion', []);
+    }
+    async getWalletFiles() {
+        const files = await this.module.callZano('getWalletFiles', []);
+        return JSON.parse(files);
+    }
+    async getExportPrivateInfo(targetDir) {
+        const response = await this.module.callZano('getExportPrivateInfo', [
+            targetDir
+        ]);
+        return JSON.parse(response);
+    }
+    async deleteWallet(fileName) {
+        const response = await this.module.callZano('deleteWallet', [fileName]);
+        return JSON.parse(response);
+    }
+    async getAddressInfo(addr) {
+        const response = await this.module.callZano('getAddressInfo', [addr]);
+        return JSON.parse(response);
+    }
+    async getAppconfig(encryptionKey) {
+        const response = await this.module.callZano('getAppconfig', [encryptionKey]);
+        return JSON.parse(response);
+    }
+    async setAppconfig(confStr, encryptionKey) {
+        const response = await this.module.callZano('setAppconfig', [
+            confStr,
+            encryptionKey
+        ]);
+        return JSON.parse(response);
+    }
+    async generateRandomKey(length) {
+        return await this.module.callZano('generateRandomKey', [length.toFixed()]);
+    }
+    async getLogsBuffer() {
+        return await this.module.callZano('getLogsBuffer', []);
+    }
+    async truncateLog() {
+        const response = await this.module.callZano('truncateLog', []);
+        return JSON.parse(response);
+    }
+    async getConnectivityStatus() {
+        const response = await this.module.callZano('getConnectivityStatus', []);
+        return JSON.parse(response);
+    }
+    async open(path, password) {
+        const response = await this.module.callZano('open', [path, password]);
+        return JSON.parse(response);
+    }
+    async restore(seed, path, password, seedPassword) {
+        const response = await this.module.callZano('restore', [
+            seed,
+            path,
+            password,
+            seedPassword
+        ]);
+        return JSON.parse(response);
+    }
+    async generate(path, password) {
+        const response = await this.module.callZano('generate', [path, password]);
+        return JSON.parse(response);
+    }
+    async getOpenedWallets() {
+        const response = await this.module.callZano('getOpenedWallets', []);
+        return JSON.parse(response);
+    }
+    async getWalletStatus(walletId) {
+        const response = await this.module.callZano('getWalletStatus', [
+            walletId.toFixed()
+        ]);
+        return JSON.parse(response);
+    }
+    async closeWallet(walletId) {
+        const response = await this.module.callZano('closeWallet', [
+            walletId.toFixed()
+        ]);
+        return JSON.parse(response);
+    }
+    async invoke(walletId, params) {
+        return await this.module.callZano('invoke', [walletId.toFixed(), params]);
+    }
+    async asyncCall(methodName, instanceId, params) {
+        const response = await this.module.callZano('asyncCall', [
+            methodName,
+            instanceId.toFixed(),
+            params
+        ]);
+        return JSON.parse(response);
+    }
+    async tryPullResult(arg) {
+        const response = await this.module.callZano('tryPullResult', [
+            arg.toFixed()
+        ]);
+        return JSON.parse(response);
+    }
+    async syncCall(methodName, instanceId, params) {
+        return await this.module.callZano('syncCall', [
+            methodName,
+            instanceId.toFixed(),
+            params
+        ]);
+    }
+    async isWalletExist(path) {
+        const response = await this.module.callZano('isWalletExist', [
+            this.module.documentDirectory + '/wallets/' + path
+        ]);
+        return response === '1';
+    }
+    async getWalletInfo(walletId) {
+        const response = await this.module.callZano('getWalletInfo', [
+            walletId.toFixed()
+        ]);
+        return JSON.parse(response);
+    }
+    async resetWalletPassword(walletId, password) {
+        return await this.module.callZano('resetWalletPassword', [
+            walletId.toFixed(),
+            password
+        ]);
+    }
+    // 0 (default), 1 (unimportant), 2 (normal), 3 (elevated), 4 (priority)
+    async getCurrentTxFee(priority) {
+        const fee = await this.module.callZano('getCurrentTxFee', [
+            priority.toFixed()
+        ]);
+        return parseInt(fee);
+    }
+    // -----------------------------------------------------------------------------
+    // Convenience API
+    // -----------------------------------------------------------------------------
+    async getSeedPhraseInfo(seed, seedPassword) {
+        const params = {
+            seed_phrase: seed,
+            seed_password: seedPassword
+        };
+        const seedInfo = await this._asyncCallWithRetry('get_seed_phrase_info', 0, JSON.stringify(params));
+        return seedInfo;
+    }
+    async generateSeedPhrase(rpcAddress, storagePath, seedPassword, logLevel = -1) {
+        await this.init(rpcAddress, logLevel);
+        const response = await this.generate(storagePath, seedPassword);
+        const result = this.handleRpcResponse(response);
+        await this.closeWallet(result.wallet_id);
+        return result;
+    }
+    async startWallet(mnemonicSeed, seedPassword, storagePath) {
+        const files = await this.getWalletFiles();
+        let items = [];
+        if ('items' in files) {
+            items = files.items;
+        }
+        if (!items.includes(storagePath)) {
+            const response = await this.restore(mnemonicSeed, storagePath, seedPassword, seedPassword);
+            const result = this.handleRpcResponse(response);
+            return result;
+        }
+        else {
+            const response = await this.open(storagePath, seedPassword);
+            const result = this.handleRpcResponse(response);
+            return result;
+        }
+    }
+    async stopWallet(walletId) {
+        const closeResponse = await this._asyncCallWithRetry('close', walletId, '');
+        if (closeResponse.return_code !== 'OK') {
+            throw new Error(`${closeResponse.return_code}`);
+        }
+        return closeResponse.return_code;
+    }
+    async removeWallet(walletId) {
+        const response = await this.getOpenedWallets();
+        const result = this.handleRpcResponse(response);
+        const wallet = result.find(w => w.wallet_id === walletId);
+        if (wallet == null)
+            return;
+        await this.stopWallet(walletId);
+        await this.deleteWallet(wallet.wi.path);
+    }
+    async walletStatus(walletId) {
+        const walletStatus = await this._asyncCallWithRetry('get_wallet_status', walletId, '');
+        return walletStatus;
+    }
+    async getBalances(walletId) {
+        const params = {
+            method: 'getbalance'
+        };
+        const response = await this._asyncCallWithRetry('invoke', walletId, JSON.stringify(params));
+        const result = this.handleRpcResponse(response);
+        return result;
+    }
+    async getTransactions(walletId, offset = 0) {
+        const params = {
+            method: 'get_recent_txs_and_info2',
+            params: {
+                count: 100,
+                exclude_mining_txs: true,
+                exclude_unconfirmed: false,
+                offset,
+                order: 'FROM_BEGIN_TO_END',
+                update_provision_info: true
+            }
+        };
+        const response = await this._asyncCallWithRetry('invoke', walletId, JSON.stringify(params));
+        const result = this.handleRpcResponse(response);
+        return result;
+    }
+    async whitelistAssets(walletId, assetIds) {
+        const currentWhitelistParams = {
+            method: 'assets_whitelist_get',
+            params: {}
+        };
+        const whitelistAssetsResponse = await this._asyncCallWithRetry('invoke', walletId, JSON.stringify(currentWhitelistParams));
+        let whitelistSet = new Set();
+        if ('local_whitelist' in whitelistAssetsResponse) {
+            whitelistSet = new Set(whitelistAssetsResponse.local_whitelist.map(asset => asset.asset_id));
+        }
+        for (const assetId of assetIds) {
+            if (!whitelistSet.has(assetId)) {
+                const addAssetParams = {
+                    method: 'assets_whitelist_add',
+                    params: {
+                        asset_id: assetId
+                    }
+                };
+                await this._asyncCallWithRetry('invoke', walletId, JSON.stringify(addAssetParams));
+            }
+        }
+    }
+    async transfer(walletId, transferOpts) {
+        const params = {
+            method: 'transfer',
+            params: {
+                comment: transferOpts.comment,
+                destinations: [
+                    {
+                        address: transferOpts.recipient,
+                        amount: transferOpts.nativeAmount,
+                        asset_id: transferOpts.assetId
+                    }
+                ],
+                fee: transferOpts.fee,
+                hide_receiver: true,
+                mixin: 15,
+                payment_id: transferOpts.paymentId ?? '',
+                push_payer: false,
+                service_entries_permanent: true
+            }
+        };
+        const response = await this._asyncCallWithRetry('invoke', walletId, JSON.stringify(params));
+        const result = this.handleRpcResponse(response);
+        return result.tx_hash;
+    }
+    // -----------------------------------------------------------------------------
+    // Utils
+    // -----------------------------------------------------------------------------
+    handleRpcResponse(json) {
+        if ('result' in json) {
+            return json.result;
+        }
+        else if ('error' in json) {
+            throw new Error(`${json.error.code} ${json.error.message}`);
+        }
+        else {
+            throw new Error('Unknown error');
+        }
+    }
+    async _asyncCallWithRetry(methodName, instanceId, params) {
+        while (true) {
+            const jobIdResponse = await this.asyncCall(methodName, instanceId, params);
+            while (true) {
+                const tryPullResponse = await this.tryPullResult(jobIdResponse.job_id);
+                await new Promise(resolve => setTimeout(resolve, 100)); // 100 ms recommended by documentation
+                if (tryPullResponse.status === 'idle') {
+                    // try this again. job ID is still valid
+                    continue;
+                }
+                else if (tryPullResponse.status === 'delivered') {
+                    const error = (0, types_1.asMaybeBusy)(tryPullResponse.result);
+                    if (error != null) {
+                        // try this again. job ID is no longer valid
+                        break;
+                    }
+                    return tryPullResponse.result;
+                }
+                else if (tryPullResponse.status === 'canceled') {
+                    throw new Error(`${methodName} job canceled`);
+                }
+            }
+        }
+    }
+}
+exports.CppBridge = CppBridge;

package/lib/src/index.d.ts

@@ -0,0 +1,4 @@
+import { CppBridge, NativeZanoModule } from './CppBridge';
+export declare function makeZano(): CppBridge;
+export type { CppBridge, NativeZanoModule };
+export * from './types';

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('react-native-zano native module not linked');
+    }
+    return new CppBridge_1.CppBridge(ZanoModule);
+}
+exports.makeZano = makeZano;
+__exportStar(require("./types"), exports);