@onekeyfe/hd-core 1.2.8-alpha.1 → 1.2.8-alpha.100

package/dist/index.js

@@ -1635,6 +1635,7 @@ const createCoreApi = (call) => ({
     evmVerifyMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmVerifyMessage' })),
     btcGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcGetAddress' })),
     btcGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcGetPublicKey' })),
+    btcDeriveContextHash: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcDeriveContextHash' })),
     btcSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcSignMessage' })),
     btcSignPsbt: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcSignPsbt' })),
     btcSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcSignTransaction' })),
@@ -1720,6 +1721,8 @@ 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' })),
 });
 
 const lowLevelInject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, updateSettings, switchTransport, addHardwareGlobalEventListener, }) => {
@@ -15448,6 +15451,8 @@ var nested$2 = {
 			"(has_bitcoin_only_values)": true
 		},
 		values: {
+			MessageType_BabylonDeriveContextHash: 10054,
+			MessageType_BabylonDerivedContextHash: 10055,
 			MessageType_Initialize: 0,
 			MessageType_Ping: 1,
 			MessageType_Success: 2,
@@ -15912,6 +15917,55 @@ var nested$2 = {
 			MessageType_UpgradeFileHeader: 10050
 		}
 	},
+	CanonicalBitcoinNetwork: {
+		values: {
+			BITCOIN_MAINNET: 0,
+			BITCOIN_TESTNET: 1,
+			BITCOIN_SIGNET: 2,
+			BITCOIN_REGTEST: 3
+		}
+	},
+	BabylonDeriveContextHash: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			script_type: {
+				rule: "required",
+				type: "InputScriptType",
+				id: 2
+			},
+			app_name: {
+				rule: "required",
+				type: "bytes",
+				id: 3
+			},
+			context: {
+				rule: "required",
+				type: "bytes",
+				id: 4
+			},
+			network: {
+				rule: "required",
+				type: "CanonicalBitcoinNetwork",
+				id: 5
+			}
+		}
+	},
+	BabylonDerivedContextHash: {
+		fields: {
+			secret: {
+				rule: "required",
+				type: "bytes",
+				id: 1
+			}
+		}
+	},
 	google: {
 		nested: {
 			protobuf: {
@@ -38114,6 +38168,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,
@@ -38539,6 +38648,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,
@@ -38591,7 +38705,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: [
 			[
@@ -40896,6 +41012,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 = {
@@ -41534,7 +41725,7 @@ const parseMessage = (messageData) => {
 const createErrorMessage = (error) => {
     let payload = { error: error.message, code: error.code };
     if (error instanceof hdShared.HardwareError) {
-        payload = { error: error.message, code: error.errorCode };
+        payload = { error: error.message, code: error.errorCode, params: error.params };
     }
     return {
         success: false,
@@ -41696,11 +41887,15 @@ const LogBlockEvent = new Set([
     UI_RESPONSE.RECEIVE_PASSPHRASE,
 ]);
 const LogPayloadBlockMethod = new Set([
+    'btcDeriveContextHash',
     'deviceUploadNft',
     'deviceUploadWallpaper',
     'uploadPortfolio',
     'fileWrite',
     'fileRead',
+    'zcashGetAddress',
+    'zcashGetUnifiedAddress',
+    'zcashSignPczt',
 ]);
 function getLogBlockLabel(message) {
     if (!message || typeof message !== 'object')
@@ -43466,7 +43661,9 @@ class DevicePool extends events.exports {
                     const exist = canPathIdentifyDevice(cachedPath)
                         ? descriptorList.find(d => d.path === cachedPath)
                         : undefined;
-                    if (exist && !(initOptions === null || initOptions === void 0 ? void 0 : initOptions.forceProtocolDetection)) {
+                    if (exist &&
+                        !(initOptions === null || initOptions === void 0 ? void 0 : initOptions.forceProtocolDetection) &&
+                        !(device.needReloadDevice && device.isUnacquired())) {
                         device.updateDescriptor(exist, true);
                         yield this._refreshRuntimeState(device, initOptions);
                         devices[connectId] = device;
@@ -43522,7 +43719,11 @@ class DevicePool extends events.exports {
             const forceProtocolDetection = (initOptions === null || initOptions === void 0 ? void 0 : initOptions.forceProtocolDetection) === true;
             const isNewDevice = !cachedDevice;
             const device = cachedDevice !== null && cachedDevice !== void 0 ? cachedDevice : Device.fromDescriptor(descriptor);
-            if (isNewDevice || forceProtocolDetection) {
+            if (isNewDevice ||
+                forceProtocolDetection ||
+                (device.needReloadDevice && device.isUnacquired())) {
+                if (cachedDevice)
+                    device.updateDescriptor(descriptor, true);
                 device.deviceConnector = this.connector;
                 (_a = device.beginConnectionAttempt) === null || _a === void 0 ? void 0 : _a.call(device);
                 if (forceProtocolDetection && !isNewDevice) {
@@ -44209,6 +44410,12 @@ class DeviceCommands {
                 const isProtocolV2DeviceBusyFailure = this.device.isProtocolV2() &&
                     DEVICE_CONTROL_CALLS.has(callType) &&
                     subcode === hdTransport.DeviceErrorCode.DeviceError_Busy;
+                const isProtocolV2PinCancelledBusyFailure = this.device.isProtocolV2() &&
+                    !DEVICE_SESSION_CALLS.has(callType) &&
+                    subcode === hdTransport.DeviceSessionErrorCode.DeviceSessionError_UserCancelled &&
+                    /^pin cancelled$/i.test(normalizedMessage);
+                const isProtocolV2FirmwareUpdateBusyFailure = this.device.isProtocolV2() &&
+                    /^requested command not allowed while a firmware update is in progress$/i.test(normalizedMessage);
                 const isLegacyProtocolV2LockedFailure = this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
                 if (DEVICE_SESSION_CALLS.has(callType) &&
                     subcode === hdTransport.DeviceSessionErrorCode.DeviceSessionError_InvalidSession) {
@@ -44259,7 +44466,9 @@ class DeviceCommands {
                         firmwareMessage: message,
                     });
                 }
-                else if (isProtocolV2DeviceBusyFailure) {
+                else if (isProtocolV2DeviceBusyFailure ||
+                    isProtocolV2PinCancelledBusyFailure ||
+                    isProtocolV2FirmwareUpdateBusyFailure) {
                     error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceBusy, message, {
                         failureCode: code,
                         subcode,
@@ -45486,6 +45695,7 @@ class Device extends events.exports {
         this.connectionAttempt = 0;
         this.interruptedAttempt = null;
         this.stateStore = new DeviceStateStore();
+        this.deviceBeforeWipe = null;
         this.protocolV2StateNeedsReload = false;
         this.protocolV2UiInteractionCounter = 0;
         this.externalState = [];
@@ -45509,6 +45719,7 @@ class Device extends events.exports {
         var _a;
         if (this.isUnacquired() || !this.features)
             return null;
+        this.deviceBeforeWipe = null;
         const env = DataManager.getSettings('env');
         const deviceType = this.getCurrentDeviceType();
         const bleName = this.getCurrentBleName();
@@ -45542,6 +45753,10 @@ class Device extends events.exports {
             unavailableCapabilities: this.unavailableCapabilities,
         };
     }
+    toDisconnectMessageObject() {
+        var _a;
+        return (_a = this.toMessageObject()) !== null && _a !== void 0 ? _a : this.deviceBeforeWipe;
+    }
     connect(connectProtocol, options) {
         const env = DataManager.getSettings('env');
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -46293,6 +46508,8 @@ class Device extends events.exports {
         this.invalidateProtocolV2RuntimeState();
     }
     invalidateAfterWipe() {
+        var _a;
+        this.deviceBeforeWipe = (_a = this.toMessageObject()) !== null && _a !== void 0 ? _a : this.deviceBeforeWipe;
         const deviceId = this.getCurrentDeviceId();
         if (deviceId) {
             deviceWalletSessionStore.deleteDevice(deviceId);
@@ -46661,7 +46878,7 @@ class Device extends events.exports {
     }
     hasUnexpectedMode(allow, require) {
         if (!this.isUnacquired()) {
-            if (this.isBootloader() && !this.isProtocolV2() && !allow.includes(UI_REQUEST.BOOTLOADER)) {
+            if ((this.isBootloader() || this.isRomloader()) && !allow.includes(UI_REQUEST.BOOTLOADER)) {
                 return UI_REQUEST.BOOTLOADER;
             }
             if (!this.isInitialized() && !allow.includes(UI_REQUEST.NOT_INITIALIZE)) {
@@ -47472,7 +47689,7 @@ class GetDeviceState extends BaseMethod {
             if (this.params.scope === 'settings' &&
                 this.device.isProtocolV2() &&
                 isLoaderMode(state.status.mode)) {
-                throw hdShared.createDeviceNotSupportMethodError(`${this.name}:${this.params.scope}`, this.device.getCurrentFirmwareType());
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NotAllowInBootloaderMode);
             }
             return state;
         });
@@ -52591,12 +52808,11 @@ const getProtocolV2ErrorCode = (error) => {
 };
 const isProtocolV2TerminalInstallStatusError = (error) => {
     var _a;
-    return hdShared.isBleStaleBondHardwareError(error) ||
-        (error instanceof hdShared.HardwareError &&
-            (error.errorCode === hdShared.HardwareErrorCode.ActionCancelled ||
-                error.errorCode === hdShared.HardwareErrorCode.FirmwareError ||
-                error.errorCode === hdShared.HardwareErrorCode.FirmwareVerificationFailed ||
-                ((_a = error.params) === null || _a === void 0 ? void 0 : _a.firmwareUpdateCode) === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE));
+    return error instanceof hdShared.HardwareError &&
+        (error.errorCode === hdShared.HardwareErrorCode.ActionCancelled ||
+            error.errorCode === hdShared.HardwareErrorCode.FirmwareError ||
+            error.errorCode === hdShared.HardwareErrorCode.FirmwareVerificationFailed ||
+            ((_a = error.params) === null || _a === void 0 ? void 0 : _a.firmwareUpdateCode) === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE);
 };
 const isProtocolV2TargetStatusFinished = (status) => normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_FINISHED;
 const isProtocolV2TargetStatusInProgress = (status) => normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_PENDING ||
@@ -53690,9 +53906,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 return true;
             }
             catch (error) {
-                if (hdShared.isBleStaleBondHardwareError(error)) {
-                    throw error;
-                }
                 Log$6.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
                 return false;
             }
@@ -53777,7 +53990,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     lastError = new Error('Protocol V2 device is reachable but is not in bootloader mode');
                 }
                 catch (error) {
-                    if (hdShared.isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
+                    if (this.isProtocolV2ReconnectIdentityError(error)) {
                         throw error;
                     }
                     shouldReconnect = true;
@@ -53994,9 +54207,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 }
                 catch (error) {
                     this.throwIfAborted();
-                    if (hdShared.isBleStaleBondHardwareError(error)) {
-                        throw error;
-                    }
                     lastError = error;
                     if (attempt < PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
                         yield this.recoverProtocolV2FileTransfer();
@@ -54485,9 +54695,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 }
             }
             catch (error) {
-                if (hdShared.isBleStaleBondHardwareError(error)) {
-                    throw error;
-                }
                 Log$6.log('[FirmwareUpdateV4] unable to confirm App mode before Normal reboot: ', error);
             }
             yield this.protocolV2Reboot(hdTransport.DeviceRebootType.Normal);
@@ -54562,7 +54769,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     lastError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'Protocol V2 device is still in bootloader mode');
                 }
                 catch (error) {
-                    if (hdShared.isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
+                    if (this.isProtocolV2ReconnectIdentityError(error)) {
                         throw error;
                     }
                     shouldReconnect = true;
@@ -54840,6 +55047,7 @@ class DeviceReboot extends BaseMethod {
         return ['V2'];
     }
     init() {
+        this.allowDeviceMode.push(UI_REQUEST.BOOTLOADER);
         this.skipForceUpdateCheck = true;
         this.useDevicePassphraseState = false;
         this.unlockPolicy = 'unlock-before-run';
@@ -57136,6 +57344,72 @@ class BTCGetPublicKey extends BaseMethod {
     }
 }
 
+const NETWORKS = {
+    'bitcoin-mainnet': 'BITCOIN_MAINNET',
+    'bitcoin-testnet': 'BITCOIN_TESTNET',
+    'bitcoin-signet': 'BITCOIN_SIGNET',
+    'bitcoin-regtest': 'BITCOIN_REGTEST',
+};
+class BTCDeriveContextHash extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.strictCheckDeviceSupport = true;
+    }
+    init() {
+        this.checkDeviceId = true;
+        this.allowUsePreInitialize = true;
+        validateParams(this.payload, [
+            { name: 'path', required: true },
+            { name: 'appName', type: 'string', required: true },
+            { name: 'context', type: 'string', required: true },
+            { name: 'network', type: 'string', required: true },
+        ]);
+        const { path, appName, context, network } = this.payload;
+        if (typeof appName !== 'string' || !/^[a-z0-9-]{1,64}$/.test(appName)) {
+            throw invalidParameter('appName must contain 1..64 ASCII lowercase letters, digits or hyphens');
+        }
+        if (typeof context !== 'string' || !/^(?:[0-9a-f]{2}){1,1024}$/.test(context)) {
+            throw invalidParameter('context must be 1..1024 bytes of lowercase hex without a prefix');
+        }
+        if (typeof network !== 'string' || !Object.prototype.hasOwnProperty.call(NETWORKS, network)) {
+            throw invalidParameter('Unsupported Bitcoin network');
+        }
+        if ((typeof path === 'string' &&
+            (!/^m(?:\/\d+'?)+$/i.test(path) ||
+                path
+                    .split('/')
+                    .slice(1)
+                    .some(index => Number(index.replace(/'/g, '')) >= 0x80000000))) ||
+            (Array.isArray(path) &&
+                path.findIndex(index => !Number.isInteger(index) || index < 0 || index > 0xffffffff) !== -1)) {
+            throw invalidParameter('Not a valid BIP-32 path');
+        }
+        const addressN = validatePath(path, 3);
+        this.params = {
+            address_n: addressN,
+            script_type: getScriptType(addressN),
+            app_name: buffer.Buffer.from(appName, 'ascii').toString('hex'),
+            context,
+            network: NETWORKS[network],
+        };
+    }
+    getVersionRange() {
+        return {
+            classic1s: { min: '3.21.0' },
+            classicpure: { min: '3.21.0' },
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { message } = yield this.device.commands.typedCall('BabylonDeriveContextHash', 'BabylonDerivedContextHash', this.params);
+            if (typeof message.secret !== 'string' || !/^[0-9a-f]{64}$/.test(message.secret)) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodError, 'Invalid Babylon context hash response');
+            }
+            return message;
+        });
+    }
+}
+
 class BTCSignMessage extends BaseMethod {
     getSupportedProtocols() {
         var _a;
@@ -65434,6 +65708,189 @@ 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 = validatePath(batch.path, 3);
+            if (addressN.length !== 3 ||
+                addressN[0] !== toHardened(32) ||
+                addressN[1] !== toHardened(133) ||
+                addressN[2] < toHardened(0) ||
+                addressN[2] > 0xffffffff) {
+                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);
+                responses.push({
+                    path,
+                    address: res.message.address,
+                    ufvk: res.message.ufvk,
+                    seedFingerprint: res.message.seed_fingerprint,
+                });
+                this.postPreviousAddressMessage({
+                    address: res.message.address,
+                    path,
+                });
+            }
+            validateResult(responses, ['address'], {
+                expectedLength: this.params.length,
+            });
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
+        });
+    }
+}
+
+const ZCASH_PCZT_MAX_BYTES = 24 * 1024;
+const CHUNK_BYTE_SIZE = 1024;
+class ZcashSignPczt extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.pczt = Buffer.alloc(0);
+        this.uploadPczt = (typedCall, res, offset) => __awaiter(this, void 0, void 0, function* () {
+            if (res.type === 'ZcashSignedPczt') {
+                if (offset !== this.pczt.length) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ResponseUnexpectTypeError, 'device completed signing before receiving the whole pczt');
+                }
+                return res;
+            }
+            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);
+            const next = yield typedCall('ZcashPcztChunkAck', ['ZcashSignedPczt', 'ZcashPcztChunkRequest'], {
+                data_chunk: utils.bytesToHex(chunk),
+            });
+            return this.uploadPczt(typedCall, next, offset + chunkLength);
+        });
+        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 > ZCASH_PCZT_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 === 0 || received + chunk.length > total) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ResponseUnexpectTypeError, `device returned ${chunk.length} 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 }]);
+        this.pczt = Buffer.from(formatAnyHex(this.payload.pczt), 'hex');
+        if (this.pczt.length === 0) {
+            throw invalidParameter('pczt is empty');
+        }
+        if (this.pczt.length > ZCASH_PCZT_MAX_BYTES) {
+            throw invalidParameter(`pczt exceeds ${ZCASH_PCZT_MAX_BYTES} bytes (${this.pczt.length})`);
+        }
+        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) };
+        });
+    }
+}
+
 var ApiMethods = /*#__PURE__*/Object.freeze({
     __proto__: null,
     testInitializeDeviceDuration: TestInitializeDeviceDuration,
@@ -65490,6 +65947,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     allNetworkGetAddressByLoop: AllNetworkGetAddressByLoop,
     btcGetAddress: BTCGetAddress,
     btcGetPublicKey: BTCGetPublicKey,
+    btcDeriveContextHash: BTCDeriveContextHash,
     btcSignMessage: BTCSignMessage,
     btcSignPsbt: BTCSignPsbt,
     btcSignTransaction: BTCSignTransaction,
@@ -65576,7 +66034,9 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     benfenSignMessage: BenfenSignMessage,
     benfenSignTransaction: BenfenSignTransaction,
     neoGetAddress: NeoGetAddress,
-    neoSignTransaction: NeoSignTransaction
+    neoSignTransaction: NeoSignTransaction,
+    zcashGetAddress: ZcashGetAddress,
+    zcashSignPczt: ZcashSignPczt
 });
 
 const publicMethodRegistry = ApiMethods;
@@ -66683,9 +67143,6 @@ function isMissingDetectedProtocolV2Error(method, error) {
         typeof typedError.message === 'string' &&
         typedError.message.includes('Device protocol has not been detected'));
 }
-function isTerminalBleStaleBondError(error) {
-    return hdShared.isBleStaleBondHardwareError(error);
-}
 function isDeviceIdentityMismatchError(error) {
     return ((error === null || error === void 0 ? void 0 : error.errorCode) === hdShared.HardwareErrorCode.DeviceCheckDeviceIdError);
 }
@@ -66850,6 +67307,7 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                     hdShared.HardwareErrorCode.BridgeNotInstalled,
                     hdShared.HardwareErrorCode.BridgeTimeoutError,
                     hdShared.HardwareErrorCode.BridgeNeedsPermission,
+                    hdShared.HardwareErrorCode.WebUsbDeviceAccessError,
                 ].includes(error.errorCode)) {
                     _deviceList = undefined;
                     reject(error);
@@ -66924,12 +67382,12 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                     hdShared.HardwareErrorCode.DeviceDetectInBootloaderMode,
                     hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
                     hdShared.HardwareErrorCode.BridgeNeedsPermission,
+                    hdShared.HardwareErrorCode.WebUsbDeviceAccessError,
                     hdShared.HardwareErrorCode.DeviceInterruptedFromUser,
                     hdShared.HardwareErrorCode.CallQueueActionCancelled,
                 ].includes(error.errorCode) ||
                     (env === 'react-native' &&
                         [hdShared.HardwareErrorCode.BleDeviceDisconnected, hdShared.HardwareErrorCode.PollingTimeout].includes(error.errorCode)) ||
-                    isTerminalBleStaleBondError(error) ||
                     isDeviceIdentityMismatchError(error)) {
                     reject(error);
                     return;
@@ -67089,7 +67547,7 @@ const onDeviceConnectHandler = (device) => {
 };
 const onDeviceDisconnectHandler = (device) => {
     device.clearPreInitialized();
-    const deviceObject = device.toMessageObject();
+    const deviceObject = device.toDisconnectMessageObject();
     if (!deviceObject)
         return;
     postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject }));