@ledgerhq/live-cli 24.36.0 → 24.37.0-nightly.20260331030457

package/lib/465.js

@@ -0,0 +1,517 @@
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+exports.ids = ["465"];
+exports.modules = {
+"../../node_modules/.pnpm/@ledgerhq+zcash-decrypt@0.2.0/node_modules/@ledgerhq/zcash-decrypt/pkg/zcash_decrypt.js"(__unused_rspack_module, exports, __webpack_require__) {
+/* @ts-self-types="./zcash_decrypt.d.ts" */
+
+/**
+ * @param {string} tx_hex
+ * @param {string} viewing_key
+ * @returns {any}
+ */
+function decrypt_tx(tx_hex, viewing_key) {
+    const ptr0 = passStringToWasm0(tx_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(viewing_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.decrypt_tx(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.decrypt_tx = decrypt_tx;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_new_361308b2356cecd0: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_3eb36ae241fe6f44: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
+        __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./zcash_decrypt_bg.js": import0,
+    };
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/zcash_decrypt_bg.wasm`;
+const wasmBytes = (__webpack_require__("fs")/* .readFileSync */.readFileSync)(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+const wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();
+
+
+},
+"../../libs/coin-modules/zcash-shielded/lib-es/ZCash.js"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  ZCASH_JSON_RPC_SERVER_MAINNET: () => (/* reexport */ ZCASH_JSON_RPC_SERVER_MAINNET),
+  ZCASH_JSON_RPC_SERVER_TESTNET: () => (/* reexport */ ZCASH_JSON_RPC_SERVER_TESTNET),
+  ZCash: () => (/* binding */ ZCash)
+});
+
+// EXTERNAL MODULE: ../../libs/ledgerjs/packages/logs/lib-es/index.js
+var lib_es = __webpack_require__("../../libs/ledgerjs/packages/logs/lib-es/index.js");
+// EXTERNAL MODULE: ../../node_modules/.pnpm/@ledgerhq+zcash-decrypt@0.2.0/node_modules/@ledgerhq/zcash-decrypt/pkg/zcash_decrypt.js
+var zcash_decrypt = __webpack_require__("../../node_modules/.pnpm/@ledgerhq+zcash-decrypt@0.2.0/node_modules/@ledgerhq/zcash-decrypt/pkg/zcash_decrypt.js");
+// EXTERNAL MODULE: ../../libs/live-network/lib-es/index.js
+var live_network_lib_es = __webpack_require__("../../libs/live-network/lib-es/index.js");
+// EXTERNAL MODULE: ../../node_modules/.pnpm/bignumber.js@9.1.2/node_modules/bignumber.js/bignumber.mjs
+var bignumber = __webpack_require__("../../node_modules/.pnpm/bignumber.js@9.1.2/node_modules/bignumber.js/bignumber.mjs");
+;// CONCATENATED MODULE: ../../libs/coin-modules/zcash-shielded/lib-es/constants.js
+
+const ZCASH_LOG_TYPE = "zcash-shielded";
+const ZCASH_JSON_RPC_SERVER_TESTNET = "https://explorers.api.vault.ledger-test.com/nodes/zec_testnet/zaino/jsonrpc";
+const ZCASH_JSON_RPC_SERVER_MAINNET = "https://explorers.api.vault.ledger-test.com/nodes/zec_testnet/zaino/jsonrpc";
+const ZCASH_ACTIVATION_DATE = new Date("2016-10-28");
+const ZCASH_ACTIVATION_DATE_STRING = "2016-10-28";
+const ZCASH_OUTDATED_SYNC_INTERVAL_MINUTES = 2;
+const DEFAULT_ZCASH_PRIVATE_INFO = {
+    orchardBalance: new bignumber/* .BigNumber */.g(0),
+    saplingBalance: new bignumber/* .BigNumber */.g(0),
+    ufvk: null,
+    syncState: "disabled",
+    birthday: ZCASH_ACTIVATION_DATE_STRING,
+    lastSyncTimestamp: null,
+    lastBlockProcessed: null,
+    transactions: []
+}; //# sourceMappingURL=constants.js.map
+
+;// CONCATENATED MODULE: ../../libs/coin-modules/zcash-shielded/lib-es/jsonRpcClient.js
+
+
+
+class JsonRpcClient {
+    serverUrl;
+    constructor(serverUrl){
+        this.serverUrl = serverUrl;
+    }
+    async _jsonRpcRequest(args) {
+        let data;
+        try {
+            const response = await (0,live_network_lib_es/* ["default"] */.A)({
+                url: this.serverUrl,
+                method: "POST",
+                data: {
+                    jsonrpc: "2.0",
+                    ...args,
+                    id: 1
+                }
+            });
+            data = response.data;
+        } catch (err) {
+            (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, "error: Network error");
+            throw err;
+        }
+        if ("error" in data) {
+            const message = data.error.message ?? "unknown error";
+            (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, `error: Zcash RPC ${args.method} failed - ${message}`);
+        } else if (data.result === undefined || data.result === null) {
+            (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, `error: Zcash RPC ${args.method} returned no result`);
+        } else {
+            return data.result;
+        }
+    }
+    getBlock(blockHashOrHeight) {
+        return this._jsonRpcRequest({
+            method: "getblock",
+            params: [
+                blockHashOrHeight,
+                1
+            ]
+        });
+    }
+    async getBlockCount() {
+        const result = await this._jsonRpcRequest({
+            method: "getblockcount",
+            params: []
+        });
+        if (result === undefined) {
+            return undefined;
+        }
+        if (typeof result !== "number") {
+            (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, "error: Zcash RPC getblockcount returned non-numeric result");
+            return undefined;
+        }
+        return result;
+    }
+    getRawTransaction(txId) {
+        return this._jsonRpcRequest({
+            method: "getrawtransaction",
+            params: [
+                txId,
+                1
+            ]
+        });
+    }
+} //# sourceMappingURL=jsonRpcClient.js.map
+
+;// CONCATENATED MODULE: ../../libs/coin-modules/zcash-shielded/lib-es/shieldedTransaction.js
+
+const toShieldedTransaction = (tx, decryptedTx)=>({
+        id: tx.txid,
+        hex: tx.hex,
+        blockHash: tx.blockhash,
+        blockHeight: tx.height,
+        timestamp: tx.time,
+        fee: new bignumber/* .BigNumber */.g(tx.orchard.valueBalanceZat),
+        decryptedData: {
+            orchard_outputs: decryptedTx.orchard_outputs.map((output)=>({
+                    ...output,
+                    amount: new bignumber/* .BigNumber */.g(output.amount)
+                })),
+            sapling_outputs: decryptedTx.sapling_outputs.map((output)=>({
+                    ...output,
+                    amount: new bignumber/* .BigNumber */.g(output.amount)
+                }))
+        }
+    }); //# sourceMappingURL=shieldedTransaction.js.map
+
+// EXTERNAL MODULE: ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/cjs/index.js
+var cjs = __webpack_require__("../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/cjs/index.js");
+;// CONCATENATED MODULE: ../../libs/coin-modules/zcash-shielded/lib-es/ZCash.js
+
+
+
+
+
+
+/**
+ * ZCash API
+ */ 
+class ZCash {
+    jsonRpcClient;
+    constructor(args){
+        this.jsonRpcClient = new JsonRpcClient(args.nodeUrl);
+    }
+    /**
+     * Estimates sync time given a total number of blocks to process.
+     * This is a curried function that returns a function that returns the estimated sync time.
+     * It should be called when processing a block (passing the total number of blocks to process)
+     * and then called again when processing the next block.
+     * The function will return the estimated sync time in hours and minutes.
+     *
+     * @param totalBlocks total blocks to process
+     * @return an object with the estimated sync time in hours and minutes
+     */ async estimatedSyncTime(totalBlocks) {
+        const start = Date.now();
+        let end = null;
+        return ()=>{
+            end = Date.now();
+            const totalSeconds = (end - start) / 1000 * totalBlocks;
+            const totalMinutes = Math.floor(totalSeconds / 60);
+            const hours = Math.floor(totalMinutes / 60);
+            const minutes = totalMinutes % 60;
+            return {
+                hours,
+                minutes
+            };
+        };
+    }
+    /**
+     * Scans a block for shielded transactions matching the given viewing key.
+     *
+     * @param {{
+     *    block: Block,
+     *    viewingKey: string
+     * }} args, Block and the UFVK - unified full viewing key.
+     * @returns {ShieldedTransaction[]} list of shielded transactions
+     */ async findShieldedTxsInBlock(args) {
+        const { block, viewingKey } = args;
+        // 1. get list of tx
+        const transactions = block?.tx;
+        const decryptedTransactions = [];
+        // 2. retrieve each tx hash
+        if (transactions) {
+            for (const txId of transactions){
+                if (!txId) {
+                    continue;
+                }
+                const tx = await this.jsonRpcClient.getRawTransaction(txId);
+                // 3. call decryptTransaction for each tx hash containing orchard actions
+                if (tx?.orchard.actions.length) {
+                    const decryptedTx = await this.decryptTransaction(tx, viewingKey);
+                    if (decryptedTx) {
+                        decryptedTransactions.push(decryptedTx);
+                    }
+                }
+            }
+        }
+        // 4. return list of transaction for the given viewingKey
+        return decryptedTransactions;
+    }
+    /**
+     * Decrypts a ZCash shielded - i.e., encrypted - transaction.
+     *
+     * @param {RawTransaction} rawTransaction, raw data representing an encrypted transaction.
+     * @param {string} viewingKey the UFVK - unified full viewing key.
+     * @return {Promise<ShieldedTransaction | undefined>} the decrypted shielded transaction.
+     */ async decryptTransaction(rawTransaction, viewingKey) {
+        try {
+            const decryptedTx = (0,zcash_decrypt.decrypt_tx)(rawTransaction.hex, viewingKey);
+            return toShieldedTransaction(rawTransaction, decryptedTx);
+        } catch (error) {
+            (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, "error: failed to decrypt transaction", error);
+        }
+    }
+    /**
+     * Finds the lowest block height correspondent to a given timestamp.
+     *
+     * @param {number} timestamp
+     * @returns {Promise<number>} a block height
+     */ async findBlockHeight(timestamp) {
+        if (timestamp < 0 || !Number.isFinite(timestamp)) {
+            (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, `error: findBlockHeight invalid timestamp: ${timestamp}`);
+            return undefined;
+        }
+        const maxHeight = await this.jsonRpcClient.getBlockCount();
+        if (maxHeight === undefined) {
+            (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, "error: findBlockHeight failed to fetch block count from RPC node (getBlockCount returned undefined).");
+            return;
+        }
+        if (maxHeight <= 0) {
+            return 0;
+        }
+        let low = 0;
+        let high = maxHeight;
+        let candidate = 0;
+        while(low <= high){
+            const mid = Math.floor((low + high) / 2);
+            const block = await this.jsonRpcClient.getBlock(mid.toString());
+            if (!block) {
+                (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, `Block ${mid} not found.`);
+                return;
+            }
+            if (block.time <= timestamp) {
+                candidate = mid;
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+        return candidate;
+    }
+    /**
+     * Parses the blocks in the provided range and, after each iteration,
+     * it returns a synced shielded context including aggregate information
+     * like the shielded transactions and processing progress.
+     *
+     * ### Stop the iterator
+     * The sync operation can be gracefully stopped by calling unsubscribe on the
+     * observable subscription.
+     *
+     * @param {{
+     *    startBlockHeight: number
+     *    viewingKey: string
+     *    maxBatchSize: number
+     * }} args, Block, the UFVK - unified full viewing key, and max batch size.
+     * @returns {Observable<ShieldedSyncResult>} the current synced shielded context.
+     */ syncShielded(args) {
+        return new cjs.Observable((subscriber)=>{
+            this._syncShieldedObsFunc(args)(subscriber).then(()=>subscriber.complete(), (error)=>subscriber.error(error));
+        });
+    }
+    _syncShieldedObsFunc(args) {
+        return async (subscriber)=>{
+            const { startBlockHeight, viewingKey, maxBatchSize } = args;
+            const syncedShielded = {
+                processedBlocks: 0,
+                remainingBlocks: 0,
+                transactions: []
+            };
+            // 0. validate args
+            if (startBlockHeight < 0) {
+                (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, "error: invalid negative arg startBlockHeight");
+                subscriber.error("error: invalid negative arg startBlockHeight");
+                return;
+            }
+            if (maxBatchSize <= 0) {
+                (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, "error: invalid negative or zero arg maxBatchSize");
+                subscriber.error("error: invalid negative or zero arg maxBatchSize");
+                return;
+            }
+            // 1. get end block height before the start of the cycle
+            let endBlockHeight = await this.jsonRpcClient.getBlockCount();
+            if (endBlockHeight === undefined) {
+                (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, "error: could not retrieve the last block");
+                subscriber.error("error: could not retrieve the last block");
+                return;
+            }
+            for(let blockHeight = startBlockHeight; blockHeight <= endBlockHeight; blockHeight++){
+                if (subscriber.closed) {
+                    break;
+                }
+                // 2. on the last iteration, update the end block height and process until the end
+                if (blockHeight === endBlockHeight) {
+                    endBlockHeight = await this.jsonRpcClient.getBlockCount();
+                    if (endBlockHeight === undefined) {
+                        (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, "error: could not retrieve the last block");
+                        subscriber.error("error: could not retrieve the last block");
+                        break;
+                    }
+                }
+                // 3. get current block
+                const block = await this.jsonRpcClient.getBlock(blockHeight.toString());
+                if (!block) {
+                    (0,lib_es/* .log */.Rm)(ZCASH_LOG_TYPE, `error: invalid block height ${blockHeight}`);
+                    break;
+                }
+                // 4. find shielded tx in block
+                const shieldedTxs = await this.findShieldedTxsInBlock({
+                    block,
+                    viewingKey
+                });
+                // 5. update syncedShielded's context: list of shielded transactions and counters
+                syncedShielded.transactions.push(...shieldedTxs);
+                syncedShielded.processedBlocks++;
+                syncedShielded.remainingBlocks = endBlockHeight - blockHeight;
+                syncedShielded.lastProcessedBlock = block.height;
+                if (!(syncedShielded.processedBlocks % maxBatchSize) || blockHeight === endBlockHeight) {
+                    subscriber.next({
+                        ...syncedShielded,
+                        transactions: [
+                            ...syncedShielded.transactions
+                        ]
+                    });
+                }
+            }
+            subscriber.complete();
+            return;
+        };
+    }
+} //# sourceMappingURL=ZCash.js.map
+
+
+},
+
+};
+;