@onekeyfe/hd-core 1.2.0-alpha.3 → 1.2.0-alpha.30

package/src/api/tron/TronSignMessage.ts

@@ -6,11 +6,16 @@ import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { stripHexPrefix } from '../helpers/hexUtils';
-import { getFirmwareType } from '../../utils';
 
 import type { TronSignMessage as HardwareTronSignMessage } from '@onekeyfe/hd-transport';
 
 export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage> {
+  private isLegacyMessageType = false;
+
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
@@ -26,12 +31,8 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
     const { path, messageHex } = this.payload;
     const addressN = validatePath(path, 3);
 
-    if (this.payload.messageType === 'V1' || this.payload.messageType == null) {
-      throw createDeviceNotSupportMethodError(
-        'TronSignMessage',
-        getFirmwareType(this.device?.features)
-      );
-    }
+    this.isLegacyMessageType =
+      this.payload.messageType === 'V1' || this.payload.messageType == null;
 
     const messageType = TronMessageType.V2;
 
@@ -56,6 +57,9 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
 
   getMessageV2VersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       pro: {
         min: '4.16.0',
       },
@@ -72,6 +76,13 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
   }
 
   async run() {
+    if (this.isLegacyMessageType) {
+      throw createDeviceNotSupportMethodError(
+        'TronSignMessage',
+        this.device.getCurrentFirmwareType()
+      );
+    }
+
     this.checkFeatureVersionLimit(
       () => this.params.message_type === TronMessageType.V2,
       () => this.getMessageV2VersionRange(),

package/src/api/tron/TronSignTransaction.ts

@@ -11,6 +11,10 @@ import type { TronSignTx } from '@onekeyfe/hd-transport';
 import type { DeviceFirmwareRange } from '../../types';
 
 export default class TronSignTransaction extends BaseMethod<TronSignTx> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   parseTx(tx: TronTransaction, address_n: number[]): TronSignTx {
     const unSignTx = {
       address_n,

package/src/api/utils.ts

@@ -2,16 +2,20 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import * as ApiMethods from './index';
 
+import type { BaseMethod } from './BaseMethod';
 import type { IFrameCallMessage } from '../events';
 
-export function findMethod(message: IFrameCallMessage & { id?: number }) {
+type MethodConstructor = new (message: IFrameCallMessage & { id?: number }) => BaseMethod<any>;
+
+const publicMethodRegistry = ApiMethods as unknown as Record<string, MethodConstructor>;
+
+export function findMethod(message: IFrameCallMessage & { id?: number }): BaseMethod<any> {
   const { method } = message.payload;
   if (typeof method !== 'string') {
     throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
   }
 
-  // @ts-expect-error
-  const MethodConstructor = ApiMethods[method];
+  const MethodConstructor = publicMethodRegistry[method];
   if (MethodConstructor) {
     return new MethodConstructor(message);
   }

package/src/api/xrp/XrpGetAddress.ts

@@ -11,6 +11,10 @@ export default class XrpGetAddress extends BaseMethod<
     show_display: boolean;
   }[]
 > {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   shouldConfirm = false;

package/src/api/xrp/XrpSignTransaction.ts

@@ -6,6 +6,10 @@ import { validatePath } from '../helpers/pathUtils';
 import type { XrpSignTransactionParams } from '../../types/api/xrpSignTransaction';
 
 export default class XrpGetAddress extends BaseMethod<XrpSignTransactionParams> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {
@@ -30,7 +34,7 @@ export default class XrpGetAddress extends BaseMethod<XrpSignTransactionParams>
       { name: 'payment', type: 'object' },
     ]);
     validateParams(transaction.payment, [
-      { name: 'amount', type: 'uint', required: true },
+      { name: 'amount', type: 'number', required: true },
       { name: 'destination', type: 'string', required: true },
       { name: 'destinationTag', type: 'number' },
     ]);

package/src/constants/index.ts

@@ -5,7 +5,4 @@ export {
   TonSignDataType,
   TonWalletVersion,
 } from '@onekeyfe/hd-transport';
-export type {
-  HDNodeType,
-  Success as DeviceSuccess,
-} from '@onekeyfe/hd-transport';
+export type { HDNodeType, Success as DeviceSuccess } from '@onekeyfe/hd-transport';

package/src/core/RequestQueue.ts

@@ -30,6 +30,7 @@ export default class RequestQueue {
       method.responseID = requestId;
     }
     const abortController = new AbortController();
+    method.abortSignal = abortController.signal;
     const task = { id: requestId, method, abortController };
     this.requestQueue.set(requestId, task);
     return task;

package/src/core/deviceEventRegistration.ts

@@ -0,0 +1,23 @@
+import { DEVICE } from '../events';
+
+import type { Device, DeviceEvents } from '../device/Device';
+
+export type HardwareUiEventHandlers = {
+  pin: (...event: DeviceEvents[typeof DEVICE.PIN]) => void;
+  button: (...event: DeviceEvents[typeof DEVICE.BUTTON]) => void;
+  passphrase: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE]) => void;
+  passphraseOnDevice: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE_ON_DEVICE]) => void;
+  attachPinOnDevice: (...event: DeviceEvents[typeof DEVICE.ATTACH_PIN_ON_DEVICE]) => void;
+};
+
+export function registerHardwareUiEventListeners(
+  device: Pick<Device, 'on'>,
+  handlers: HardwareUiEventHandlers
+) {
+  device.on(DEVICE.PIN, handlers.pin);
+  device.on(DEVICE.BUTTON, handlers.button);
+  device.on(DEVICE.PASSPHRASE, handlers.passphrase);
+  device.on(DEVICE.PASSPHRASE_ON_DEVICE, handlers.passphraseOnDevice);
+  device.on(DEVICE.ATTACH_PIN_ON_DEVICE, handlers.attachPinOnDevice);
+  return true;
+}

package/src/core/index.ts

@@ -1,5 +1,6 @@
 import semver from 'semver';
 import EventEmitter from 'events';
+import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 import {
   ERRORS,
   ERROR_CODES_REQUIRE_RELEASE,
@@ -14,14 +15,7 @@ import {
   createNewFirmwareUnReleaseHardwareError,
 } from '@onekeyfe/hd-shared';
 
-import {
-  LoggerNames,
-  enableLog,
-  getLogger,
-  isMethodVersionRangeUnsupported,
-  setLoggerPostMessage,
-  wait,
-} from '../utils';
+import { LoggerNames, enableLog, getLogger, setLoggerPostMessage, wait } from '../utils';
 import {
   findDefectiveBatchDevice,
   getDefectiveDeviceInfo,
@@ -36,6 +30,7 @@ import {
   updateRequestContext,
 } from '../utils/tracing';
 import { Device } from '../device/Device';
+import { checkLiveDeviceId } from '../device/deviceIdentity';
 import { DeviceList } from '../device/DeviceList';
 import { DevicePool } from '../device/DevicePool';
 import { PollingStateManager } from './PollingStateManager';
@@ -51,19 +46,29 @@ import {
   createDeviceMessage,
   createResponseMessage,
   createUiMessage,
+  getLogBlockLabel,
 } from '../events';
 import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
+import { registerHardwareUiEventListeners } from './deviceEventRegistration';
 import { getSynchronize } from '../utils/getSynchronize';
-import { setProtocolV2DeviceInfoMock } from '../protocols/protocol-v2/features';
+import { runMethodWithUnlockRetry } from '../protocols/protocol-v2/unlockRetry';
+import {
+  ProtocolV2UiInteractionCoordinator,
+  isProtocolV2UiEnabled,
+} from '../protocols/protocol-v2/uiInteraction';
 
 import type { ConnectSettings, Features, KnownDevice } from '../types';
 import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
 import type { DeviceEvents, InitOptions, RunOptions } from '../device/Device';
 import type { SdkTracingContext } from '../utils/tracing';
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type { LowlevelTransportSharedPlugin, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
+import type {
+  LowlevelTransportSharedPlugin,
+  OneKeyDeviceInfo,
+  TransportDeviceDisconnectEvent,
+} from '@onekeyfe/hd-transport';
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
@@ -92,13 +97,14 @@ function hasDeriveCardano(method: BaseMethod): boolean {
 
 const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   initSession: method?.payload.initSession,
-  passphraseState: method?.payload.passphraseState,
+  passphraseState: method?.payload.useEmptyPassphrase ? undefined : method?.payload.passphraseState,
   deviceId: method?.payload.deviceId,
   deriveCardano: method && hasDeriveCardano(method),
   connectProtocol: method?.payload.connectProtocol,
+  protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
 });
 
-let _core: Core;
+let _core: Core | undefined;
 let _deviceList: DeviceList | undefined;
 let _connector: DeviceConnector | undefined;
 let _uiPromises: UiPromise<UiPromiseResponse['type']>[] = []; // Waiting for ui response
@@ -142,7 +148,7 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   }
 
   // find api method
-  let method: BaseMethod;
+  let method!: BaseMethod;
   try {
     method = findMethod(message as IFrameCallMessage);
     method.connector = _connector;
@@ -158,11 +164,13 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
 
     method.init();
   } catch (error) {
-    return Promise.reject(error);
+    if (method) {
+      completeMethodRequestContext(method, error);
+      method.dispose();
+    }
+    return createResponseMessage(method?.responseID ?? message.id, false, { error });
   }
 
-  DevicePool.emitter.on(DEVICE.CONNECT, onDeviceConnectHandler);
-
   if (!method.useDevice) {
     updateMethodRequestContext(method, { status: 'running' });
     try {
@@ -223,9 +231,15 @@ const handlePreWarmSignal = async (
   message: CoreMessage,
   method: BaseMethod
 ): Promise<any> => {
+  const createAckResponse = () => {
+    completeMethodRequestContext(method);
+    method.dispose();
+    return createResponseMessage(method.responseID, true, true);
+  };
+
   // no connectId: can't target a device safely, skip pre-warm (ack only)
   if (!method.connectId) {
-    return createResponseMessage(method.responseID, true, true);
+    return createAckResponse();
   }
 
   const key = method.getPreWarmKey();
@@ -238,12 +252,12 @@ const handlePreWarmSignal = async (
     } catch {
       // pre-warm is best-effort; ignore its failure for the coalesced caller
     }
-    return createResponseMessage(method.responseID, true, true);
+    return createAckResponse();
   }
 
   const doneAt = preWarmDoneAt.get(key);
   if (typeof doneAt === 'number' && Date.now() - doneAt <= method.preWarmTtl) {
-    return createResponseMessage(method.responseID, true, true);
+    return createAckResponse();
   }
 
   const run = onCallDevice(context, message, method);
@@ -351,7 +365,7 @@ const onCallDevice = async (
     );
   } catch (e) {
     preWarmCallbackTask?.resolve();
-    console.log('ensureConnected error: ', e);
+    Log.debug('ensureConnected error: ', e);
 
     completeMethodRequestContext(method, e);
 
@@ -388,18 +402,23 @@ const onCallDevice = async (
     );
   }
 
-  device.on(DEVICE.PIN, onDevicePinHandler);
-  device.on(DEVICE.BUTTON, onDeviceButtonHandler);
-  device.on(
-    DEVICE.PASSPHRASE,
-    message.payload.useEmptyPassphrase ? onEmptyPassphraseHandler : onDevicePassphraseHandler
-  );
-  device.on(DEVICE.PASSPHRASE_ON_DEVICE, onEnterPassphraseOnDeviceHandler);
+  registerHardwareUiEventListeners(device, {
+    pin: onDevicePinHandler,
+    button: onDeviceButtonHandler,
+    passphrase: message.payload.useEmptyPassphrase
+      ? onEmptyPassphraseHandler
+      : onDevicePassphraseHandler,
+    passphraseOnDevice: onEnterPassphraseOnDeviceHandler,
+    attachPinOnDevice: onEnterAttachPinOnDeviceHandler,
+  });
   device.on(DEVICE.FEATURES, onDeviceFeaturesHandler);
+  device.on(DEVICE.STATE, onDeviceStateHandler);
   device.on(
     DEVICE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE,
     onSelectDeviceInBootloaderForWebDeviceHandler
   );
+
+  const protocolV2UiCoordinator = new ProtocolV2UiInteractionCoordinator(device, postMessage);
   device.on(
     DEVICE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE,
     onSelectDeviceForSwitchFirmwareWebDeviceHandler
@@ -414,11 +433,9 @@ const onCallDevice = async (
     await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
     const inner = async (): Promise<void> => {
-      // Protocol V2 专属方法统一守卫：协议在 acquire/initialize 后已确定，
-      // 非 V2 设备直接抛出明确的 NotSupport 错误（见 BaseMethod.requireProtocolV2）。
-      if (method.requireProtocolV2 && !device.isProtocolV2()) {
-        throw createDeviceNotSupportMethodError(method.name, device.getCurrentFirmwareType());
-      }
+      // Protocol is established from an active device response during acquire/initialize.
+      // Reject unsupported methods before any method-specific device command is sent.
+      method.assertProtocolSupported(device.getProtocol(), device.getCurrentFirmwareType());
 
       // check firmware version
       const versionRange = device.getCurrentMethodVersionRange(
@@ -429,8 +446,8 @@ const onCallDevice = async (
       const deviceFirmwareType = device.getCurrentFirmwareType();
       let newVersionStatus: ReturnType<typeof DataManager.getFirmwareStatus> | undefined;
 
-      // 故障批次检测与远端强制升级门禁基于 V1 features/remote config，
-      // Pro2(V2) 暂不参与：profile 版的 firmwareStatus 需要 DataManager 支持后再接入。
+      // Defective-batch and forced-update gates depend on V1 features/remote config.
+      // Pro2 joins after DataManager supports its profile firmwareStatus.
       if (device.features && !device.isProtocolV2()) {
         await DataManager.checkAndReloadData();
 
@@ -478,10 +495,6 @@ const onCallDevice = async (
         }
       }
 
-      if (isMethodVersionRangeUnsupported(versionRange)) {
-        throw createDeviceNotSupportMethodError(method.name, deviceFirmwareType);
-      }
-
       if (versionRange) {
         if (semver.valid(versionRange.min) && semver.lt(currentFirmwareVersion, versionRange.min)) {
           if (newVersionStatus === 'none' || newVersionStatus === 'valid') {
@@ -533,7 +546,7 @@ const onCallDevice = async (
       }
 
       if (method.deviceId && method.checkDeviceId) {
-        const isSameDeviceID = device.checkDeviceId(method.deviceId);
+        const isSameDeviceID = await checkLiveDeviceId(device, method.deviceId);
         if (!isSameDeviceID) {
           return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError));
         }
@@ -610,7 +623,11 @@ const onCallDevice = async (
       method.device?.commands?.checkDisposed();
 
       try {
-        const response: object = await method.run();
+        const response: object = await runMethodWithUnlockRetry(
+          method,
+          device,
+          protocolV2UiCoordinator
+        );
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
@@ -627,6 +644,8 @@ const onCallDevice = async (
         ) {
           throw error;
         }
+      } finally {
+        protocolV2UiCoordinator.close();
       }
     };
     Log.debug('Call API - Device Run: ', device.mainId);
@@ -680,7 +699,9 @@ const onCallDevice = async (
 
     requestQueue.releaseTask(method.responseID);
 
-    closePopup();
+    if (isProtocolV2UiEnabled(method)) {
+      closePopup();
+    }
 
     cleanup();
 
@@ -732,6 +753,15 @@ function initDevice(method: BaseMethod) {
 
   if (method.connectId) {
     device = _deviceList.getDevice(method.connectId);
+    if (!device && method.name === 'firmwareUpdateV4' && allDevices.length === 1) {
+      const [singleDevice] = allDevices;
+      if (singleDevice.isBootloader()) {
+        Log.debug(
+          'firmwareUpdateV4 uses the only bootloader device when connectId changed after reboot'
+        );
+        device = singleDevice;
+      }
+    }
   } else if (allDevices.length === 1) {
     [device] = allDevices;
   } else if (allDevices.length > 1) {
@@ -833,8 +863,15 @@ function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown)
  */
 async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
-    await device.acquire(method.payload.connectProtocol);
+    const shouldAcquire =
+      !device.hasDeviceAcquire() || !device.commands || device.commands.disposed;
+    if (shouldAcquire) {
+      await device.acquire(method.payload.connectProtocol);
+    }
     if (method.payload?.onlyConnectBleDevice) {
+      if (shouldAcquire) {
+        DevicePool.emitter.emit(DEVICE.CONNECT, device);
+      }
       return;
     }
     // Skip initialize if conditions are met
@@ -845,6 +882,9 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
         passphraseState: initOptions.passphraseState,
       });
     }
+    if (shouldAcquire) {
+      DevicePool.emitter.emit(DEVICE.CONNECT, device);
+    }
   } catch (err) {
     if (
       (err.errorCode === HardwareErrorCode.BleTimeoutError ||
@@ -1145,8 +1185,6 @@ const cleanup = () => {
 
 const removeDeviceListener = (device: Device) => {
   device.removeAllListeners();
-  DevicePool.emitter.removeAllListeners(DEVICE.CONNECT);
-  // DevicePool.emitter.removeListener(DEVICE.DISCONNECT, onDeviceDisconnectHandler);
 };
 
 /**
@@ -1157,16 +1195,30 @@ const closePopup = () => {
 };
 
 const onDeviceConnectHandler = (device: Device) => {
-  const env = DataManager.getSettings('env');
-  const deviceObject = DataManager.isBleConnect(env) ? device : device.toMessageObject();
-  postMessage(createDeviceMessage(DEVICE.CONNECT, { device: deviceObject as KnownDevice }));
+  const deviceObject = device.toMessageObject();
+  if (!deviceObject) return;
+  postMessage(createDeviceMessage(DEVICE.CONNECT, { device: deviceObject }));
 };
 
 const onDeviceDisconnectHandler = (device: Device) => {
   device.clearPreInitialized();
-  const env = DataManager.getSettings('env');
-  const deviceObject = DataManager.isBleConnect(env) ? device : device.toMessageObject();
-  postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject as KnownDevice }));
+  const deviceObject = device.toMessageObject();
+  if (!deviceObject) return;
+  postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject }));
+};
+
+const onTransportDeviceDisconnectHandler = (event: TransportDeviceDisconnectEvent) => {
+  const device =
+    deviceCacheMap.get(event.connectId) ??
+    DevicePool.devicesCache[event.connectId] ??
+    DevicePool.getDeviceByPath(event.connectId);
+  if (!device) {
+    Log.debug('Ignoring transport disconnect for an unknown device:', event.connectId);
+    return;
+  }
+
+  device.markTransportDisconnected();
+  DevicePool.emitter.emit(DEVICE.DISCONNECT, device);
 };
 
 const onDevicePinHandler = async (...[device, type, callback]: DeviceEvents['pin']) => {
@@ -1207,6 +1259,10 @@ const onDeviceFeaturesHandler = (...[_, features]: [...DeviceEvents['features']]
   postMessage(createDeviceMessage(DEVICE.FEATURES, { ...features }));
 };
 
+const onDeviceStateHandler = (...[_, stateEvent]: [...DeviceEvents['state']]) => {
+  postMessage(createDeviceMessage(DEVICE.STATE, stateEvent));
+};
+
 const onDevicePassphraseHandler = async (
   ...[device, requestPayload, callback]: DeviceEvents['passphrase']
 ) => {
@@ -1217,6 +1273,10 @@ const onDevicePassphraseHandler = async (
       device: device.toMessageObject() as KnownDevice,
       passphraseState: device.passphraseState,
       existsAttachPinUser: requestPayload.existsAttachPinUser,
+      deviceOnly: requestPayload.deviceOnly,
+      source: requestPayload.source,
+      reason: requestPayload.reason,
+      expectedPassphraseState: requestPayload.expectedPassphraseState,
     })
   );
   // wait for passphrase
@@ -1238,12 +1298,27 @@ const onEmptyPassphraseHandler = (...[_, , callback]: DeviceEvents['passphrase']
 };
 
 const onEnterPassphraseOnDeviceHandler = (
-  ...[device]: [...DeviceEvents['passphrase_on_device']]
+  ...[device, requestPayload]: [...DeviceEvents['passphrase_on_device']]
 ) => {
   postMessage(
     createUiMessage(UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE, {
       device: device.toMessageObject() as KnownDevice,
       passphraseState: device.passphraseState,
+      source: requestPayload?.source,
+      reason: requestPayload?.reason,
+    })
+  );
+};
+
+const onEnterAttachPinOnDeviceHandler = (
+  ...[device, requestPayload]: [...DeviceEvents['attach_pin_on_device']]
+) => {
+  postMessage(
+    createUiMessage(UI_REQUEST.REQUEST_PIN, {
+      device: device.toMessageObject() as KnownDevice,
+      type: 'ButtonRequest_AttachPin',
+      source: requestPayload?.source,
+      reason: requestPayload?.reason,
     })
   );
 };
@@ -1314,6 +1389,8 @@ export default class Core extends EventEmitter {
 
   private requestQueue = new RequestQueue();
 
+  private disposePromise?: Promise<void>;
+
   // background task
   private prePendingCallPromise: Promise<void> | undefined;
 
@@ -1372,10 +1449,17 @@ export default class Core extends EventEmitter {
       }
 
       case IFRAME.CALL: {
-        Log.log(`[${Date.now()}][CALL_API]`, message);
+        const logBlockLabel = getLogBlockLabel(message);
+        Log.log(
+          `[${Date.now()}][CALL_API]`,
+          logBlockLabel ? { method: logBlockLabel, payload: '[REDACTED]' } : message
+        );
         const response = await callAPI(this.getCoreContext(), message);
         const { success, payload } = response;
-        Log.log(`[${Date.now()}][CALL_API_RESPONSE]`, response);
+        Log.log(
+          `[${Date.now()}][CALL_API_RESPONSE]`,
+          logBlockLabel ? { method: logBlockLabel, payload: '[REDACTED]' } : response
+        );
         if (success) {
           return response;
         }
@@ -1405,25 +1489,65 @@ export default class Core extends EventEmitter {
     return Promise.resolve(message);
   }
 
-  dispose() {
+  dispose(): Promise<void> {
+    if (!this.disposePromise) {
+      this.disposePromise = this.disposeResources();
+    }
+    return this.disposePromise;
+  }
+
+  private async disposeResources(): Promise<void> {
+    Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
+    pollingManager.stopAll();
+    this.requestQueue.abortAllRequests();
+    cleanup();
+
+    _connector?.stop();
+    let transportCleanup: Promise<void>;
+    try {
+      transportCleanup = Promise.resolve(TransportManager.getTransport()?.stop?.()).catch(error => {
+        Log.warn('[Core] Transport cleanup failed:', error);
+      });
+    } catch (error) {
+      Log.warn('[Core] Transport cleanup failed:', error);
+      transportCleanup = Promise.resolve();
+    }
+
+    // Preserve synchronous dispose semantics for in-memory state and listeners.
     _deviceList = undefined;
     _connector = undefined;
+    DevicePool.resetState();
     deviceCacheMap.clear();
     preWarmInflight.clear();
     preWarmDoneAt.clear();
-    Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
+    preConnectCache = { passphraseState: undefined };
+    this.prePendingCallPromise = undefined;
+    this.removeAllListeners();
     cleanupSdkInstance(this.sdkInstanceId);
+    if (_core === this) _core = undefined;
+
+    // Transports, especially Node USB, may release native handles asynchronously.
+    await transportCleanup;
   }
 }
 
 export const initCore = () => {
-  _core = new Core();
-  return _core;
+  const core = new Core();
+  _core = core;
+  return core;
 };
 
 export const initConnector = () => {
   _connector = new DeviceConnector();
+  DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
+  DevicePool.emitter.removeListener(DEVICE.DISCONNECT, onDeviceDisconnectHandler);
+  DevicePool.emitter.removeListener(
+    TRANSPORT_EVENT.DEVICE_DISCONNECT,
+    onTransportDeviceDisconnectHandler
+  );
+  DevicePool.emitter.on(DEVICE.CONNECT, onDeviceConnectHandler);
   DevicePool.emitter.on(DEVICE.DISCONNECT, onDeviceDisconnectHandler);
+  DevicePool.emitter.on(TRANSPORT_EVENT.DEVICE_DISCONNECT, onTransportDeviceDisconnectHandler);
   return _connector;
 };
 
@@ -1439,7 +1563,6 @@ export const init = async (
   try {
     try {
       await DataManager.load(settings);
-      setProtocolV2DeviceInfoMock(settings.protocolV2DeviceInfoMockEnabled ?? false);
       initTransport(Transport, plugin);
     } catch {
       Log.error('DataManager.load error');