@onekeyfe/hd-core 1.1.34-alpha.3 → 1.1.34-alpha.4

package/src/core/index.ts

@@ -17,8 +17,11 @@ import {
 import {
   LoggerNames,
   enableLog,
+  getDeviceBLEFirmwareVersion,
+  getDeviceFirmwareVersion,
+  getFirmwareType,
   getLogger,
-  isMethodVersionRangeUnsupported,
+  getMethodVersionRange,
   setLoggerPostMessage,
   wait,
 } from '../utils';
@@ -26,6 +29,7 @@ import {
   findDefectiveBatchDevice,
   getDefectiveDeviceInfo,
 } from '../utils/findDefectiveBatchDevice';
+import { supportNewPassphrase } from '../utils/deviceFeaturesUtils';
 import {
   cleanupSdkInstance,
   completeRequestContext,
@@ -36,7 +40,6 @@ 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';
@@ -52,25 +55,22 @@ 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 { runMethodWithUnlockRetry } from '../protocols/protocol-v2/unlockRetry';
-import {
-  ProtocolV2UiInteractionCoordinator,
-  isProtocolV2UiEnabled,
-} from '../protocols/protocol-v2/uiInteraction';
 
-import type { ConnectSettings, Features, KnownDevice } from '../types';
+import type { ConnectSettings, 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 {
+  Features,
+  LowlevelTransportSharedPlugin,
+  OneKeyDeviceInfo,
+} from '@onekeyfe/hd-transport';
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
@@ -99,14 +99,12 @@ function hasDeriveCardano(method: BaseMethod): boolean {
 
 const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   initSession: method?.payload.initSession,
-  passphraseState: method?.payload.useEmptyPassphrase ? undefined : method?.payload.passphraseState,
+  passphraseState: method?.payload.passphraseState,
   deviceId: method?.payload.deviceId,
   deriveCardano: method && hasDeriveCardano(method),
-  connectProtocol: method?.payload.connectProtocol,
-  protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
 });
 
-let _core: Core | undefined;
+let _core: Core;
 let _deviceList: DeviceList | undefined;
 let _connector: DeviceConnector | undefined;
 let _uiPromises: UiPromise<UiPromiseResponse['type']>[] = []; // Waiting for ui response
@@ -150,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;
@@ -166,10 +164,6 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
 
     method.init();
   } catch (error) {
-    if (method) {
-      completeMethodRequestContext(method, error);
-      method.dispose();
-    }
     return Promise.reject(error);
   }
 
@@ -196,25 +190,34 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   //   );
   // }
 
+  const { requestQueue, methodSynchronize } = context;
+  const error = await methodSynchronize(() => {
+    for (const requestId of requestQueue.getRequestTasksId()) {
+      const task = requestQueue.getTask(requestId);
+      Log.debug(
+        'pre request task: ',
+        `task?.id: ${task?.id},
+      task?.method.connectId: ${task?.method.connectId},
+      task?.method.deviceId: ${task?.method.deviceId},
+      task?.method.name: ${task?.method.name}`
+      );
+      // if (task) {
+      //   return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceBusy));
+      // }
+    }
+    return null;
+  });
+
+  if (error) {
+    return createResponseMessage(method.responseID, false, { error });
+  }
+
   // only the pre-warm signal (PreInitialize) forks here; normal methods fall
   // through to onCallDevice below, so the pre-warm dedup/guards never touch them
   if (method.isPreWarmSignal) {
     return handlePreWarmSignal(context, message, method);
   }
 
-  const { requestQueue, methodSynchronize } = context;
-  const admission = await methodSynchronize(
-    () => requestQueue.admitTask(method),
-    method.connectId ?? method.deviceId ?? 'unknown-device'
-  );
-  if (admission.status === 'busy') {
-    const error = ERRORS.TypedError(HardwareErrorCode.DeviceBusy);
-    DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
-    completeMethodRequestContext(method, error);
-    method.dispose();
-    return createResponseMessage(method.responseID, false, { error });
-  }
-
   return onCallDevice(context, message, method);
 };
 
@@ -226,16 +229,9 @@ const handlePreWarmSignal = async (
   message: CoreMessage,
   method: BaseMethod
 ): Promise<any> => {
-  const createAckResponse = () => {
-    DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
-    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 createAckResponse();
+    return createResponseMessage(method.responseID, true, true);
   }
 
   const key = method.getPreWarmKey();
@@ -248,12 +244,12 @@ const handlePreWarmSignal = async (
     } catch {
       // pre-warm is best-effort; ignore its failure for the coalesced caller
     }
-    return createAckResponse();
+    return createResponseMessage(method.responseID, true, true);
   }
 
   const doneAt = preWarmDoneAt.get(key);
   if (typeof doneAt === 'number' && Date.now() - doneAt <= method.preWarmTtl) {
-    return createAckResponse();
+    return createResponseMessage(method.responseID, true, true);
   }
 
   const run = onCallDevice(context, message, method);
@@ -334,7 +330,7 @@ const onCallDevice = async (
 
   await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
-  const task = requestQueue.getTask(method.responseID) ?? requestQueue.createTask(method);
+  const task = requestQueue.createTask(method);
 
   // Pre-warm holds the device as a per-connectId callback task so a concurrent
   // real call waits (before ensureConnected) instead of racing its Initialize.
@@ -361,7 +357,7 @@ const onCallDevice = async (
     );
   } catch (e) {
     preWarmCallbackTask?.resolve();
-    Log.debug('ensureConnected error: ', e);
+    console.log('ensureConnected error: ', e);
 
     completeMethodRequestContext(method, e);
 
@@ -378,10 +374,6 @@ const onCallDevice = async (
   if (method.payload?.onlyConnectBleDevice) {
     preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
-    DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
-    requestQueue.releaseTask(method.responseID);
-    completeMethodRequestContext(method);
-    method.dispose();
     return createResponseMessage(method.responseID, true, null);
   }
 
@@ -402,23 +394,18 @@ const onCallDevice = async (
     );
   }
 
-  registerHardwareUiEventListeners(device, {
-    pin: onDevicePinHandler,
-    button: onDeviceButtonHandler,
-    passphrase: message.payload.useEmptyPassphrase
-      ? onEmptyPassphraseHandler
-      : onDevicePassphraseHandler,
-    passphraseOnDevice: onEnterPassphraseOnDeviceHandler,
-    attachPinOnDevice: onEnterAttachPinOnDeviceHandler,
-  });
+  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);
   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
@@ -433,24 +420,13 @@ const onCallDevice = async (
     await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
     const inner = async (): Promise<void> => {
-      // The protocol is established after acquire/initialize. Reject Protocol V2-only
-      // methods on other devices through BaseMethod.requireProtocolV2.
-      if (method.requireProtocolV2 && !device.isProtocolV2()) {
-        throw createDeviceNotSupportMethodError(method.name, device.getCurrentFirmwareType());
-      }
-
       // check firmware version
-      const versionRange = device.getCurrentMethodVersionRange(
+      const versionRange = getMethodVersionRange(
+        device.features,
         type => method.getVersionRange()[type]
       );
-      const currentFirmwareVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
-      const currentBleVersion = device.getCurrentBLEFirmwareVersionString() ?? '0.0.0';
-      const deviceFirmwareType = device.getCurrentFirmwareType();
-      let newVersionStatus: ReturnType<typeof DataManager.getFirmwareStatus> | undefined;
-
-      // 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()) {
+
+      if (device.features) {
         await DataManager.checkAndReloadData();
 
         // 检测故障固件设备
@@ -467,9 +443,12 @@ const onCallDevice = async (
           }
         }
 
-        newVersionStatus = DataManager.getFirmwareStatus(device.features, deviceFirmwareType);
+        const deviceFirmwareType = getFirmwareType(device.features);
+        const newVersionStatus = DataManager.getFirmwareStatus(device.features, deviceFirmwareType);
         const bleVersionStatus = DataManager.getBLEFirmwareStatus(device.features);
 
+        const currentFirmwareVersion = getDeviceFirmwareVersion(device.features).join('.');
+        const currentBleVersion = getDeviceBLEFirmwareVersion(device.features).join('.');
         if (
           (newVersionStatus === 'required' || bleVersionStatus === 'required') &&
           method.skipForceUpdateCheck === false
@@ -495,43 +474,42 @@ const onCallDevice = async (
             currentVersions
           );
         }
-      }
 
-      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') {
+              throw createNewFirmwareUnReleaseHardwareError({
+                currentVersion: currentFirmwareVersion,
+                requireVersion: versionRange.min,
+                methodName: method.name,
+                firmwareType: getFirmwareType(device.features),
+              });
+            }
 
-      if (versionRange) {
-        if (semver.valid(versionRange.min) && semver.lt(currentFirmwareVersion, versionRange.min)) {
-          if (newVersionStatus === 'none' || newVersionStatus === 'valid') {
-            throw createNewFirmwareUnReleaseHardwareError({
-              currentVersion: currentFirmwareVersion,
-              requireVersion: versionRange.min,
-              methodName: method.name,
-              firmwareType: deviceFirmwareType,
-            });
+            return Promise.reject(
+              createNeedUpgradeFirmwareHardwareError({
+                currentVersion: currentFirmwareVersion,
+                requireVersion: versionRange.min,
+                methodName: method.name,
+                firmwareType: getFirmwareType(device.features),
+              })
+            );
           }
-
-          return Promise.reject(
-            createNeedUpgradeFirmwareHardwareError({
-              currentVersion: currentFirmwareVersion,
-              requireVersion: versionRange.min,
-              methodName: method.name,
-              firmwareType: deviceFirmwareType,
-            })
-          );
-        }
-        if (
-          versionRange.max &&
-          semver.valid(versionRange.max) &&
-          semver.gte(currentFirmwareVersion, versionRange.max)
-        ) {
-          return Promise.reject(
-            createDeprecatedHardwareError(currentFirmwareVersion, versionRange.max, method.name)
-          );
+          if (
+            versionRange.max &&
+            semver.valid(versionRange.max) &&
+            semver.gte(currentFirmwareVersion, versionRange.max)
+          ) {
+            return Promise.reject(
+              createDeprecatedHardwareError(currentFirmwareVersion, versionRange.max, method.name)
+            );
+          }
+        } else if (method.strictCheckDeviceSupport) {
+          throw createDeviceNotSupportMethodError(method.name, getFirmwareType(device.features));
         }
-      } else if (method.strictCheckDeviceSupport) {
-        throw createDeviceNotSupportMethodError(method.name, deviceFirmwareType);
       }
 
       // check call method mode
@@ -552,7 +530,7 @@ const onCallDevice = async (
       }
 
       if (method.deviceId && method.checkDeviceId) {
-        const isSameDeviceID = await checkLiveDeviceId(device, method.deviceId);
+        const isSameDeviceID = device.checkDeviceId(method.deviceId);
         if (!isSameDeviceID) {
           return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError));
         }
@@ -569,16 +547,16 @@ const onCallDevice = async (
       method.checkDeviceSupportFeature();
 
       // reconfigure messages
-      if (_deviceList && device.features && !device.isProtocolV2()) {
+      if (_deviceList) {
         await TransportManager.reconfigure(device.features);
       }
 
       // Check to see if it is safe to use Passphrase
       checkPassphraseEnableState(method, device.features);
 
-      if (shouldCheckPassphraseState(method, device)) {
+      if (device.hasUsePassphrase() && method.useDevicePassphraseState) {
         // check version
-        const support = device.supportNewPassphrase();
+        const support = supportNewPassphrase(device.features);
         if (!support.support) {
           return Promise.reject(
             ERRORS.TypedError(
@@ -629,11 +607,7 @@ const onCallDevice = async (
       method.device?.commands?.checkDisposed();
 
       try {
-        const response: object = await runMethodWithUnlockRetry(
-          method,
-          device,
-          protocolV2UiCoordinator
-        );
+        const response: object = await method.run();
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
@@ -650,8 +624,6 @@ const onCallDevice = async (
         ) {
           throw error;
         }
-      } finally {
-        protocolV2UiCoordinator.close();
       }
     };
     Log.debug('Call API - Device Run: ', device.mainId);
@@ -661,9 +633,8 @@ const onCallDevice = async (
       skipInitialize: canSkipInitialize(method, device),
       ...parseInitOptions(method),
     };
-    const deviceRunPromise = device.run(inner, runOptions);
-    task.callPromise = createDeferred<any>();
-    deviceRunPromise.catch(error => task.callPromise?.reject(error));
+    const deviceRun = () => device.run(inner, runOptions);
+    task.callPromise = createDeferred<any>(deviceRun);
 
     try {
       return await task.callPromise.promise;
@@ -671,8 +642,6 @@ const onCallDevice = async (
       Log.debug('Device Run Error: ', e);
       completeMethodRequestContext(method, e);
       return createResponseMessage(method.responseID, false, { error: e });
-    } finally {
-      await deviceRunPromise.catch(() => undefined);
     }
   } catch (error) {
     messageResponse = createResponseMessage(method.responseID, false, { error });
@@ -708,9 +677,7 @@ const onCallDevice = async (
 
     requestQueue.releaseTask(method.responseID);
 
-    if (isProtocolV2UiEnabled(method)) {
-      closePopup();
-    }
+    closePopup();
 
     cleanup();
 
@@ -756,27 +723,17 @@ function initDevice(method: BaseMethod) {
   let device: Device | typeof undefined;
   const allDevices = _deviceList.allDevices();
 
-  if (method.payload?.detectBootloaderDevice && allDevices.some(d => d.isBootloader())) {
+  if (method.payload?.detectBootloaderDevice && allDevices.some(d => d.features?.bootloader_mode)) {
     throw ERRORS.TypedError(HardwareErrorCode.DeviceDetectInBootloaderMode);
   }
 
   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) {
     throw ERRORS.TypedError(
       [
-        'firmwareUpdateV4',
         'firmwareUpdateV3',
         'firmwareUpdateV2',
         'checkFirmwareRelease',
@@ -839,8 +796,8 @@ function canSkipInitialize(method: BaseMethod, device: Device): boolean {
   if (!method.connectId) reasons.push('connectId.missing');
   // passphrase state must match the pre-initialize
   if (!device.isPreInitializeMetaMatch(method.payload)) reasons.push('meta.mismatch');
-  // device must have been initialized before.
-  if (device.isUnacquired()) reasons.push('deviceInfo.missing');
+  // device must have been initialized before (has features)
+  if (!device.features) reasons.push('features.missing');
   // within pre-initialize TTL
   if (!device.isPreInitializedValid(PRE_INITIALIZE_TTL_MS)) reasons.push('ttl.expired');
 
@@ -856,23 +813,13 @@ function canSkipInitialize(method: BaseMethod, device: Device): boolean {
   return true;
 }
 
-function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
-  const message = error instanceof Error ? error.message : String(error ?? '');
-  return (
-    method.payload.connectProtocol === 'V2' &&
-    message.includes('Device protocol mismatch') &&
-    message.includes('expected V2') &&
-    message.includes('did not respond to expected protocol')
-  );
-}
-
 /**
  * If the Bluetooth connection times out, retry up to 6 times
  * @param retryCount - Current retry count (default 0)
  */
 async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
-    await device.acquire(method.payload.connectProtocol);
+    await device.acquire();
     if (method.payload?.onlyConnectBleDevice) {
       return;
     }
@@ -885,12 +832,7 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
       });
     }
   } catch (err) {
-    if (
-      (err.errorCode === HardwareErrorCode.BleTimeoutError ||
-        err.errorCode === HardwareErrorCode.BleConnectedError ||
-        isRetryableBleProtocolV2ProbeError(method, err)) &&
-      retryCount < 6
-    ) {
+    if (err.errorCode === HardwareErrorCode.BleTimeoutError && retryCount < 6) {
       const nextRetry = retryCount + 1;
       Log.debug(`Bluetooth connect timeout and will retry, retry count: ${nextRetry}`);
       await wait(3000);
@@ -1149,11 +1091,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
 const checkPassphraseEnableState = (method: BaseMethod, features?: Features) => {
   if (!method.useDevicePassphraseState) return;
 
-  const passphraseProtection = method.device
-    ? method.device.getCurrentPassphraseProtection()
-    : features?.passphraseProtection;
-
-  if (passphraseProtection === true) {
+  if (features?.passphrase_protection === true) {
     const hasNoPassphraseState =
       method.payload.passphraseState == null || method.payload.passphraseState === '';
     const shouldRequirePassphrase =
@@ -1165,18 +1103,12 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
     }
   }
 
-  if (passphraseProtection === false && method.payload.passphraseState) {
+  if (features?.passphrase_protection === false && method.payload.passphraseState) {
     DevicePool.clearDeviceCache(method.payload.connectId);
     throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
   }
 };
 
-const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
-  if (!method.useDevicePassphraseState) return false;
-
-  return device.hasUsePassphrase();
-};
-
 const cleanup = () => {
   _uiPromises = [];
   Log.debug('Cleanup...');
@@ -1196,16 +1128,16 @@ const closePopup = () => {
 };
 
 const onDeviceConnectHandler = (device: Device) => {
-  const deviceObject = device.toMessageObject();
-  if (!deviceObject) return;
-  postMessage(createDeviceMessage(DEVICE.CONNECT, { device: deviceObject }));
+  const env = DataManager.getSettings('env');
+  const deviceObject = DataManager.isBleConnect(env) ? device : device.toMessageObject();
+  postMessage(createDeviceMessage(DEVICE.CONNECT, { device: deviceObject as KnownDevice }));
 };
 
 const onDeviceDisconnectHandler = (device: Device) => {
   device.clearPreInitialized();
-  const deviceObject = device.toMessageObject();
-  if (!deviceObject) return;
-  postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject }));
+  const env = DataManager.getSettings('env');
+  const deviceObject = DataManager.isBleConnect(env) ? device : device.toMessageObject();
+  postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject as KnownDevice }));
 };
 
 const onDevicePinHandler = async (...[device, type, callback]: DeviceEvents['pin']) => {
@@ -1246,10 +1178,6 @@ 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']
 ) => {
@@ -1260,9 +1188,6 @@ const onDevicePassphraseHandler = async (
       device: device.toMessageObject() as KnownDevice,
       passphraseState: device.passphraseState,
       existsAttachPinUser: requestPayload.existsAttachPinUser,
-      source: requestPayload.source,
-      reason: requestPayload.reason,
-      expectedPassphraseState: requestPayload.expectedPassphraseState,
     })
   );
   // wait for passphrase
@@ -1284,27 +1209,12 @@ const onEmptyPassphraseHandler = (...[_, , callback]: DeviceEvents['passphrase']
 };
 
 const onEnterPassphraseOnDeviceHandler = (
-  ...[device, requestPayload]: [...DeviceEvents['passphrase_on_device']]
+  ...[device]: [...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,
     })
   );
 };
@@ -1375,8 +1285,6 @@ export default class Core extends EventEmitter {
 
   private requestQueue = new RequestQueue();
 
-  private disposePromise?: Promise<void>;
-
   // background task
   private prePendingCallPromise: Promise<void> | undefined;
 
@@ -1389,10 +1297,6 @@ export default class Core extends EventEmitter {
     Log.debug(`[Core] Created SDK instance: ${this.sdkInstanceId}`);
   }
 
-  cancelOperation(operationId: string) {
-    this.requestQueue.abortOperation(operationId);
-  }
-
   private getCoreContext() {
     return {
       sdkInstanceId: this.sdkInstanceId,
@@ -1439,17 +1343,10 @@ export default class Core extends EventEmitter {
       }
 
       case IFRAME.CALL: {
-        const logBlockLabel = getLogBlockLabel(message);
-        Log.log(
-          `[${Date.now()}][CALL_API]`,
-          logBlockLabel ? { method: logBlockLabel, payload: '[REDACTED]' } : message
-        );
+        Log.log(`[${Date.now()}][CALL_API]`, message);
         const response = await callAPI(this.getCoreContext(), message);
         const { success, payload } = response;
-        Log.log(
-          `[${Date.now()}][CALL_API_RESPONSE]`,
-          logBlockLabel ? { method: logBlockLabel, payload: '[REDACTED]' } : response
-        );
+        Log.log(`[${Date.now()}][CALL_API_RESPONSE]`, response);
         if (success) {
           return response;
         }
@@ -1468,10 +1365,6 @@ export default class Core extends EventEmitter {
         cancel(this.getCoreContext(), message.payload.connectId);
         break;
       }
-      case IFRAME.CANCEL_OPERATION: {
-        this.cancelOperation(message.payload.operationId);
-        break;
-      }
       case IFRAME.CALLBACK: {
         Log.log('callback message: ', message);
         postMessage(message);
@@ -1483,52 +1376,20 @@ export default class Core extends EventEmitter {
     return Promise.resolve(message);
   }
 
-  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.
+  dispose() {
     _deviceList = undefined;
     _connector = undefined;
-    DevicePool.resetState();
     deviceCacheMap.clear();
     preWarmInflight.clear();
     preWarmDoneAt.clear();
-    preConnectCache = { passphraseState: undefined };
-    this.prePendingCallPromise = undefined;
-    this.removeAllListeners();
+    Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
     cleanupSdkInstance(this.sdkInstanceId);
-    if (_core === this) _core = undefined;
-
-    // Transports, especially Node USB, may release native handles asynchronously.
-    await transportCleanup;
   }
 }
 
 export const initCore = () => {
-  const core = new Core();
-  _core = core;
-  return core;
+  _core = new Core();
+  return _core;
 };
 
 export const initConnector = () => {