@onekeyfe/hd-core 1.2.8-alpha.126 → 1.2.8-alpha.127

package/dist/index.js

@@ -1721,6 +1721,12 @@ const createCoreApi = (call) => ({
     benfenSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'benfenSignMessage' })),
     neoGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'neoGetAddress' })),
     neoSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'neoSignTransaction' })),
+    zcashGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'zcashGetAddress' })),
+    zcashSignPczt: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'zcashSignPczt' })),
+    moneroGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'moneroGetAddress' })),
+    moneroGetWatchKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'moneroGetWatchKey' })),
+    moneroKeyImageSync: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'moneroKeyImageSync' })),
+    moneroSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'moneroSignTransaction' })),
 });
 
 const lowLevelInject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, updateSettings, switchTransport, addHardwareGlobalEventListener, }) => {
@@ -2439,6 +2445,12 @@ const LogPayloadBlockMethod = new Set([
     'uploadPortfolio',
     'fileWrite',
     'fileRead',
+    'zcashGetAddress',
+    'zcashSignPczt',
+    'moneroGetAddress',
+    'moneroGetWatchKey',
+    'moneroKeyImageSync',
+    'moneroSignTransaction',
 ]);
 function getLogBlockLabel(message) {
     if (!message || typeof message !== 'object')
@@ -2453,11 +2465,41 @@ function getLogBlockLabel(message) {
     }
     return undefined;
 }
+const LogPayloadBlockNetwork = new Set(['zcash', 'xmr']);
+function redactAllNetworkItem(item) {
+    if (!item || item.success === false || item.payload === undefined)
+        return item;
+    return item.network && LogPayloadBlockNetwork.has(item.network)
+        ? Object.assign(Object.assign({}, item), { payload: '[REDACTED]' }) : item;
+}
+function redactAllNetworkItems(items) {
+    const redacted = items.map(redactAllNetworkItem);
+    return redacted.some((item, index) => item !== items[index]) ? redacted : items;
+}
+function redactAllNetworkResults(message) {
+    const { payload } = message;
+    if (Array.isArray(payload)) {
+        const items = redactAllNetworkItems(payload);
+        return items === payload ? message : Object.assign(Object.assign({}, message), { payload: items });
+    }
+    const data = payload === null || payload === void 0 ? void 0 : payload.data;
+    if (!data)
+        return message;
+    const redacted = Array.isArray(data) ? redactAllNetworkItems(data) : redactAllNetworkItem(data);
+    return redacted === data ? message : Object.assign(Object.assign({}, message), { payload: Object.assign(Object.assign({}, payload), { data: redacted }) });
+}
 function getSafeLogPayload(value, blockLabel) {
     if (blockLabel) {
         return { method: blockLabel, payload: '[REDACTED]' };
     }
-    return value;
+    if (!value || typeof value !== 'object')
+        return value;
+    return redactAllNetworkResults(value);
+}
+function getSafeLogTask(task) {
+    var _a;
+    const blockLabel = getLogBlockLabel((_a = task === null || task === void 0 ? void 0 : task.method) === null || _a === void 0 ? void 0 : _a.payload);
+    return blockLabel ? { id: task === null || task === void 0 ? void 0 : task.id, method: blockLabel, payload: '[REDACTED]' } : task;
 }
 function formatLogMethodLabel(label, methodName) {
     return methodName ? `${label} [${methodName}]` : label;
@@ -2574,6 +2616,25 @@ const validatePath = (path, length = 0, base = false) => {
         throw PATH_NOT_VALID;
     return base ? valid.splice(0, 3) : valid;
 };
+const isTextIndex = (part) => {
+    var _a;
+    const digits = (_a = /^(\d+)'?$/.exec(part)) === null || _a === void 0 ? void 0 : _a[1];
+    return digits !== undefined && Number(digits) < HD_HARDENED;
+};
+const isUint32 = (n) => Number.isInteger(n) && n >= 0 && n <= 0xffffffff;
+const validateStrictPath = (path, length = 0) => {
+    const addressN = validatePath(path, length);
+    const isStrict = typeof path === 'string'
+        ? path
+            .toLowerCase()
+            .split('/')
+            .filter(p => p !== 'm' && p !== '')
+            .every(isTextIndex)
+        : path.every(isUint32);
+    if (!isStrict)
+        throw PATH_NOT_VALID;
+    return addressN;
+};
 
 const pkg = require('../package.json');
 const getSDKVersion = () => pkg.version;
@@ -37942,6 +38003,61 @@ var nested = {
 			}
 		}
 	},
+	ZcashSignPczt: {
+		fields: {
+			pczt_length: {
+				rule: "required",
+				type: "uint32",
+				id: 1
+			},
+			pczt_initial_chunk: {
+				rule: "required",
+				type: "bytes",
+				id: 2
+			}
+		}
+	},
+	ZcashPcztChunkRequest: {
+		fields: {
+			chunk_length: {
+				rule: "required",
+				type: "uint32",
+				id: 1
+			}
+		}
+	},
+	ZcashPcztChunkAck: {
+		fields: {
+			data_chunk: {
+				rule: "required",
+				type: "bytes",
+				id: 1
+			}
+		}
+	},
+	ZcashSignedPczt: {
+		fields: {
+			pczt_length: {
+				rule: "required",
+				type: "uint32",
+				id: 1
+			},
+			pczt_initial_chunk: {
+				rule: "required",
+				type: "bytes",
+				id: 2
+			}
+		}
+	},
+	ZcashSignedPcztChunkRequest: {
+		fields: {
+			chunk_length: {
+				rule: "required",
+				type: "uint32",
+				id: 1
+			}
+		}
+	},
 	wire_in: {
 		type: "bool",
 		id: 50002,
@@ -38367,6 +38483,11 @@ var nested = {
 			MessageType_NeoAddress: 12302,
 			MessageType_NeoSignTx: 12303,
 			MessageType_NeoSignedTx: 12304,
+			MessageType_ZcashSignPczt: 12402,
+			MessageType_ZcashSignedPczt: 12403,
+			MessageType_ZcashPcztChunkRequest: 12404,
+			MessageType_ZcashPcztChunkAck: 12405,
+			MessageType_ZcashSignedPcztChunkRequest: 12406,
 			MessageType_DeviceFactoryInfoSet: 60000,
 			MessageType_DeviceFactoryInfoGet: 60001,
 			MessageType_DeviceFactoryInfo: 60002,
@@ -38419,7 +38540,9 @@ var nested = {
 			MessageType_PortfolioUpdate: 61400,
 			MessageType_NftUpdate: 61500,
 			MessageType_OnboardingStatusGet: 61600,
-			MessageType_OnboardingStatus: 61601
+			MessageType_OnboardingStatus: 61601,
+			MessageType_ZcashGetAddress: 12400,
+			MessageType_ZcashAddress: 12401
 		},
 		reserved: [
 			[
@@ -40724,6 +40847,81 @@ var nested = {
 				}
 			}
 		}
+	},
+	ZcashAddressType: {
+		values: {
+			UNIFIED_ORCHARD_P2PKH: 0,
+			TRANSPARENT_P2PKH: 1,
+			UNIFIED_ORCHARD: 2
+		}
+	},
+	ZcashAddressScope: {
+		values: {
+			EXTERNAL: 0,
+			INTERNAL: 1
+		}
+	},
+	ZcashGetAddress: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			show_display: {
+				type: "bool",
+				id: 2
+			},
+			include_seed_fingerprint: {
+				type: "bool",
+				id: 3
+			},
+			include_ufvk: {
+				type: "bool",
+				id: 4
+			},
+			diversifier_index: {
+				type: "uint32",
+				id: 5,
+				options: {
+					"default": 0
+				}
+			},
+			address_type: {
+				type: "ZcashAddressType",
+				id: 6,
+				options: {
+					"default": "UNIFIED_ORCHARD_P2PKH"
+				}
+			},
+			scope: {
+				type: "ZcashAddressScope",
+				id: 7,
+				options: {
+					"default": "EXTERNAL"
+				}
+			}
+		}
+	},
+	ZcashAddress: {
+		fields: {
+			address: {
+				rule: "required",
+				type: "string",
+				id: 1
+			},
+			ufvk: {
+				type: "string",
+				id: 2
+			},
+			seed_fingerprint: {
+				type: "bytes",
+				id: 3
+			}
+		}
 	}
 };
 var MessagesProtocolV2JSON = {
@@ -43561,6 +43759,7 @@ class BaseMethod {
         this.postPreviousAddressMessage = (data) => {
             this.postMessage(createUiMessage(UI_REQUEST.PREVIOUS_ADDRESS_RESULT, {
                 device: this.device.toMessageObject(),
+                method: this.name,
                 data,
             }));
         };
@@ -47828,7 +48027,7 @@ function parseChainId(chainId) {
 }
 
 const invalidParameter = (message) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, message);
-const invalidResponse = (message) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodError, message);
+const invalidResponse$1 = (message) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodError, message);
 const validateParams = (values, fields) => {
     fields.forEach(field => {
         const existsProp = Object.prototype.hasOwnProperty.call(values, field.name);
@@ -47905,12 +48104,12 @@ const validateParams = (values, fields) => {
 function validateResult(result, nonNullableFields, options) {
     if (Array.isArray(result)) {
         if ((options === null || options === void 0 ? void 0 : options.expectedLength) !== null && result.length !== (options === null || options === void 0 ? void 0 : options.expectedLength)) {
-            throw invalidResponse(`Expected array length of ${options === null || options === void 0 ? void 0 : options.expectedLength}, but got ${result.length}`);
+            throw invalidResponse$1(`Expected array length of ${options === null || options === void 0 ? void 0 : options.expectedLength}, but got ${result.length}`);
         }
         result.forEach((item, index) => {
             nonNullableFields.forEach(field => {
                 if (item[field] == null) {
-                    throw invalidResponse(`Field '${field}' in array item at index ${index} is null`);
+                    throw invalidResponse$1(`Field '${field}' in array item at index ${index} is null`);
                 }
             });
         });
@@ -47918,12 +48117,12 @@ function validateResult(result, nonNullableFields, options) {
     else if (typeof result === 'object' && result !== null) {
         nonNullableFields.forEach(field => {
             if (result[field] == null) {
-                throw invalidResponse(`Field '${field}' in object is null`);
+                throw invalidResponse$1(`Field '${field}' in object is null`);
             }
         });
     }
     else {
-        throw invalidResponse('Result is neither an array nor a valid object');
+        throw invalidResponse$1('Result is neither an array nor a valid object');
     }
 }
 
@@ -56204,6 +56403,11 @@ function runMethodWithUnlockPolicy(method, device, options = {}) {
 }
 
 const Mainnet = 'mainnet';
+const MoneroNetworkTypes = new Map([
+    [Mainnet, hdTransport.Messages.MoneroNetworkType.MAINNET],
+    ['testnet', hdTransport.Messages.MoneroNetworkType.TESTNET],
+    ['stagenet', hdTransport.Messages.MoneroNetworkType.STAGENET],
+]);
 const networkAliases = {
     tbtc: { name: 'btc', coin: 'Testnet' },
     bch: { name: 'btc', coin: 'Bcash' },
@@ -56392,6 +56596,36 @@ const networkConfigMap = {
     stellar: {
         methodName: 'stellarGetAddress',
     },
+    xmr: {
+        methodName: 'moneroGetAddress',
+        getParams: (baseParams, chainName) => {
+            const { path, showOnOneKey } = baseParams;
+            const networkType = MoneroNetworkTypes.get(chainName !== null && chainName !== void 0 ? chainName : Mainnet);
+            if (networkType === undefined) {
+                throw invalidParameter(`Unsupported Monero chainName: ${chainName}`);
+            }
+            return {
+                path,
+                networkType,
+                showOnOneKey,
+            };
+        },
+    },
+    zcash: {
+        methodName: 'zcashGetAddress',
+        getParams: (baseParams) => {
+            const { path, showOnOneKey } = baseParams;
+            return {
+                path,
+                showOnOneKey,
+                addressType: hdTransport.Messages.ZcashAddressType.UNIFIED_ORCHARD,
+                scope: hdTransport.Messages.ZcashAddressScope.EXTERNAL,
+                diversifierIndex: 0,
+                includeUfvk: true,
+                includeSeedFingerprint: true,
+            };
+        },
+    },
 };
 class AllNetworkGetAddressBase extends BaseMethod {
     constructor() {
@@ -65868,6 +66102,620 @@ class NeoSignTransaction extends BaseMethod {
     }
 }
 
+class ZcashGetAddress extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
+    getSupportedProtocols() {
+        return ['V2'];
+    }
+    init() {
+        var _a;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+        this.strictCheckDeviceSupport = true;
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            var _a, _b, _c, _d, _e, _f;
+            const addressN = validateStrictPath(batch.path, 3);
+            if (addressN.length !== 3 ||
+                addressN[0] !== toHardened(32) ||
+                addressN[1] !== toHardened(133) ||
+                addressN[2] < toHardened(0)) {
+                throw invalidParameter("Zcash requires a ZIP-32 account path m/32'/133'/account'");
+            }
+            const addressType = (_a = batch.addressType) !== null && _a !== void 0 ? _a : hdTransport.ZcashAddressType.UNIFIED_ORCHARD_P2PKH;
+            const scope = (_b = batch.scope) !== null && _b !== void 0 ? _b : hdTransport.ZcashAddressScope.EXTERNAL;
+            const diversifierIndex = (_c = batch.diversifierIndex) !== null && _c !== void 0 ? _c : 0;
+            if (![
+                hdTransport.ZcashAddressType.UNIFIED_ORCHARD_P2PKH,
+                hdTransport.ZcashAddressType.TRANSPARENT_P2PKH,
+                hdTransport.ZcashAddressType.UNIFIED_ORCHARD,
+            ].includes(addressType) ||
+                ![hdTransport.ZcashAddressScope.EXTERNAL, hdTransport.ZcashAddressScope.INTERNAL].includes(scope)) {
+                throw invalidParameter('Invalid Zcash address type or scope');
+            }
+            const maxIndex = addressType === hdTransport.ZcashAddressType.UNIFIED_ORCHARD ? 0xffffffff : 0x7fffffff;
+            if (!Number.isSafeInteger(diversifierIndex) ||
+                diversifierIndex < 0 ||
+                diversifierIndex > maxIndex) {
+                throw invalidParameter('Invalid Zcash diversifier index');
+            }
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'showOnOneKey', type: 'boolean' },
+                { name: 'includeUfvk', type: 'boolean' },
+                { name: 'includeSeedFingerprint', type: 'boolean' },
+            ]);
+            this.params.push({
+                address_n: addressN,
+                address_type: addressType,
+                scope,
+                diversifier_index: diversifierIndex,
+                show_display: (_d = batch.showOnOneKey) !== null && _d !== void 0 ? _d : true,
+                include_ufvk: (_e = batch.includeUfvk) !== null && _e !== void 0 ? _e : false,
+                include_seed_fingerprint: (_f = batch.includeSeedFingerprint) !== null && _f !== void 0 ? _f : false,
+            });
+        });
+    }
+    getVersionRange() {
+        return {
+            model_pro2: {
+                min: '0.0.0',
+            },
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('ZcashGetAddress', 'ZcashAddress', Object.assign({}, param));
+                const path = serializedPath(param.address_n);
+                const { address, ufvk, seed_fingerprint: seedFingerprint } = res.message;
+                responses.push(Object.assign(Object.assign({ path,
+                    address }, (ufvk ? { ufvk } : {})), (seedFingerprint ? { seedFingerprint } : {})));
+                this.postPreviousAddressMessage({ address, path });
+            }
+            validateResult(responses, ['address'], {
+                expectedLength: this.params.length,
+            });
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
+        });
+    }
+}
+
+const CHUNK_BYTE_SIZE = 1024;
+const SIGNED_PCZT_SANITY_MAX_BYTES = 16 * 1024 * 1024;
+class ZcashSignPczt extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.pczt = Buffer.alloc(0);
+        this.uploadPczt = (typedCall, first, initialOffset) => __awaiter(this, void 0, void 0, function* () {
+            let res = first;
+            let offset = initialOffset;
+            while (res.type === 'ZcashPcztChunkRequest') {
+                const { chunk_length: chunkLength } = res.message;
+                if (!Number.isSafeInteger(chunkLength) ||
+                    chunkLength <= 0 ||
+                    offset + chunkLength > this.pczt.length) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ResponseUnexpectTypeError, `device requested ${chunkLength} bytes at offset ${offset} of ${this.pczt.length}`);
+                }
+                const chunk = this.pczt.subarray(offset, offset + chunkLength);
+                res = yield typedCall('ZcashPcztChunkAck', ['ZcashSignedPczt', 'ZcashPcztChunkRequest'], {
+                    data_chunk: utils.bytesToHex(chunk),
+                });
+                offset += chunkLength;
+            }
+            if (offset !== this.pczt.length) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ResponseUnexpectTypeError, 'device completed signing before receiving the whole pczt');
+            }
+            return res;
+        });
+        this.downloadSignedPczt = (typedCall, res) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { pczt_length: total, pczt_initial_chunk: initial } = res.message;
+            if (!Number.isSafeInteger(total) || total <= 0 || total > SIGNED_PCZT_SANITY_MAX_BYTES) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ResponseUnexpectTypeError, `device announced invalid signed pczt length ${total}`);
+            }
+            const parts = [Buffer.from(initial !== null && initial !== void 0 ? initial : '', 'hex')];
+            let received = parts[0].length;
+            if (received > total) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ResponseUnexpectTypeError, 'device returned more initial pczt bytes than announced');
+            }
+            while (received < total) {
+                const chunkLength = Math.min(CHUNK_BYTE_SIZE, total - received);
+                const ack = yield typedCall('ZcashSignedPcztChunkRequest', 'ZcashPcztChunkAck', {
+                    chunk_length: chunkLength,
+                });
+                const chunk = Buffer.from((_a = ack.message.data_chunk) !== null && _a !== void 0 ? _a : '', 'hex');
+                if (chunk.length !== chunkLength) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ResponseUnexpectTypeError, `device returned ${chunk.length} of ${chunkLength} requested bytes at offset ${received} of ${total}`);
+                }
+                parts.push(chunk);
+                received += chunk.length;
+            }
+            return Buffer.concat(parts);
+        });
+    }
+    getSupportedProtocols() {
+        return ['V2'];
+    }
+    init() {
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+        this.strictCheckDeviceSupport = true;
+        validateParams(this.payload, [{ name: 'pczt', type: 'hexString', required: true }]);
+        const pcztHex = stripHexPrefix(this.payload.pczt);
+        if (pcztHex.length % 2 !== 0) {
+            throw invalidParameter('pczt hex must have an even length');
+        }
+        this.pczt = Buffer.from(pcztHex, 'hex');
+        if (this.pczt.length === 0) {
+            throw invalidParameter('pczt is empty');
+        }
+        this.params = {
+            pczt_length: this.pczt.length,
+            pczt_initial_chunk: utils.bytesToHex(this.pczt.subarray(0, CHUNK_BYTE_SIZE)),
+        };
+    }
+    getVersionRange() {
+        return {
+            model_pro2: {
+                min: '0.0.0',
+            },
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+            const first = yield typedCall('ZcashSignPczt', ['ZcashSignedPczt', 'ZcashPcztChunkRequest'], Object.assign({}, this.params));
+            const signed = yield this.uploadPczt(typedCall, first, Math.min(CHUNK_BYTE_SIZE, this.pczt.length));
+            const pczt = yield this.downloadSignedPczt(typedCall, signed);
+            return { pczt: utils.bytesToHex(pczt) };
+        });
+    }
+}
+
+const NETWORK_TYPES = [0, 1, 2];
+function validateMoneroNetworkType(networkType) {
+    const value = networkType !== null && networkType !== void 0 ? networkType : 0;
+    if (!NETWORK_TYPES.includes(value)) {
+        throw invalidParameter('Invalid Monero network type');
+    }
+    return value;
+}
+function decodeMoneroAddress(hex) {
+    return hex ? Buffer.from(hexToBytes(hex)).toString('utf-8') : undefined;
+}
+function getMoneroVersionRange() {
+    return {
+        model_touch: {
+            min: '0.0.0',
+        },
+    };
+}
+
+class MoneroGetAddress extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
+    getSupportedProtocols() {
+        return ['V1', 'V2'];
+    }
+    init() {
+        var _a;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+        this.strictCheckDeviceSupport = true;
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            var _a;
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'showOnOneKey', type: 'boolean' },
+                { name: 'networkType', type: 'number' },
+            ]);
+            this.params.push({
+                address_n: validateStrictPath(batch.path, 3),
+                network_type: validateMoneroNetworkType(batch.networkType),
+                show_display: (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true,
+            });
+        });
+    }
+    getVersionRange() {
+        return getMoneroVersionRange();
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('MoneroGetAddress', 'MoneroAddress', Object.assign({}, param));
+                const path = serializedPath(param.address_n);
+                const address = decodeMoneroAddress(res.message.address);
+                responses.push({ path, address });
+                this.postPreviousAddressMessage({ address, path });
+            }
+            validateResult(responses, ['address'], {
+                expectedLength: this.params.length,
+            });
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
+        });
+    }
+}
+
+class MoneroGetWatchKey extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
+    getSupportedProtocols() {
+        return ['V1', 'V2'];
+    }
+    init() {
+        var _a;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+        this.strictCheckDeviceSupport = true;
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'networkType', type: 'number' },
+            ]);
+            this.params.push({
+                address_n: validateStrictPath(batch.path, 3),
+                network_type: validateMoneroNetworkType(batch.networkType),
+            });
+        });
+    }
+    getVersionRange() {
+        return getMoneroVersionRange();
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('MoneroGetWatchKey', 'MoneroWatchKey', Object.assign({}, param));
+                responses.push({
+                    path: serializedPath(param.address_n),
+                    watchKey: res.message.watch_key,
+                    address: decodeMoneroAddress(res.message.address),
+                });
+            }
+            validateResult(responses, ['watchKey', 'address'], {
+                expectedLength: this.params.length,
+            });
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
+        });
+    }
+}
+
+const STEP_SIZE = 10;
+const UINT32_MAX = 0xffffffff;
+const parseKey = (value, name) => {
+    const hex = typeof value === 'string' ? stripHexPrefix(value) : '';
+    if (!/^[0-9a-fA-F]{64}$/.test(hex)) {
+        throw invalidParameter(`${name} must be a 32-byte hex string`);
+    }
+    return hex.toLowerCase();
+};
+const parseUint = (value, name, max = Number.MAX_SAFE_INTEGER) => {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0 || value > max) {
+        throw invalidParameter(`${name} must be an unsigned integer`);
+    }
+    return value;
+};
+const parseTransfer = (transfer, index) => {
+    var _a, _b, _c;
+    const name = `transfers[${index}]`;
+    if (!transfer || typeof transfer !== 'object') {
+        throw invalidParameter(`${name} must be an object`);
+    }
+    const additional = (_a = transfer.additionalTxPubKeys) !== null && _a !== void 0 ? _a : [];
+    if (!Array.isArray(additional)) {
+        throw invalidParameter(`${name}.additionalTxPubKeys must be an array`);
+    }
+    return {
+        out_key: parseKey(transfer.outKey, `${name}.outKey`),
+        tx_pub_key: parseKey(transfer.txPubKey, `${name}.txPubKey`),
+        additional_tx_pub_keys: additional.map((key, i) => parseKey(key, `${name}.additionalTxPubKeys[${i}]`)),
+        internal_output_index: parseUint(transfer.internalOutputIndex, `${name}.internalOutputIndex`),
+        sub_addr_major: parseUint((_b = transfer.subAddrMajor) !== null && _b !== void 0 ? _b : 0, `${name}.subAddrMajor`, UINT32_MAX),
+        sub_addr_minor: parseUint((_c = transfer.subAddrMinor) !== null && _c !== void 0 ? _c : 0, `${name}.subAddrMinor`, UINT32_MAX),
+    };
+};
+const encodeUvarint = (value) => {
+    const bytes = [];
+    let n = value;
+    while (n >= 0x80) {
+        bytes.push((n % 0x80) + 0x80);
+        n = Math.floor(n / 0x80);
+    }
+    bytes.push(n);
+    return Uint8Array.from(bytes);
+};
+const computeTransfersHash = (tdis) => {
+    const total = sha3.keccak_256.create();
+    tdis.forEach(td => {
+        const hash = sha3.keccak_256.create();
+        hash.update(hexToBytes(td.out_key));
+        hash.update(hexToBytes(td.tx_pub_key));
+        td.additional_tx_pub_keys.forEach(key => hash.update(hexToBytes(key)));
+        hash.update(encodeUvarint(td.internal_output_index));
+        total.update(hash.digest());
+    });
+    return utils.bytesToHex(total.digest());
+};
+class MoneroKeyImageSync extends BaseMethod {
+    getSupportedProtocols() {
+        return ['V1', 'V2'];
+    }
+    init() {
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+        this.strictCheckDeviceSupport = true;
+        const payload = this.payload;
+        validateParams(payload, [
+            { name: 'path', required: true },
+            { name: 'networkType', type: 'number' },
+            { name: 'transfers', type: 'array', required: true },
+        ]);
+        if (!Array.isArray(payload.transfers) || payload.transfers.length === 0) {
+            throw invalidParameter('transfers must be a non-empty array');
+        }
+        this.params = {
+            address_n: validateStrictPath(payload.path, 3),
+            network_type: validateMoneroNetworkType(payload.networkType),
+            tdis: payload.transfers.map(parseTransfer),
+        };
+    }
+    getVersionRange() {
+        return getMoneroVersionRange();
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { address_n, network_type, tdis } = this.params;
+            yield this.device.commands.typedCall('MoneroKeyImageExportInitRequest', 'MoneroKeyImageExportInitAck', {
+                num: tdis.length,
+                hash: computeTransfersHash(tdis),
+                address_n,
+                network_type,
+                subs: [],
+            });
+            const keyImages = [];
+            for (let start = 0; start < tdis.length; start += STEP_SIZE) {
+                const res = yield this.device.commands.typedCall('MoneroKeyImageSyncStepRequest', 'MoneroKeyImageSyncStepAck', { tdis: tdis.slice(start, start + STEP_SIZE) });
+                res.message.kis.forEach(ki => keyImages.push({ iv: ki.iv, blob: ki.blob }));
+            }
+            const res = yield this.device.commands.typedCall('MoneroKeyImageSyncFinalRequest', 'MoneroKeyImageSyncFinalAck', {});
+            const encKey = res.message.enc_key;
+            validateResult(keyImages, ['iv', 'blob'], { expectedLength: tdis.length });
+            validateResult({ encKey }, ['encKey']);
+            return Promise.resolve({ encKey, keyImages });
+        });
+    }
+}
+
+const BP_PLUS_VERSION = 4;
+const OFFLOAD_RANGE_PROOF = 1;
+const KEY_IMAGE_HEX_LENGTH = 64;
+const invalidResponse = (message) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodError, message);
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const requireBytes = (value, name) => {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw invalidResponse(`Device response is missing ${name}`);
+    }
+    return value;
+};
+const withoutNulls = (value) => {
+    if (Array.isArray(value))
+        return value.map(withoutNulls);
+    if (!isObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, item]) => item !== null && item !== undefined)
+        .map(([key, item]) => [key, withoutNulls(item)]));
+};
+const validateObjects = (values, name) => {
+    values.forEach((value, index) => {
+        if (!isObject(value)) {
+            throw invalidParameter(`${name}[${index}] must be an object`);
+        }
+    });
+};
+const validateTsxData = (tsxData, inputCount) => {
+    if (tsxData.num_inputs !== inputCount) {
+        throw invalidParameter('tsxData.num_inputs must equal the number of inputs');
+    }
+    const { outputs } = tsxData;
+    if (!Array.isArray(outputs) || outputs.length < 2) {
+        throw invalidParameter('tsxData.outputs must hold at least 2 outputs');
+    }
+    validateObjects(outputs, 'tsxData.outputs');
+    const hardFork = tsxData.hard_fork;
+    if (typeof hardFork !== 'number' || !Number.isSafeInteger(hardFork) || hardFork <= 0) {
+        throw invalidParameter('tsxData.hard_fork is required');
+    }
+    const rsigData = tsxData.rsig_data;
+    if (!isObject(rsigData) || rsigData.bp_version !== BP_PLUS_VERSION) {
+        throw invalidParameter('tsxData.rsig_data.bp_version must be 4 (Bulletproof+)');
+    }
+    const { grouping } = rsigData;
+    const validBatches = Array.isArray(grouping) &&
+        grouping.every(size => Number.isSafeInteger(size) && size > 0) &&
+        grouping.reduce((sum, size) => sum + size, 0) === outputs.length;
+    if (!validBatches) {
+        throw invalidParameter('tsxData.rsig_data.grouping must add up to the number of outputs');
+    }
+};
+const parseSetInputAck = (ack, origIdx) => {
+    const name = (field) => `${field} of input ${origIdx}`;
+    const vini = requireBytes(ack.vini, name('vini'));
+    if (vini.length < KEY_IMAGE_HEX_LENGTH) {
+        throw invalidResponse(`Device returned a vini without a key image for input ${origIdx}`);
+    }
+    return {
+        origIdx,
+        keyImage: vini.slice(-KEY_IMAGE_HEX_LENGTH).toLowerCase(),
+        vini,
+        vini_hmac: requireBytes(ack.vini_hmac, name('vini_hmac')),
+        pseudo_out: requireBytes(ack.pseudo_out, name('pseudo_out')),
+        pseudo_out_hmac: requireBytes(ack.pseudo_out_hmac, name('pseudo_out_hmac')),
+        pseudo_out_alpha: requireBytes(ack.pseudo_out_alpha, name('pseudo_out_alpha')),
+        spend_key: requireBytes(ack.spend_key, name('spend_key')),
+    };
+};
+const parseAllOutSetAck = (ack) => {
+    const { rv } = ack;
+    if (!rv || rv.txn_fee == null || rv.rv_type == null) {
+        throw invalidResponse('Device response is missing rv');
+    }
+    return {
+        extra: requireBytes(ack.extra, 'extra'),
+        txPrefixHash: requireBytes(ack.tx_prefix_hash, 'tx_prefix_hash'),
+        fullMessageHash: requireBytes(ack.full_message_hash, 'full_message_hash'),
+        rv: {
+            txnFee: String(rv.txn_fee),
+            message: requireBytes(rv.message, 'rv.message'),
+            rvType: rv.rv_type,
+        },
+    };
+};
+const sortByKeyImage = (inputs) => {
+    const sorted = [...inputs].sort((a, b) => {
+        if (a.keyImage === b.keyImage)
+            return 0;
+        return a.keyImage > b.keyImage ? -1 : 1;
+    });
+    sorted.forEach((input, index) => {
+        if (index > 0 && sorted[index - 1].keyImage === input.keyImage) {
+            throw invalidResponse('Two inputs have the same key image');
+        }
+    });
+    return sorted;
+};
+class MoneroSignTransaction extends BaseMethod {
+    getSupportedProtocols() {
+        return ['V1', 'V2'];
+    }
+    init() {
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+        this.strictCheckDeviceSupport = true;
+        const payload = this.payload;
+        validateParams(payload, [
+            { name: 'path', required: true },
+            { name: 'networkType', type: 'number' },
+            { name: 'tsxData', type: 'object', required: true },
+            { name: 'inputs', type: 'array', required: true },
+        ]);
+        if (!isObject(payload.tsxData)) {
+            throw invalidParameter('tsxData must be an object');
+        }
+        if (!Array.isArray(payload.inputs) || payload.inputs.length === 0) {
+            throw invalidParameter('inputs must be a non-empty array');
+        }
+        validateObjects(payload.inputs, 'inputs');
+        const tsxData = withoutNulls(payload.tsxData);
+        validateTsxData(tsxData, payload.inputs.length);
+        this.params = {
+            address_n: validateStrictPath(payload.path, 3),
+            network_type: validateMoneroNetworkType(payload.networkType),
+            tsx_data: tsxData,
+            inputs: payload.inputs.map(input => withoutNulls(input)),
+        };
+    }
+    getVersionRange() {
+        return getMoneroVersionRange();
+    }
+    run() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { address_n, network_type, tsx_data, inputs } = this.params;
+            const { outputs } = tsx_data;
+            const init = yield this.device.commands.typedCall('MoneroTransactionInitRequest', 'MoneroTransactionInitAck', { version: 0, address_n, network_type, tsx_data });
+            if (((_a = init.message.rsig_data) === null || _a === void 0 ? void 0 : _a.offload_type) === OFFLOAD_RANGE_PROOF) {
+                throw invalidResponse('The device asked the host to prove the range proof, which is not supported: send at most 2 outputs');
+            }
+            const { hmacs } = init.message;
+            if (!Array.isArray(hmacs) || hmacs.length !== outputs.length) {
+                throw invalidResponse('Device returned a wrong number of output HMACs');
+            }
+            const states = [];
+            for (let i = 0; i < inputs.length; i++) {
+                const res = yield this.device.commands.typedCall('MoneroTransactionSetInputRequest', 'MoneroTransactionSetInputAck', { src_entr: inputs[i] });
+                states.push(parseSetInputAck(res.message, i));
+            }
+            const sorted = sortByKeyImage(states);
+            for (const input of sorted) {
+                yield this.device.commands.typedCall('MoneroTransactionInputViniRequest', 'MoneroTransactionInputViniAck', {
+                    src_entr: inputs[input.origIdx],
+                    vini: input.vini,
+                    vini_hmac: input.vini_hmac,
+                    pseudo_out: input.pseudo_out,
+                    pseudo_out_hmac: input.pseudo_out_hmac,
+                    orig_idx: input.origIdx,
+                });
+            }
+            yield this.device.commands.typedCall('MoneroTransactionAllInputsSetRequest', 'MoneroTransactionAllInputsSetAck', {});
+            const txOuts = [];
+            const outPks = [];
+            const ecdhInfos = [];
+            const rsigs = [];
+            for (let i = 0; i < outputs.length; i++) {
+                const res = yield this.device.commands.typedCall('MoneroTransactionSetOutputRequest', 'MoneroTransactionSetOutputAck', { dst_entr: outputs[i], dst_entr_hmac: hmacs[i] });
+                txOuts.push(requireBytes(res.message.tx_out, `tx_out of output ${i}`));
+                outPks.push(requireBytes(res.message.out_pk, `out_pk of output ${i}`));
+                ecdhInfos.push(requireBytes(res.message.ecdh_info, `ecdh_info of output ${i}`));
+                const rsig = (_b = res.message.rsig_data) === null || _b === void 0 ? void 0 : _b.rsig;
+                if (rsig)
+                    rsigs.push(rsig);
+            }
+            if (rsigs.length !== 1) {
+                throw invalidResponse(`Expected one aggregated range proof, got ${rsigs.length}`);
+            }
+            const allOut = yield this.device.commands.typedCall('MoneroTransactionAllOutSetRequest', 'MoneroTransactionAllOutSetAck', {});
+            const prefix = parseAllOutSetAck(allOut.message);
+            const signatures = [];
+            const pseudoOuts = [];
+            for (const input of sorted) {
+                const res = yield this.device.commands.typedCall('MoneroTransactionSignInputRequest', 'MoneroTransactionSignInputAck', {
+                    src_entr: inputs[input.origIdx],
+                    vini: input.vini,
+                    vini_hmac: input.vini_hmac,
+                    pseudo_out: input.pseudo_out,
+                    pseudo_out_hmac: input.pseudo_out_hmac,
+                    pseudo_out_alpha: input.pseudo_out_alpha,
+                    spend_key: input.spend_key,
+                    orig_idx: input.origIdx,
+                });
+                signatures.push(requireBytes(res.message.signature, `signature of input ${input.origIdx}`));
+                pseudoOuts.push(requireBytes(res.message.pseudo_out, `pseudo_out of input ${input.origIdx}`));
+            }
+            const final = yield this.device.commands.typedCall('MoneroTransactionFinalRequest', 'MoneroTransactionFinalAck', {});
+            return Object.assign(Object.assign({ origIndices: sorted.map(input => input.origIdx), vinis: sorted.map(input => input.vini), pseudoOuts,
+                signatures,
+                txOuts,
+                outPks,
+                ecdhInfos, rsig: rsigs[0] }, prefix), { openingKey: requireBytes(final.message.opening_key, 'opening_key'), salt: requireBytes(final.message.salt, 'salt'), randMult: requireBytes(final.message.rand_mult, 'rand_mult'), txEncKeys: requireBytes(final.message.tx_enc_keys, 'tx_enc_keys') });
+        });
+    }
+}
+
 var ApiMethods = /*#__PURE__*/Object.freeze({
     __proto__: null,
     testInitializeDeviceDuration: TestInitializeDeviceDuration,
@@ -66011,7 +66859,13 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     benfenSignMessage: BenfenSignMessage,
     benfenSignTransaction: BenfenSignTransaction,
     neoGetAddress: NeoGetAddress,
-    neoSignTransaction: NeoSignTransaction
+    neoSignTransaction: NeoSignTransaction,
+    zcashGetAddress: ZcashGetAddress,
+    zcashSignPczt: ZcashSignPczt,
+    moneroGetAddress: MoneroGetAddress,
+    moneroGetWatchKey: MoneroGetWatchKey,
+    moneroKeyImageSync: MoneroKeyImageSync,
+    moneroSignTransaction: MoneroSignTransaction
 });
 
 const publicMethodRegistry = ApiMethods;
