@onekeyfe/hd-core 1.2.3-alpha.1 → 1.2.3-alpha.11

package/dist/index.js

@@ -291,7 +291,6 @@ const writeFirmwareByteSource = ({ source, chunkSize, write, }) => __awaiter(voi
 const OpenWalletSessionMode = {
     Standard: 'standard',
     SelectHidden: 'select-hidden',
-    ResumeHidden: 'resume-hidden',
 };
 
 exports.EOneKeyDeviceMode = void 0;
@@ -38564,6 +38563,7 @@ var nested = {
 			MessageType_DeviceFindMyTokenState: 60450,
 			MessageType_DeviceFindMyTokenUpdate: 60451,
 			MessageType_DeviceFindMyTokenStateGet: 60452,
+			MessageType_DeviceAnimationControl: 60461,
 			MessageType_DeviceInfoGet: 60600,
 			MessageType_DeviceInfo: 60601,
 			MessageType_DeviceStatusGet: 60602,
@@ -38902,6 +38902,26 @@ var nested = {
 			}
 		}
 	},
+	DeviceAnimationAction: {
+		values: {
+			AnimationAction_Unknown: 0,
+			AnimationAction_Start: 1,
+			AnimationAction_Stop: 2
+		}
+	},
+	DeviceAnimationControl: {
+		fields: {
+			action: {
+				rule: "required",
+				type: "DeviceAnimationAction",
+				id: 1
+			},
+			timeout_ms: {
+				type: "uint32",
+				id: 2
+			}
+		}
+	},
 	DeviceFactoryAck: {
 		values: {
 			FACTORY_ACK_SUCCESS: 0,
@@ -41858,6 +41878,7 @@ function getProtocolV2WalletSession(device, options) {
             ? device.getInternalState()
             : undefined;
         let response;
+        let walletSelectionRequested = false;
         let resumed = false;
         let walletStatusRefreshed = false;
         const markWalletStatusRefreshed = () => {
@@ -42029,6 +42050,7 @@ function getProtocolV2WalletSession(device, options) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.WalletSessionInvalid);
             }
             yield lockAttachPinBeforePassphraseSelection();
+            walletSelectionRequested = true;
             response = yield selectDeviceSession(device, expectedPassphraseState, options === null || options === void 0 ? void 0 : options.deriveCardano, markWalletStatusRefreshed);
         }
         let { message } = response;
@@ -42051,6 +42073,10 @@ function getProtocolV2WalletSession(device, options) {
                 device.clearInternalState();
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.WalletSessionInvalid);
             }
+            if (walletSelectionRequested) {
+                clearCurrentWalletSession();
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckPassphraseStateError);
+            }
             if (options === null || options === void 0 ? void 0 : options.onlyMainPin) {
                 (_j = device.clearStandardInternalState) === null || _j === void 0 ? void 0 : _j.call(device);
                 yield selectStandardWallet(true);
@@ -43679,6 +43705,18 @@ class TransportManager {
         this.defaultMessages = DataManager.getProtobufMessages();
         this.currentMessages = this.defaultMessages;
         this.protocolV1MessageSchema = 'v1CurrentSchema';
+        this.webUsbInit = false;
+    }
+    static ensureInitialized() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const env = DataManager.getSettings('env');
+            if (env !== 'webusb' && env !== 'desktop-webusb')
+                return;
+            if (this.webUsbInit)
+                return;
+            yield this.transport.init(WebUsbLogger, DevicePool.emitter);
+            this.webUsbInit = true;
+        });
     }
     static configure() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -43707,7 +43745,7 @@ class TransportManager {
                     yield this.transport.init(WebBleLogger, DevicePool.emitter);
                 }
                 else if (env === 'webusb' || env === 'desktop-webusb') {
-                    yield this.transport.init(WebUsbLogger, DevicePool.emitter);
+                    yield this.ensureInitialized();
                 }
                 else {
                     yield this.transport.init(HttpLogger);
@@ -43790,6 +43828,7 @@ class TransportManager {
     }
 }
 TransportManager.reactNativeInit = false;
+TransportManager.webUsbInit = false;
 TransportManager.protocolV1MessageSchema = 'v1CurrentSchema';
 TransportManager.plugin = null;
 
@@ -46324,6 +46363,10 @@ class Device extends events.exports {
         }
         this.invalidateProtocolV2RuntimeState();
     }
+    waitForRunCleanup() {
+        var _a;
+        return (_a = this.runCleanupPromise) !== null && _a !== void 0 ? _a : Promise.resolve();
+    }
     run(fn, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.runPromise) {
@@ -46441,44 +46484,68 @@ class Device extends events.exports {
         });
     }
     interruptionFromUser() {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser);
-            this.interruptedAttempt = this.connectionAttempt;
-            const cleanupPromise = this.runCleanupPromise;
-            const { cancelableAction } = this;
-            if (cancelableAction) {
-                yield cancelableAction(error);
-            }
-            else if (this.shouldSendFallbackProtocolCancel()) {
-                yield ((_b = (_a = this.commands) === null || _a === void 0 ? void 0 : _a.cancelDevice) === null || _b === void 0 ? void 0 : _b.call(_a).catch(cancelError => {
-                    Log$h.debug('Protocol V2 fallback cancel error', cancelError);
-                }));
+        var _a;
+        const attempt = this.connectionAttempt;
+        if (((_a = this.userInterruption) === null || _a === void 0 ? void 0 : _a.attempt) === attempt) {
+            return this.userInterruption.promise;
+        }
+        const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser);
+        this.interruptedAttempt = attempt;
+        const cleanupPromise = this.runCleanupPromise;
+        const { cancelableAction, commands, runPromise, deviceConnector, mainId } = this;
+        const sendFallbackCancel = this.shouldSendFallbackProtocolCancel();
+        const acquired = this.hasDeviceAcquire();
+        const promise = (() => __awaiter(this, void 0, void 0, function* () {
+            var _b;
+            try {
+                if (cancelableAction) {
+                    yield cancelableAction(error);
+                }
+                else if (sendFallbackCancel) {
+                    yield ((_b = commands === null || commands === void 0 ? void 0 : commands.cancelDevice) === null || _b === void 0 ? void 0 : _b.call(commands).catch(cancelError => {
+                        Log$h.debug('Protocol V2 fallback cancel error', cancelError);
+                    }));
+                }
+                else if (!acquired) {
+                    if (mainId && (deviceConnector === null || deviceConnector === void 0 ? void 0 : deviceConnector.disconnect)) {
+                        Log$h.debug('interruptionFromUser: disconnecting device without acquire, mainId:', mainId);
+                        yield deviceConnector.disconnect(mainId);
+                    }
+                    if (this.connectionAttempt === attempt)
+                        this.markTransportDisconnected();
+                }
+                yield (commands === null || commands === void 0 ? void 0 : commands.cancel());
             }
-            else if (!this.hasDeviceAcquire()) {
-                if (this.mainId && ((_c = this.deviceConnector) === null || _c === void 0 ? void 0 : _c.disconnect)) {
-                    yield this.deviceConnector.disconnect(this.mainId).catch(disconnectError => {
-                        Log$h.debug('Ignored disconnect during user cancel without acquire', disconnectError);
+            catch (cleanupError) {
+                Log$h.warn('User cancellation cleanup failed; disconnecting device', cleanupError);
+                if (mainId && (deviceConnector === null || deviceConnector === void 0 ? void 0 : deviceConnector.disconnect)) {
+                    yield deviceConnector.disconnect(mainId).catch(disconnectError => {
+                        Log$h.debug('User cancellation fallback disconnect failed', disconnectError);
                     });
                 }
-                this.markTransportDisconnected();
+                if (this.connectionAttempt === attempt)
+                    this.markTransportDisconnected();
             }
-            yield ((_d = this.commands) === null || _d === void 0 ? void 0 : _d.cancel());
-            if (this.runPromise) {
-                this.runPromise.reject(error);
-                this.runPromise = null;
+            finally {
+                runPromise === null || runPromise === void 0 ? void 0 : runPromise.reject(error);
+                if (this.runPromise === runPromise)
+                    this.runPromise = null;
+                yield (cleanupPromise === null || cleanupPromise === void 0 ? void 0 : cleanupPromise.catch(() => undefined));
             }
-            yield (cleanupPromise === null || cleanupPromise === void 0 ? void 0 : cleanupPromise.catch(() => undefined));
-        });
+        }))();
+        this.userInterruption = { attempt, promise };
+        return promise;
     }
     setCancelableAction(callback) {
-        this.cancelableAction = (e) => callback(e)
+        const action = (e) => callback(e)
             .catch(e2 => {
             Log$h.debug('cancelableAction error', e2);
         })
             .finally(() => {
-            this.clearCancelableAction();
+            if (this.cancelableAction === action)
+                this.clearCancelableAction();
         });
+        this.cancelableAction = action;
     }
     clearCancelableAction() {
         this.cancelableAction = undefined;
@@ -47210,6 +47277,48 @@ class PreInitialize extends BaseMethod {
 }
 
 const Log$e = getLogger(exports.LoggerNames.DevicePool);
+const getDescriptorKeys = (descriptor) => [descriptor.path, descriptor.id].filter((key) => typeof key === 'string' && key.length > 0);
+const isOwnedByActiveWebUsbRequest = (descriptor, requestQueue) => {
+    if (!requestQueue)
+        return false;
+    return getDescriptorKeys(descriptor).some(key => requestQueue.getRequestTasksIdByConnectId(key).length > 0);
+};
+const getUsbHandle = (descriptor) => descriptor === null || descriptor === void 0 ? void 0 : descriptor.device;
+const getOwningRequestDevice = (descriptor, requestQueue) => {
+    var _a, _b;
+    if (!requestQueue)
+        return undefined;
+    const usbHandle = getUsbHandle(descriptor);
+    if (usbHandle === undefined)
+        return undefined;
+    for (const key of getDescriptorKeys(descriptor)) {
+        for (const requestId of requestQueue.getRequestTasksIdByConnectId(key)) {
+            const device = (_a = requestQueue.getTask(requestId)) === null || _a === void 0 ? void 0 : _a.method.device;
+            if ((device === null || device === void 0 ? void 0 : device.features) &&
+                (device.mainId === key || ((_b = device.originalDescriptor) === null || _b === void 0 ? void 0 : _b.path) === key) &&
+                getUsbHandle(device.originalDescriptor) === usbHandle) {
+                return device;
+            }
+        }
+    }
+    return undefined;
+};
+const toSearchDeviceFromDescriptor = (descriptor) => {
+    const connectId = descriptor.path || descriptor.id || null;
+    return {
+        connectId,
+        uuid: '',
+        serialNo: null,
+        deviceId: null,
+        deviceType: hdShared.EDeviceType.Unknown,
+        name: descriptor.name || connectId || '',
+        commType: descriptor.commType,
+    };
+};
+const toSearchDevice = (device) => {
+    const message = device.toMessageObject();
+    return message ? message : null;
+};
 class SearchDevices extends BaseMethod {
     init() {
         this.useDevice = false;
@@ -47217,20 +47326,32 @@ class SearchDevices extends BaseMethod {
         this.skipForceUpdateCheck = true;
     }
     run() {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g;
         return __awaiter(this, void 0, void 0, function* () {
-            yield TransportManager.configure();
-            const deviceDiff = yield ((_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate());
-            const devicesDescriptor = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
             const env = DataManager.getSettings('env');
+            const isWebUsb = env === 'webusb' || env === 'desktop-webusb';
+            const requestQueue = (_a = this.context) === null || _a === void 0 ? void 0 : _a.requestQueue;
+            const hasActiveWebUsbRequest = isWebUsb && ((_b = requestQueue === null || requestQueue === void 0 ? void 0 : requestQueue.getRequestTasksId().length) !== null && _b !== void 0 ? _b : 0) > 0;
+            if (isWebUsb) {
+                try {
+                    yield TransportManager.ensureInitialized();
+                }
+                catch (error) {
+                    Log$e.debug('WebUSB bring-up unavailable', error);
+                }
+            }
+            if (!hasActiveWebUsbRequest)
+                yield TransportManager.configure();
+            const deviceDiff = yield ((_c = this.connector) === null || _c === void 0 ? void 0 : _c.enumerate());
+            const devicesDescriptor = (_d = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _d !== void 0 ? _d : [];
             if (DataManager.isBleConnect(env)) {
                 const devices = [];
                 const seenIds = new Set();
                 for (const device of devicesDescriptor) {
-                    const lowerId = (_c = device.id) === null || _c === void 0 ? void 0 : _c.toLowerCase();
+                    const lowerId = (_e = device.id) === null || _e === void 0 ? void 0 : _e.toLowerCase();
                     if (!seenIds.has(lowerId)) {
                         seenIds.add(lowerId);
-                        const rawBleName = (_e = (_d = device.name) !== null && _d !== void 0 ? _d : device.localName) !== null && _e !== void 0 ? _e : '';
+                        const rawBleName = (_g = (_f = device.name) !== null && _f !== void 0 ? _f : device.localName) !== null && _g !== void 0 ? _g : '';
                         const bleName = hdShared.canonicalizePro2BleAdvertisementName(rawBleName);
                         devices.push(Object.assign(Object.assign({}, device), { connectId: device.id, serialNo: null, uuid: '', deviceId: null, name: bleName || device.name, deviceType: getDeviceTypeByBleName(bleName) }));
                     }
@@ -47239,22 +47360,34 @@ class SearchDevices extends BaseMethod {
             }
             const deviceList = [];
             for (const descriptor of devicesDescriptor) {
-                try {
-                    const result = yield DevicePool.getDevices([descriptor], descriptor.path, {
-                        connectProtocol: undefined,
-                        forceProtocolDetection: true,
-                        refreshRuntimeState: true,
-                    });
-                    deviceList.push(...result.deviceList);
+                if (hasActiveWebUsbRequest && isOwnedByActiveWebUsbRequest(descriptor, requestQueue)) {
+                    const cached = DevicePool.getDeviceByPath(descriptor.path);
+                    const known = (cached === null || cached === void 0 ? void 0 : cached.features) ? cached : getOwningRequestDevice(descriptor, requestQueue);
+                    const message = known ? toSearchDevice(known) : null;
+                    deviceList.push(message !== null && message !== void 0 ? message : toSearchDeviceFromDescriptor(descriptor));
                 }
-                catch (error) {
-                    const errorCode = error && typeof error === 'object' && 'errorCode' in error
-                        ? error.errorCode
-                        : undefined;
-                    Log$e.debug('Skip unavailable device during search', Object.assign({ path: descriptor.path }, (errorCode !== undefined ? { errorCode } : {})));
+                else {
+                    try {
+                        const result = yield DevicePool.getDevices([descriptor], descriptor.path, {
+                            connectProtocol: undefined,
+                            forceProtocolDetection: true,
+                            refreshRuntimeState: true,
+                        });
+                        for (const device of result.deviceList) {
+                            const message = toSearchDevice(device);
+                            if (message)
+                                deviceList.push(message);
+                        }
+                    }
+                    catch (error) {
+                        const errorCode = error && typeof error === 'object' && 'errorCode' in error
+                            ? error.errorCode
+                            : undefined;
+                        Log$e.debug('Skip unavailable device during search', Object.assign({ path: descriptor.path }, (errorCode !== undefined ? { errorCode } : {})));
+                    }
                 }
             }
-            return deviceList.map(device => device.toMessageObject());
+            return deviceList;
         });
     }
 }
@@ -47588,15 +47721,6 @@ function validateResult(result, nonNullableFields, options) {
     }
 }
 
-const requiredString = (value, name) => {
-    if (value === undefined || value === null) {
-        throw invalidParameter(`Missing required parameter: ${name}`);
-    }
-    if (typeof value !== 'string' || !value.trim()) {
-        throw invalidParameter(`Parameter [${name}] must be a non-empty string.`);
-    }
-    return value.trim();
-};
 const wasResumed = (session) => !!session &&
     typeof session === 'object' &&
     'resumed' in session &&
@@ -47618,25 +47742,16 @@ const normalizeParams = (payload) => {
         throw invalidParameter('Parameter [mode] is required.');
     }
     if (payload.mode !== OpenWalletSessionMode.Standard &&
-        payload.mode !== OpenWalletSessionMode.SelectHidden &&
-        payload.mode !== OpenWalletSessionMode.ResumeHidden) {
-        throw invalidParameter('Parameter [mode] must be one of standard, select-hidden, or resume-hidden.');
+        payload.mode !== OpenWalletSessionMode.SelectHidden) {
+        throw invalidParameter('Parameter [mode] must be one of standard or select-hidden.');
     }
     if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
         throw invalidParameter('Legacy parameters [useEmptyPassphrase] and [initSession] are not supported by openWalletSession.');
     }
-    if (payload.mode === OpenWalletSessionMode.Standard ||
-        payload.mode === OpenWalletSessionMode.SelectHidden) {
-        if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
-            throw invalidParameter('Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].');
-        }
-        return { mode: payload.mode };
+    if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
+        throw invalidParameter('Parameters [deviceId] and [passphraseState] are not supported by openWalletSession. Pass passphraseState on later address and signing calls.');
     }
-    return {
-        mode: OpenWalletSessionMode.ResumeHidden,
-        deviceId: requiredString(payload.deviceId, 'deviceId'),
-        passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
-    };
+    return { mode: payload.mode };
 };
 class OpenWalletSession extends BaseMethod {
     getSupportedProtocols() {
@@ -47739,43 +47854,6 @@ class OpenWalletSession extends BaseMethod {
                     resumed: wasResumed(session),
                 };
             }
-            if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
-                if (isProtocolV2) {
-                    yield ensureProtocolV2WalletStatus();
-                    const refreshedDeviceId = requireDeviceId();
-                    if (refreshedDeviceId !== this.params.deviceId) {
-                        deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError);
-                    }
-                }
-                else if (requireDeviceId() !== this.params.deviceId) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError);
-                }
-                this.device.passphraseState = this.params.passphraseState;
-                const cachedSessionId = deviceWalletSessionStore.get(this.params.deviceId, this.params.passphraseState);
-                if (!cachedSessionId && !isProtocolV2) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.WalletSessionInvalid);
-                }
-                if (!isProtocolV2) {
-                    yield this.device.initialize({
-                        deviceId: this.params.deviceId,
-                        passphraseState: this.params.passphraseState,
-                    });
-                }
-                const session = isProtocolV2
-                    ? yield getProtocolV2WalletSession(this.device, {
-                        expectedPassphraseState: this.params.passphraseState,
-                    })
-                    : yield getPassphraseStateWithRefreshDeviceInfo(this.device, {
-                        expectPassphraseState: this.params.passphraseState,
-                    });
-                const deviceId = requireDeviceId();
-                if (session.passphraseState !== this.params.passphraseState) {
-                    this.device.clearInternalState();
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckPassphraseStateError);
-                }
-                return Object.assign(Object.assign({ protocol, walletType: 'hidden', deviceId }, requireHiddenWalletResponse(session)), { resumed: wasResumed(session) || (!isProtocolV2 && session.newSession === cachedSessionId) });
-            }
             this.device.passphraseState = undefined;
             const walletStatus = yield ensureProtocolV2WalletStatus();
             if (isProtocolV2 && walletStatus.status.passphraseProtection !== true) {
@@ -49186,6 +49264,14 @@ class DeviceVerify extends BaseMethod {
         this.unlockPolicy = 'unlock-before-run';
         this.protocolV2PreUnlockPinType = hdTransport.DeviceSessionPinType.Any;
         this.useDevicePassphraseState = false;
+        this.protocolV2UiInteraction = {
+            request: 'button',
+            source: 'method-lifecycle',
+            reason: 'device-management',
+            completion: 'operation-completed',
+            deviceOnly: true,
+            operation: 'deviceVerify',
+        };
         validateParams(this.payload, [{ name: 'dataHex', type: 'hexString' }]);
         this.params = {
             data: formatAnyHex(this.payload.dataHex),
@@ -55908,6 +55994,8 @@ class AllNetworkGetAddressBase extends BaseMethod {
     constructor() {
         super(...arguments);
         this.abortController = null;
+        this.loadingCleanupInBackground = false;
+        this.protocolV2ResumedSeedDomains = new Set();
     }
     getSupportedProtocols() {
         return ['V1', 'V2'];
@@ -55943,7 +56031,20 @@ class AllNetworkGetAddressBase extends BaseMethod {
             _originalIndex: originalIndex,
         };
     }
-    callMethod(methodName, params, rootFingerprint) {
+    hasProtocolV2WalletResume(deriveCardano) {
+        if (deriveCardano) {
+            return this.protocolV2ResumedSeedDomains.has('cardano');
+        }
+        return (this.protocolV2ResumedSeedDomains.has('standard') ||
+            this.protocolV2ResumedSeedDomains.has('cardano'));
+    }
+    markProtocolV2WalletResumed(deriveCardano) {
+        this.protocolV2ResumedSeedDomains.add('standard');
+        if (deriveCardano) {
+            this.protocolV2ResumedSeedDomains.add('cardano');
+        }
+    }
+    callMethod(methodName, params, rootFingerprint, postMessage = this.postMessage) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const method = findMethod({
@@ -55952,7 +56053,7 @@ class AllNetworkGetAddressBase extends BaseMethod {
                 payload: Object.assign({ connectId: this.payload.connectId, deviceId: this.payload.deviceId, method: methodName }, params),
             });
             method.connector = this.connector;
-            method.postMessage = this.postMessage;
+            method.postMessage = postMessage;
             if (this.context) {
                 (_a = method.setContext) === null || _a === void 0 ? void 0 : _a.call(method, this.context);
             }
@@ -56005,11 +56106,14 @@ class AllNetworkGetAddressBase extends BaseMethod {
                         const useEmptyPassphrase = this.payload.useEmptyPassphrase === true;
                         const deriveCardano = method.name.startsWith('cardano') ? true : undefined;
                         const shouldResumeWalletSession = useEmptyPassphrase || !!this.payload.passphraseState;
-                        if (this.device.isProtocolV2() && shouldResumeWalletSession) {
+                        if (this.device.isProtocolV2() &&
+                            shouldResumeWalletSession &&
+                            !this.hasProtocolV2WalletResume(deriveCardano)) {
                             const passphraseStateSafety = yield this.device.checkPassphraseStateSafety(this.payload.passphraseState, useEmptyPassphrase, this.payload.skipPassphraseCheck, deriveCardano, (_d = this.protocolV2UnlockContext) === null || _d === void 0 ? void 0 : _d.preflightMainPinSelected);
                             if (!passphraseStateSafety) {
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckPassphraseStateError);
                             }
+                            this.markProtocolV2WalletResumed(deriveCardano);
                         }
                     }),
                 });
@@ -56045,27 +56149,63 @@ class AllNetworkGetAddressBase extends BaseMethod {
             return result;
         });
     }
-    run() {
+    stopAllNetworkLoading(canSend = true) {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('GetPublicKey', 'PublicKey', {
-                address_n: [toHardened(44), toHardened(1), toHardened(0)],
-                coin_name: 'Testnet',
-                script_type: 'SPENDADDRESS',
-                show_display: false,
-            });
-            if (!this.device.isProtocolV2()) {
-                this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+            const commands = this.loadingCommands;
+            this.loadingCommands = undefined;
+            if (!canSend || !commands || commands.disposed || commands !== this.device.commands)
+                return;
+            try {
+                yield commands.typedCall('DeviceAnimationControl', 'Success', {
+                    action: hdTransport.Messages.DeviceAnimationAction.AnimationAction_Stop,
+                });
             }
-            if (res.message.root_fingerprint == null) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter);
+            catch (_a) {
             }
-            this.abortController = new AbortController();
-            return this.getAllNetworkAddress(res.message.root_fingerprint).catch(e => {
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.loadingCleanupInBackground = false;
+            try {
+                if (this.device.isProtocolV2() &&
+                    (this.device.getCurrentDeviceType() === hdShared.EDeviceType.Pro2 ||
+                        this.device.getCurrentDeviceType() === hdShared.EDeviceType.Neo)) {
+                    const protocolInfo = yield this.device.ensureProtocolV2RuntimeContext();
+                    if (supportsProtocolV2Message(protocolInfo, 60461)) {
+                        const { commands } = this.device;
+                        yield commands.typedCall('DeviceAnimationControl', 'Success', {
+                            action: hdTransport.Messages.DeviceAnimationAction.AnimationAction_Start,
+                        });
+                        this.loadingCommands = commands;
+                    }
+                }
+                const res = yield this.device.commands.typedCall('GetPublicKey', 'PublicKey', {
+                    address_n: [toHardened(44), toHardened(1), toHardened(0)],
+                    coin_name: 'Testnet',
+                    script_type: 'SPENDADDRESS',
+                    show_display: false,
+                });
+                if (!this.device.isProtocolV2()) {
+                    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+                }
+                if (res.message.root_fingerprint == null) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter);
+                }
+                this.abortController = new AbortController();
+                return yield this.getAllNetworkAddress(res.message.root_fingerprint);
+            }
+            catch (e) {
+                yield this.stopAllNetworkLoading(false);
                 if (e instanceof hdShared.HardwareError && e.errorCode === hdShared.HardwareErrorCode.RepeatUnlocking) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RepeatUnlocking, e.message);
                 }
                 throw e;
-            });
+            }
+            finally {
+                if (!this.loadingCleanupInBackground)
+                    yield this.stopAllNetworkLoading();
+            }
         });
     }
 }
@@ -56126,57 +56266,83 @@ function handleSkippableHardwareError(e, device, method) {
 }
 
 class AllNetworkGetAddress extends AllNetworkGetAddressBase {
+    checkAborted() {
+        var _a;
+        if ((_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal.aborted) {
+            throw new Error(hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.RepeatUnlocking]);
+        }
+    }
+    callAddressGroup(methodName, params, rootFingerprint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const methodCallParams = { bundle: params.map(param => (Object.assign({}, param.params))) };
+            if (!this.device.isProtocolV2() || params.length === 1) {
+                return this.callMethod(methodName, methodCallParams, rootFingerprint);
+            }
+            const postedAddressCounts = new Map();
+            let runningIndividually = false;
+            const postMessage = message => {
+                var _a;
+                if (message.type === UI_REQUEST.PREVIOUS_ADDRESS_RESULT) {
+                    const { path, address } = message.payload.data;
+                    const key = JSON.stringify([path, address]);
+                    const count = (_a = postedAddressCounts.get(key)) !== null && _a !== void 0 ? _a : 0;
+                    if (runningIndividually && count > 0) {
+                        postedAddressCounts.set(key, count - 1);
+                        return;
+                    }
+                    if (!runningIndividually)
+                        postedAddressCounts.set(key, count + 1);
+                }
+                this.postMessage(message);
+            };
+            if (params.every(param => param._originRequestParams.showOnOneKey === false)) {
+                const response = yield this.callMethod(methodName, methodCallParams, rootFingerprint, postMessage);
+                if (response.some(item => item.success))
+                    return response;
+            }
+            runningIndividually = true;
+            const responses = [];
+            for (const param of params) {
+                this.checkAborted();
+                const response = yield this.callMethod(methodName, { bundle: [Object.assign({}, param.params)] }, rootFingerprint, postMessage);
+                responses.push(...response);
+            }
+            return responses;
+        });
+    }
     getAllNetworkAddress(rootFingerprint) {
-        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             const responses = [];
-            const resultMap = {};
             const { bundle } = this.payload;
             const methodParams = bundle.map((param, index) => this.generateMethodName({
                 network: param.network,
                 payload: param,
                 originalIndex: index,
             }));
-            const groupedMethodParams = methodParams.reduce((groups, param) => {
+            const methodGroups = methodParams.reduce((groups, param) => {
                 var _a;
                 const group = (_a = groups.get(param.methodName)) !== null && _a !== void 0 ? _a : [];
                 group.push(param);
                 groups.set(param.methodName, group);
                 return groups;
             }, new Map());
-            const requiresProtocolV2WalletHandoff = this.device.isProtocolV2() &&
-                (this.payload.useEmptyPassphrase === true || !!this.payload.passphraseState);
-            const methodGroups = requiresProtocolV2WalletHandoff
-                ? methodParams.map(param => [param.methodName, [param]])
-                : Array.from(groupedMethodParams.entries());
-            let i = 0;
-            for (const [methodName, params] of methodGroups) {
-                const methodParams = {
-                    bundle: params.map(param => (Object.assign({}, param.params))),
-                };
-                if ((_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal.aborted) {
-                    throw new Error(hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.RepeatUnlocking]);
-                }
-                const response = yield this.callMethod(methodName, methodParams, rootFingerprint);
-                if ((_b = this.abortController) === null || _b === void 0 ? void 0 : _b.signal.aborted) {
-                    throw new Error(hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.RepeatUnlocking]);
-                }
-                for (let i = 0; i < params.length; i++) {
-                    const { _originRequestParams, _originalIndex } = params[i];
-                    const responseKey = `${_originalIndex}`;
-                    resultMap[responseKey] = Object.assign(Object.assign({}, _originRequestParams), response[i]);
+            let processed = 0;
+            for (const [methodName, params] of methodGroups.entries()) {
+                this.checkAborted();
+                const response = yield this.callAddressGroup(methodName, params, rootFingerprint);
+                this.checkAborted();
+                for (let index = 0; index < params.length; index++) {
+                    const { _originRequestParams, _originalIndex } = params[index];
+                    responses[_originalIndex] = Object.assign(Object.assign({}, _originRequestParams), response[index]);
                 }
-                if (((_d = (_c = this.payload) === null || _c === void 0 ? void 0 : _c.bundle) === null || _d === void 0 ? void 0 : _d.length) > 1) {
-                    const progress = Math.round(((i + 1) / this.payload.bundle.length) * 100);
+                processed += params.length;
+                if (bundle.length > 1) {
+                    const progress = Math.round((processed / bundle.length) * 100);
                     this.postMessage(createUiMessage(UI_REQUEST.DEVICE_PROGRESS, { progress }));
                 }
-                i++;
-            }
-            for (let i = 0; i < bundle.length; i++) {
-                responses.push(resultMap[i]);
             }
             this.abortController = null;
-            return Promise.resolve(responses);
+            return responses;
         });
     }
 }
@@ -56192,6 +56358,7 @@ class AllNetworkGetAddressByLoop extends AllNetworkGetAddressBase {
                 throw new Error('callbackIdFinish is required');
             }
             const bundle = this.payload.bundle || [this.payload];
+            this.loadingCleanupInBackground = true;
             const callbackPromise = this.processCallbacksInBackground(bundle, rootFingerprint, callbackId, callbackIdFinish);
             this.device.pendingCallbackPromise = hdShared.createDeferred(callbackPromise);
             if (this.context && this.payload.connectId) {
@@ -56232,6 +56399,7 @@ class AllNetworkGetAddressByLoop extends AllNetworkGetAddressBase {
                 });
             }
             catch (error) {
+                yield this.stopAllNetworkLoading(false);
                 let errorCode = error.errorCode || error.code;
                 let errorMessage = error.message;
                 if (error instanceof hdShared.HardwareError) {
@@ -56259,6 +56427,7 @@ class AllNetworkGetAddressByLoop extends AllNetworkGetAddressBase {
                 });
             }
             finally {
+                yield this.stopAllNetworkLoading();
                 (_c = this.context) === null || _c === void 0 ? void 0 : _c.cancelCallbackTasks(this.payload.connectId);
                 this.abortController = null;
             }
@@ -65584,6 +65753,29 @@ class RequestQueue {
     getTask(requestId) {
         return this.requestQueue.get(requestId);
     }
+    waitForTask(task, pending) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signal = task.method.abortSignal;
+            const cancellationError = () => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                throw cancellationError();
+            let onAbort;
+            try {
+                const cancelled = new Promise((_, reject) => {
+                    onAbort = () => reject(cancellationError());
+                    signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
+                });
+                const result = yield Promise.race([pending(), cancelled]);
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                    throw cancellationError();
+                return result;
+            }
+            finally {
+                if (onAbort)
+                    signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+            }
+        });
+    }
     getAbortController(requestId) {
         var _a;
         return (_a = this.requestQueue.get(requestId)) === null || _a === void 0 ? void 0 : _a.abortController;
@@ -65783,7 +65975,8 @@ const createUiProgressMessageFilter = (intervalMs = DEFAULT_UI_PROGRESS_INTERVAL
 
 const Log = getLogger(exports.LoggerNames.Core);
 const PRE_INITIALIZE_TTL_MS = 60 * 1000;
-const PRE_PENDING_CALL_TIMEOUT_MS = 15 * 1000;
+const PRE_PENDING_CALL_TIMEOUT_MS = 5 * 1000;
+const PRO2_USB_SIGNING_COOLDOWN_MS = 1000;
 const preWarmInflight = new Map();
 const preWarmDoneAt = new Map();
 function resolveDeriveCardano(method) {
@@ -65862,6 +66055,7 @@ const callAPI = (context, message) => __awaiter(void 0, void 0, void 0, function
             }
         };
         (_a = method.setContext) === null || _a === void 0 ? void 0 : _a.call(method, context);
+        method.context = context;
         method.requestContext = createRequestContext(method.responseID, method.name, {
             sdkInstanceId: context.sdkInstanceId,
             connectId: method.connectId,
@@ -65879,7 +66073,11 @@ const callAPI = (context, message) => __awaiter(void 0, void 0, void 0, function
     if (!method.useDevice) {
         updateMethodRequestContext(method, { status: 'running' });
         try {
-            const response = yield method.run();
+            const env = DataManager.getSettings('env');
+            const response = method.name === 'searchDevices' &&
+                (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env))
+                ? yield context.methodSynchronize(() => method.run(), 'webusb-discovery')
+                : yield method.run();
             completeMethodRequestContext(method);
             return createResponseMessage(method.responseID, true, response);
         }
@@ -65951,6 +66149,7 @@ const waitForPendingPromise = (connectId, getPrePendingCallPromise, removePrePen
         Log.debug('pre pending call promise before call method, wait for it');
         let timer;
         let timedOut = false;
+        let completed = false;
         try {
             yield Promise.race([
                 pendingPromise,
@@ -65961,13 +66160,13 @@ const waitForPendingPromise = (connectId, getPrePendingCallPromise, removePrePen
                     }, PRE_PENDING_CALL_TIMEOUT_MS);
                 }),
             ]);
-        }
-        catch (error) {
+            completed = !timedOut;
         }
         finally {
             if (timer)
                 clearTimeout(timer);
-            removePrePendingCallPromise === null || removePrePendingCallPromise === void 0 ? void 0 : removePrePendingCallPromise(connectId, pendingPromise);
+            if (timedOut || completed)
+                removePrePendingCallPromise === null || removePrePendingCallPromise === void 0 ? void 0 : removePrePendingCallPromise(connectId, pendingPromise);
         }
         if (timedOut) {
             Log.warn('pre pending call promise timed out before call method', { connectId });
@@ -65975,8 +66174,19 @@ const waitForPendingPromise = (connectId, getPrePendingCallPromise, removePrePen
         Log.debug('pre pending call promise before call method done');
     }
 });
+function getPostCallPendingPromise(method, device) {
+    const cleanupPromise = device.waitForRunCleanup();
+    const env = DataManager.getSettings('env');
+    const deviceType = device.getCurrentDeviceType();
+    const requiresSigningCooldown = method.name.includes('Sign') &&
+        (deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo) &&
+        (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env) || env === 'node-usb');
+    return requiresSigningCooldown
+        ? cleanupPromise.then(() => wait(PRO2_USB_SIGNING_COOLDOWN_MS)).then(() => undefined)
+        : cleanupPromise;
+}
 const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, void 0, function* () {
-    var _d, _e, _f, _g, _h, _j, _k;
+    var _d, _e, _f, _g, _h, _j;
     let messageResponse;
     const { requestQueue, getPrePendingCallPromise, removePrePendingCallPromise } = context;
     updateMethodRequestContext(method, { status: 'running' });
@@ -65990,21 +66200,42 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
         Log.debug('passphrase state change, clear device cache');
         DevicePool.clearDeviceCache(method.payload.connectId);
     }
-    if (method.connectId) {
-        yield context.waitForCallbackTasks(method.connectId);
-    }
-    yield waitForPendingPromise((_d = method.connectId) !== null && _d !== void 0 ? _d : '', getPrePendingCallPromise, removePrePendingCallPromise);
     const task = requestQueue.createTask(method);
     let preWarmCallbackTask;
-    if (method.isPreWarmSignal && method.connectId) {
-        preWarmCallbackTask = hdShared.createDeferred();
-        context.registerCallbackTask(method.connectId, preWarmCallbackTask);
-    }
     let device;
     try {
-        const connectId = (_e = method.connectId) !== null && _e !== void 0 ? _e : '';
+        const connectId = (_d = method.connectId) !== null && _d !== void 0 ? _d : '';
+        if (connectId) {
+            yield requestQueue.waitForTask(task, () => context.waitForCallbackTasks(connectId));
+        }
+        yield requestQueue.waitForTask(task, () => {
+            var _a;
+            return waitForPendingPromise((_a = method.connectId) !== null && _a !== void 0 ? _a : '', getPrePendingCallPromise, removePrePendingCallPromise);
+        });
+        if (method.isPreWarmSignal && method.connectId) {
+            preWarmCallbackTask = hdShared.createDeferred();
+            context.registerCallbackTask(method.connectId, preWarmCallbackTask);
+        }
         const pollingId = pollingManager.start(connectId);
-        device = yield ensureConnected(context, method, connectId, pollingId, (_f = task.abortController) === null || _f === void 0 ? void 0 : _f.signal);
+        const env = DataManager.getSettings('env');
+        const connect = () => ensureConnected(context, method, connectId, pollingId, method.abortSignal);
+        if (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env)) {
+            const connectPromise = context.methodSynchronize(() => __awaiter(void 0, void 0, void 0, function* () {
+                var _k;
+                if ((_k = method.abortSignal) === null || _k === void 0 ? void 0 : _k.aborted) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
+                }
+                return connect();
+            }), 'webusb-discovery');
+            connectPromise.catch(() => undefined);
+            device = yield requestQueue.waitForTask(task, () => connectPromise);
+        }
+        else {
+            device = yield connect();
+        }
+        if ((_e = method.abortSignal) === null || _e === void 0 ? void 0 : _e.aborted) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
+        }
     }
     catch (e) {
         preWarmCallbackTask === null || preWarmCallbackTask === void 0 ? void 0 : preWarmCallbackTask.resolve();
@@ -66019,7 +66250,7 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
         requestQueue.releaseTask(method.responseID);
         return createResponseMessage(method.responseID, false, { error: e });
     }
-    if ((_g = method.payload) === null || _g === void 0 ? void 0 : _g.onlyConnectBleDevice) {
+    if ((_f = method.payload) === null || _f === void 0 ? void 0 : _f.onlyConnectBleDevice) {
         preWarmCallbackTask === null || preWarmCallbackTask === void 0 ? void 0 : preWarmCallbackTask.resolve();
         Log.debug('Call API - only connect ble device: ', device === null || device === void 0 ? void 0 : device.mainId);
         completeMethodRequestContext(method);
@@ -66027,11 +66258,11 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
         return createResponseMessage(method.responseID, true, null);
     }
     Log.debug('Call API - setDevice: ', device.mainId);
-    (_h = method.setDevice) === null || _h === void 0 ? void 0 : _h.call(method, device);
+    (_g = method.setDevice) === null || _g === void 0 ? void 0 : _g.call(method, device);
     method.context = context;
     updateMethodRequestContext(method, {
         deviceInstanceId: device.instanceId,
-        commandsInstanceId: (_j = device.commands) === null || _j === void 0 ? void 0 : _j.instanceId,
+        commandsInstanceId: (_h = device.commands) === null || _h === void 0 ? void 0 : _h.instanceId,
     });
     const activeRequests = getActiveRequestsByDeviceInstance(device.instanceId);
     if (activeRequests.length > 0) {
@@ -66057,10 +66288,14 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
     device.beginProtocolV2UiInteraction();
     device.on(DEVICE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE, onSelectDeviceForSwitchFirmwareWebDeviceHandler);
     try {
-        if (method.connectId) {
-            yield context.waitForCallbackTasks(method.connectId, preWarmCallbackTask);
+        const { connectId } = method;
+        if (connectId) {
+            yield requestQueue.waitForTask(task, () => context.waitForCallbackTasks(connectId, preWarmCallbackTask));
         }
-        yield waitForPendingPromise((_k = method.connectId) !== null && _k !== void 0 ? _k : '', getPrePendingCallPromise, removePrePendingCallPromise);
+        yield requestQueue.waitForTask(task, () => {
+            var _a;
+            return waitForPendingPromise((_a = method.connectId) !== null && _a !== void 0 ? _a : '', getPrePendingCallPromise, removePrePendingCallPromise);
+        });
         const inner = () => __awaiter(void 0, void 0, void 0, function* () {
             var _l, _m;
             method.assertProtocolSupported(device.getProtocol(), device.getCurrentFirmwareType());
@@ -66187,6 +66422,9 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
                     }),
                 });
                 messageResponse = createResponseMessage(method.responseID, true, response);
+                if (method.connectId) {
+                    context.setPrePendingCallPromise(method.connectId, getPostCallPendingPromise(method, device));
+                }
                 requestQueue.resolveRequest(method.responseID, messageResponse);
                 completeMethodRequestContext(method);
             }
@@ -66197,6 +66435,9 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
                 }
                 Log.debug(`Call API - Inner Method Run Error`, error);
                 messageResponse = createResponseMessage(method.responseID, false, { error });