@@ -67421,7 +68275,7 @@ const cancel = (context, connectId) => {
             };
             for (const requestId of requestIds) {
                 const task = requestQueue.getTask(requestId);
-                Log.debug('Cancel Api connect task: ', task);
+                Log.debug('Cancel Api connect task: ', getSafeLogTask(task));
                 if (task) {
                     interruptDevice((_a = task.method) === null || _a === void 0 ? void 0 : _a.device, connectId);
                     interruptDevice(deviceCacheMap.get(connectId), connectId);
@@ -67450,7 +68304,7 @@ const cancel = (context, connectId) => {
             };
             for (const requestId of requestQueue.getRequestTasksId()) {
                 const task = requestQueue.getTask(requestId);
-                Log.debug('Cancel Api connect task: ', task);
+                Log.debug('Cancel Api connect task: ', getSafeLogTask(task));
                 if (task) {
                     interruptDevice((_b = task.method) === null || _b === void 0 ? void 0 : _b.device);
                     if (task.method.connectId) {
@@ -67740,7 +68594,7 @@ class Core extends events.exports {
                     break;
                 }
                 case IFRAME.CALLBACK: {
-                    Log.log('callback message: ', message);
+                    Log.log('callback message: ', getSafeLogPayload(message));
                     postMessage(message);
                     break;
                 }
@@ -67978,6 +68832,7 @@ exports.getNftSize = getNftSize;
 exports.getOutputScriptType = getOutputScriptType;
 exports.getSDKVersion = getSDKVersion;
 exports.getSafeLogPayload = getSafeLogPayload;
+exports.getSafeLogTask = getSafeLogTask;
 exports.getScriptType = getScriptType;
 exports.getTimeStamp = getTimeStamp;
 exports.httpRequest = httpRequest;