+                if (method.connectId) {
+                    context.setPrePendingCallPromise(method.connectId, getPostCallPendingPromise(method, device));
+                }
                 requestQueue.resolveRequest(method.responseID, messageResponse);
                 completeMethodRequestContext(method, error);
                 if (error instanceof hdShared.HardwareError &&
@@ -66215,6 +66456,9 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
         });
         Log.debug('Call API - Device Run: ', device.mainId);
         const runOptions = Object.assign({ keepSession: method.payload.keepSession, skipInitialize: canSkipInitialize(method, device) }, parseInitOptions(method));
+        if ((_j = method.abortSignal) === null || _j === void 0 ? void 0 : _j.aborted) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
+        }
         const deviceRun = () => device.run(inner, runOptions);
         task.callPromise = hdShared.createDeferred(deviceRun);
         try {
@@ -66233,6 +66477,7 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
         requestQueue.rejectRequest(method.responseID, hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodError, error.message));
         Log.debug('Call API - Run Error: ', error);
         completeMethodRequestContext(method, error);
+        return messageResponse;
     }
     finally {
         preWarmCallbackTask === null || preWarmCallbackTask === void 0 ? void 0 : preWarmCallbackTask.resolve();
@@ -66437,7 +66682,7 @@ function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            if (device.wasInterruptedByUser()) {
+            if ((abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) || device.wasInterruptedByUser()) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser);
             }
             if (method.payload.forceProtocolDetection && device.hasDeviceAcquire()) {
@@ -66493,6 +66738,9 @@ function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
             }
         }
         catch (err) {
+            if ((abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) || device.wasInterruptedByUser()) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser);
+            }
             const requiresColdReconnect = isMissingDetectedProtocolV2Error(method, err);
             if ((hdShared.ERROR_CODES_REQUIRE_DISCONNECT.includes(err.errorCode) || requiresColdReconnect) &&
                 device.mainId &&
@@ -66525,6 +66773,7 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
     const POLL_INTERVAL_TIME = (method.payload && method.payload.pollIntervalTime) || 1000;
     const TIME_OUT = (method.payload && method.payload.timeout) || 10000;
     let timer = null;
+    let lastInitializeError;
     Log.debug(`EnsureConnected function start, MAX_RETRY_COUNT=${MAX_RETRY_COUNT}, POLL_INTERVAL_TIME=${POLL_INTERVAL_TIME}  `);
     const poll = (time = POLL_INTERVAL_TIME) => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
@@ -66557,8 +66806,10 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
             Log.debug('EnsureConnected function try count: ', tryCount, ' poll interval time: ', time);
             try {
                 yield initDeviceList(method);
+                lastInitializeError = undefined;
             }
             catch (error) {
+                lastInitializeError = error;
                 Log.debug('device list error: ', error);
                 if ([
                     hdShared.HardwareErrorCode.BridgeNotInstalled,
@@ -66571,6 +66822,7 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                 }
                 if (error.errorCode === hdShared.HardwareErrorCode.TransportNotConfigured) {
                     yield TransportManager.configure();
+                    lastInitializeError = undefined;
                 }
             }
             if (abort()) {
@@ -66629,6 +66881,7 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                     hdShared.HardwareErrorCode.BleDeviceBondedCanceled,
                     hdShared.HardwareErrorCode.BleCharacteristicNotifyError,
                     hdShared.HardwareErrorCode.BleTimeoutError,
+                    hdShared.HardwareErrorCode.PollingTimeout,
                     hdShared.HardwareErrorCode.BleWriteCharacteristicError,
                     hdShared.HardwareErrorCode.BleAlreadyConnected,
                     hdShared.HardwareErrorCode.FirmwareUpdateLimitOneDevice,
@@ -66639,6 +66892,8 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                     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);
@@ -66650,13 +66905,16 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                     clearTimeout(timer);
                 }
                 Log.debug('EnsureConnected get to max try count, will return: ', tryCount);
-                if (DataManager.isBrowserWebUsb(env) && !((_u = method.payload) === null || _u === void 0 ? void 0 : _u.skipWebDevicePrompt)) {
+                const preserveWebUsbInitError = DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env);
+                const needsPermissionPrompt = DataManager.isBrowserWebUsb(env) && !((_u = method.payload) === null || _u === void 0 ? void 0 : _u.skipWebDevicePrompt);
+                const fallbackError = needsPermissionPrompt
+                    ? hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission)
+                    : hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
+                const errorToReject = preserveWebUsbInitError && lastInitializeError ? lastInitializeError : fallbackError;
+                if (needsPermissionPrompt && errorToReject === fallbackError) {
                     postMessage(createUiMessage(UI_REQUEST.WEB_DEVICE_PROMPT_ACCESS_PERMISSION));
-                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission));
-                }
-                else {
-                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound));
                 }
+                reject(errorToReject);
                 return;
             }
             if (abort()) {
@@ -66935,7 +67193,14 @@ class Core extends events.exports {
                     this.prePendingCallPromises.delete(connectId);
                     return;
                 }
-                this.prePendingCallPromises.set(connectId, promise);
+                const previous = this.prePendingCallPromises.get(connectId);
+                const cleanupPromise = previous && previous !== promise
+                    ? Promise.all([previous, promise]).then(() => undefined)
+                    : promise;
+                this.prePendingCallPromises.set(connectId, cleanupPromise);
+                cleanupPromise.catch(error => {
+                    Log.warn('Device cancellation cleanup failed', { errorCode: error === null || error === void 0 ? void 0 : error.errorCode });
+                });
             },
             removePrePendingCallPromise: (connectId, promise) => {
                 if (this.prePendingCallPromises.get(connectId) === promise) {