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

package/src/device/DeviceCommands.ts

@@ -1,9 +1,8 @@
 import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionOpen_FailureSubCodes } from '@onekeyfe/hd-transport';
 
 import TransportManager from '../data-manager/TransportManager';
 import DataManager from '../data-manager/DataManager';
-import { LoggerNames, getLogger, patchFeatures } from '../utils';
+import { LoggerNames, getDeviceType, getLogger, patchFeatures } from '../utils';
 import { DEVICE, type PassphraseRequestPayload } from '../events';
 import { DeviceModelToTypes } from '../types';
 import {
@@ -13,12 +12,7 @@ import {
 } from '../utils/tracing';
 
 import type { Device } from './Device';
-import type {
-  FailureType,
-  Messages,
-  Transport,
-  TransportCallOptions,
-} from '@onekeyfe/hd-transport';
+import type { FailureType, Messages, Transport } from '@onekeyfe/hd-transport';
 
 export type PassphrasePromptResponse = {
   passphrase?: string;
@@ -28,137 +22,15 @@ export type PassphrasePromptResponse = {
 };
 
 type MessageType = Messages.MessageType;
-type MessageKey = Extract<keyof MessageType, string>;
+type MessageKey = keyof MessageType;
 export type TypedResponseMessage<T extends MessageKey> = {
   type: T;
   message: MessageType[T];
 };
 type TypedCallResponseMap = {
-  [K in MessageKey]: TypedResponseMessage<K>;
-};
-export type DefaultMessageResponse = TypedCallResponseMap[MessageKey];
-
-const MAX_DEBUG_ARRAY_ITEMS = 20;
-const MAX_DEBUG_OBJECT_KEYS = 40;
-const MAX_DEBUG_STRING_LENGTH = 512;
-const MAX_DEBUG_DEPTH = 4;
-const HIGH_VOLUME_DEBUG_CALLS = new Set([
-  'FilesystemFileRead',
-  'FilesystemFileWrite',
-  'FileRead',
-  'FileWrite',
-  'EmmcFileRead',
-  'EmmcFileWrite',
-  'FirmwareUpload',
-  'ResourceAck',
-]);
-
-function shouldReduceDebugForCall(type: string) {
-  return HIGH_VOLUME_DEBUG_CALLS.has(type);
-}
-
-function getBinaryByteLength(value: unknown): number | undefined {
-  if (value instanceof ArrayBuffer) {
-    return value.byteLength;
-  }
-
-  if (ArrayBuffer.isView(value)) {
-    return value.byteLength;
-  }
-
-  if (typeof Blob !== 'undefined' && value instanceof Blob) {
-    return value.size;
-  }
-
-  return undefined;
-}
-
-function summarizeRedactedData(value: unknown): string {
-  const byteLength = getBinaryByteLength(value);
-  if (byteLength !== undefined) {
-    return `[redacted data: ${byteLength} bytes]`;
-  }
-
-  if (typeof value === 'string') {
-    return `[redacted data: string length=${value.length}]`;
-  }
-
-  if (Array.isArray(value)) {
-    return `[redacted data: array length=${value.length}]`;
-  }
-
-  if (value && typeof value === 'object') {
-    return `[redacted data: object keys=${Object.keys(value).length}]`;
-  }
-
-  return `[redacted data: ${typeof value}]`;
-}
-
-function sanitizeDebugPayload(value: unknown, key = '', depth = 0): unknown {
-  if (key === 'data' && value !== null && value !== undefined) {
-    return summarizeRedactedData(value);
-  }
-
-  // Redact passphrase-bearing keys as defense in depth so commands such as
-  // Protocol V2 DeviceSessionOpen can never write hidden-wallet secrets to logs.
-  if (key && /passphrase/i.test(key)) {
-    return '[redacted passphrase]';
-  }
-
-  const byteLength = getBinaryByteLength(value);
-  if (byteLength !== undefined) {
-    return `[binary: ${byteLength} bytes]`;
-  }
-
-  if (typeof value === 'string') {
-    return value.length > MAX_DEBUG_STRING_LENGTH
-      ? `${value.slice(0, MAX_DEBUG_STRING_LENGTH)}... (len=${value.length})`
-      : value;
-  }
-
-  if (!value || typeof value !== 'object') {
-    return value;
-  }
-
-  if (depth >= MAX_DEBUG_DEPTH) {
-    return Array.isArray(value)
-      ? `[array length=${value.length}]`
-      : `[object keys=${Object.keys(value).length}]`;
-  }
-
-  if (Array.isArray(value)) {
-    const items = value
-      .slice(0, MAX_DEBUG_ARRAY_ITEMS)
-      .map(item => sanitizeDebugPayload(item, key, depth + 1));
-    if (value.length > MAX_DEBUG_ARRAY_ITEMS) {
-      items.push(`... (${value.length - MAX_DEBUG_ARRAY_ITEMS} more)`);
-    }
-    return items;
-  }
-
-  const entries = Object.entries(value).slice(0, MAX_DEBUG_OBJECT_KEYS);
-  const sanitized: Record<string, unknown> = {};
-  entries.forEach(([entryKey, entryValue]) => {
-    sanitized[entryKey] = sanitizeDebugPayload(entryValue, entryKey, depth + 1);
-  });
-  if (Object.keys(value).length > MAX_DEBUG_OBJECT_KEYS) {
-    sanitized.__truncated__ = `${Object.keys(value).length - MAX_DEBUG_OBJECT_KEYS} more keys`;
-  }
-  return sanitized;
-}
-
-/**
- * Interactive acknowledgements must not inherit timeoutMs from the original call.
- * User confirmation and PIN/passphrase entry have unbounded think time. Preserve only
- * response-related options such as expectedTypes and intermediateTypes.
- */
-const stripInteractiveAckTimeout = (
-  options?: TransportCallOptions
-): TransportCallOptions | undefined => {
-  if (!options) return options;
-  const { timeoutMs: _timeoutMs, ...rest } = options;
-  return rest;
+  [K in keyof MessageType]: TypedResponseMessage<K>;
 };
+export type DefaultMessageResponse = TypedCallResponseMap[keyof MessageType];
 
 const assertType = (res: DefaultMessageResponse, resType: string | string[]) => {
   const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
@@ -352,21 +224,17 @@ export class DeviceCommands {
   // Sends an async message to the opened device.
   async call(
     type: MessageKey,
-    msg?: DefaultMessageResponse['message'],
-    options?: TransportCallOptions
+    msg: DefaultMessageResponse['message'] = {}
   ): Promise<DefaultMessageResponse> {
-    const shouldReduceDebug = shouldReduceDebugForCall(type);
-    if (!shouldReduceDebug) {
-      Log.debug('[DeviceCommands] [call] Sending', type);
-    }
+    Log.debug('[DeviceCommands] [call] Sending', type);
 
     try {
-      const promise = this.transport.call(this.mainId, type, msg ?? {}, options) as any;
+      const promise = this.transport.call(this.mainId, type, msg) as any;
       this.callPromise = promise;
       const res = await promise;
       if (res.type === 'Failure') {
         LogCore.debug('[DeviceCommands] [call] Received', res.type, res.message);
-      } else if (!shouldReduceDebug) {
+      } else {
         LogCore.debug('[DeviceCommands] [call] Received', res.type);
       }
       return res;
@@ -415,22 +283,19 @@ export class DeviceCommands {
   typedCall<T extends MessageKey, R extends MessageKey[]>(
     type: T,
     resType: R,
-    msg?: MessageType[T],
-    options?: TransportCallOptions
+    msg?: MessageType[T]
   ): Promise<TypedCallResponseMap[R[number]]>;
 
   typedCall<T extends MessageKey, R extends MessageKey>(
     type: T,
     resType: R,
-    msg?: MessageType[T],
-    options?: TransportCallOptions
+    msg?: MessageType[T]
   ): Promise<TypedResponseMessage<R>>;
 
   async typedCall(
     type: MessageKey,
     resType: MessageKey | MessageKey[],
-    msg?: DefaultMessageResponse['message'],
-    options?: TransportCallOptions
+    msg?: DefaultMessageResponse['message']
   ) {
     if (this.disposed) {
       throw ERRORS.TypedError(
@@ -446,30 +311,17 @@ export class DeviceCommands {
         'PinMatrixAck',
         'PassphraseAck',
         'Cancel',
-        'DeviceSessionOpen',
         'BixinPinInputOnDevice',
-        'FilesystemFileRead',
-        'FilesystemFileWrite',
-        'FileRead',
-        'FileWrite',
-        'EmmcFileRead',
-        'EmmcFileWrite',
-        'FirmwareUpload',
-        'ResourceAck',
       ] as any;
       if (!skipTypes.includes(type) && msg) {
         // Use debug channel to avoid noise escalation
-        Log.debug('[DeviceCommands] [typedCall] Sending payload', type, sanitizeDebugPayload(msg));
+        Log.debug('[DeviceCommands] [typedCall] Sending payload', type, msg);
       }
     } catch (e) {
       // ignore logging errors
     }
 
-    const expectedTypes = Array.isArray(resType) ? resType : resType.split('|');
-    const response = await this._commonCall(type, msg, {
-      ...options,
-      expectedTypes: options?.expectedTypes ?? expectedTypes,
-    });
+    const response = await this._commonCall(type, msg);
     try {
       assertType(response, resType);
     } catch (error) {
@@ -482,12 +334,6 @@ export class DeviceCommands {
       // throw bridge network error
       if (error instanceof HardwareError) {
         if (error.errorCode === HardwareErrorCode.ResponseUnexpectTypeError) {
-          Log.debug('[DeviceCommands] [typedCall] Unexpected response type', {
-            request: type,
-            expected: resType,
-            received: response.type,
-            response: sanitizeDebugPayload(response.message),
-          });
           // Do not intercept CallMethodError
           // Do not intercept “assertType: Response of unexpected type” error
           // Blocking the above two messages will not know what the specific error message is, and the specific error should be handled by the subsequent business logic.
@@ -501,7 +347,7 @@ export class DeviceCommands {
           if (error.message.indexOf('BridgeDeviceDisconnected') > -1) {
             throw ERRORS.TypedError(HardwareErrorCode.BridgeDeviceDisconnected);
           }
-          throw error;
+          throw ERRORS.TypedError(HardwareErrorCode.ResponseUnexpectTypeError);
         }
       } else {
         // throw error anyway, next call should be resolved properly// throw error anyway, next call should be resolved properly
@@ -511,27 +357,20 @@ export class DeviceCommands {
     return response;
   }
 
-  async _commonCall(
-    type: MessageKey,
-    msg?: DefaultMessageResponse['message'],
-    options?: TransportCallOptions
-  ) {
-    const resp = await this.call(type, msg, options);
-    return this._filterCommonTypes(resp, type, options);
+  async _commonCall(type: MessageKey, msg?: DefaultMessageResponse['message']) {
+    const resp = await this.call(type, msg);
+    return this._filterCommonTypes(resp, type);
   }
 
   _filterCommonTypes(
     res: DefaultMessageResponse,
-    callType: MessageKey,
-    options?: TransportCallOptions
+    callType: MessageKey
   ): Promise<DefaultMessageResponse> {
     try {
-      if (shouldReduceDebugForCall(callType)) {
-        // Avoid debug logging on every high-frequency file-write chunk.
-      } else if (DataManager.getSettings('env') === 'react-native') {
-        Log.debug('_filterCommonTypes: ', JSON.stringify(sanitizeDebugPayload(res)));
+      if (DataManager.getSettings('env') === 'react-native') {
+        Log.debug('_filterCommonTypes: ', JSON.stringify(res));
       } else {
-        Log.debug('_filterCommonTypes: ', sanitizeDebugPayload(res));
+        Log.debug('_filterCommonTypes: ', res);
       }
     } catch (error) {
       // ignore
@@ -539,9 +378,8 @@ export class DeviceCommands {
 
     this.device.clearCancelableAction();
     if (res.type === 'Failure') {
-      const { code, subcode, message } = res.message as {
+      const { code, message } = res.message as {
         code?: string | FailureType;
-        subcode?: number;
         message?: string;
       };
       let error: HardwareError | null = null;
@@ -585,25 +423,8 @@ export class DeviceCommands {
       }
 
       if (code === 'Failure_ProcessError') {
-        const isInvalidWalletSession =
-          this.device.isProtocolV2() &&
-          callType === 'DeviceSessionOpen' &&
-          subcode === DeviceSessionOpen_FailureSubCodes.InvalidSession;
-        const isLegacyProtocolV2LockedFailure =
-          this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(message?.trim() ?? '');
-        if (isInvalidWalletSession) {
-          error = ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid, message, {
-            failureCode: code,
-            subcode,
-            firmwareMessage: message,
-          });
-        } else if (subcode === 9 || isLegacyProtocolV2LockedFailure) {
-          error = ERRORS.TypedError(HardwareErrorCode.DeviceLocked, message, {
-            failureCode: code,
-            subcode,
-            firmwareMessage: message,
-          });
-        } else if (
+        // Handle firmware verification failures
+        if (
           message?.includes('Bootloader file verify failed') ||
           message?.includes('verify failed')
         ) {
@@ -640,7 +461,7 @@ export class DeviceCommands {
     }
 
     if (res.type === 'ButtonRequest') {
-      const deviceType = this.device.getCurrentDeviceType();
+      const deviceType = getDeviceType(this.device.features);
       if (DeviceModelToTypes.model_mini.includes(deviceType)) {
         this.device.setCancelableAction(() => this.cancelDeviceOnOneKeyDevice());
       } else {
@@ -651,7 +472,7 @@ export class DeviceCommands {
       } else {
         this.device.emit(DEVICE.BUTTON, this.device, res.message);
       }
-      return this._commonCall('ButtonAck', {}, stripInteractiveAckTimeout(options));
+      return this._commonCall('ButtonAck', {});
     }
 
     if (res.type === 'EntropyRequest') {
@@ -664,15 +485,11 @@ export class DeviceCommands {
           if (pin === '@@ONEKEY_INPUT_PIN_IN_DEVICE') {
             // only classic\1s\mini\pure
             this.device.setCancelableAction(() => this.cancelDeviceOnOneKeyDevice());
-            return this._commonCall(
-              'BixinPinInputOnDevice',
-              {},
-              stripInteractiveAckTimeout(options)
-            ).finally(() => {
+            return this._commonCall('BixinPinInputOnDevice').finally(() => {
               this.device.clearCancelableAction();
             });
           }
-          return this._commonCall('PinMatrixAck', { pin }, stripInteractiveAckTimeout(options));
+          return this._commonCall('PinMatrixAck', { pin });
         },
         error => Promise.reject(error)
       );
@@ -680,27 +497,19 @@ export class DeviceCommands {
 
     if (res.type === 'PassphraseRequest') {
       const existsAttachPinUser = res.message.exists_attach_pin_user;
-      return this.promptPassphrase({
+      return this._promptPassphrase({
         existsAttachPinUser,
       }).then(response => {
         const { passphrase, passphraseOnDevice, attachPinOnDevice } = response;
 
         // Attach PIN on device
         if (attachPinOnDevice && existsAttachPinUser) {
-          return this._commonCall(
-            'PassphraseAck',
-            { on_device_attach_pin: true },
-            stripInteractiveAckTimeout(options)
-          );
+          return this._commonCall('PassphraseAck', { on_device_attach_pin: true });
         }
 
         return !passphraseOnDevice
-          ? this._commonCall('PassphraseAck', { passphrase }, stripInteractiveAckTimeout(options))
-          : this._commonCall(
-              'PassphraseAck',
-              { on_device: true },
-              stripInteractiveAckTimeout(options)
-            );
+          ? this._commonCall('PassphraseAck', { passphrase })
+          : this._commonCall('PassphraseAck', { on_device: true });
       });
     }
 
@@ -778,27 +587,10 @@ export class DeviceCommands {
     });
   }
 
-  promptPassphrase(
-    options: PassphraseRequestPayload,
-    promptOptions: { cancelDeviceOnReject?: boolean } = {}
-  ) {
+  _promptPassphrase(options: PassphraseRequestPayload) {
     return new Promise<PassphrasePromptResponse>((resolve, reject) => {
-      const cancelAndReject = (_error?: Error) => {
-        const rejectWithCancelledError = () => {
-          reject(
-            ERRORS.TypedError(
-              HardwareErrorCode.CallQueueActionCancelled,
-              `${DEVICE.PASSPHRASE} canceled`
-            )
-          );
-        };
-
-        if (promptOptions.cancelDeviceOnReject === false) {
-          rejectWithCancelledError();
-          return Promise.resolve();
-        }
-
-        return cancelDeviceInPrompt(this.device, false)
+      const cancelAndReject = (_error?: Error) =>
+        cancelDeviceInPrompt(this.device, false)
           .then(onCancel => {
             const error = ERRORS.TypedError(
               HardwareErrorCode.CallQueueActionCancelled,
@@ -815,7 +607,6 @@ export class DeviceCommands {
           .catch(error => {
             reject(error);
           });
-      };
 
       if (this.device.listenerCount(DEVICE.PASSPHRASE) > 0) {
         this.device.setCancelableAction(cancelAndReject);

package/src/device/DeviceConnector.ts

@@ -1,5 +1,3 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
 import { safeThrowError } from '../constants';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
@@ -8,7 +6,6 @@ import { resolveAfter } from '../utils/promiseUtils';
 import { LoggerNames, getLogger } from '../utils';
 
 import type { DeviceDescriptorDiff } from './DevicePool';
-import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 import type { OneKeyDeviceInfo as DeviceDescriptor, Transport } from '@onekeyfe/hd-transport';
 
 const Log = getLogger(LoggerNames.DeviceConnector);
@@ -78,37 +75,15 @@ export default class DeviceConnector {
     this.listening = false;
   }
 
-  async acquire(
-    path: string,
-    session?: string | null,
-    forceCleanRunPromise?: boolean,
-    connectProtocol?: HardwareConnectProtocol
-  ) {
-    Log.debug('acquire', path, session, connectProtocol);
+  async acquire(path: string, session?: string | null, forceCleanRunPromise?: boolean) {
+    Log.debug('acquire', path, session);
     const env = DataManager.getSettings('env');
     try {
       let res;
       if (DataManager.isBleConnect(env)) {
-        res = await this.transport.acquire({
-          uuid: path,
-          forceCleanRunPromise,
-          expectedProtocol: connectProtocol,
-        });
+        res = await this.transport.acquire({ uuid: path, forceCleanRunPromise });
       } else {
-        res = await this.transport.acquire({
-          path,
-          previous: session ?? null,
-          expectedProtocol: connectProtocol,
-        });
-      }
-      if (connectProtocol) {
-        const detectedProtocol = this.transport.getProtocolType(path);
-        if (detectedProtocol !== connectProtocol) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.RuntimeError,
-            `Device protocol mismatch: expected ${connectProtocol}, detected ${detectedProtocol}`
-          );
-        }
+        res = await this.transport.acquire({ path, previous: session ?? null });
       }
       return res;
     } catch (error) {

package/src/device/DevicePool.ts

@@ -3,7 +3,7 @@ import EventEmitter from 'events';
 // eslint-disable-next-line import/no-cycle
 import { Device } from './Device';
 import { DEVICE } from '../events';
-import { LoggerNames, getLogger } from '../utils';
+import { LoggerNames, getDeviceUUID, getLogger } from '../utils';
 
 import type { InitOptions } from './Device';
 import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
@@ -106,32 +106,26 @@ export class DevicePool extends EventEmitter {
         if (exist) {
           // Log.debug('find existed Device: ', connectId);
           device.updateDescriptor(exist, true);
-          await this._refreshRuntimeState(device, initOptions);
           devices[connectId] = device;
           deviceList.push(device);
-          await this._checkDevicePool(initOptions, connectId);
+          await this._checkDevicePool(initOptions);
           return { devices, deviceList };
         }
         Log.debug('found device in cache, but path is different: ', connectId);
       }
     }
 
-    const matchedDescriptor = connectId
-      ? descriptorList.find(descriptor => descriptor.path === connectId)
-      : undefined;
-    const descriptorsToInitialize = matchedDescriptor ? [matchedDescriptor] : descriptorList;
-
-    for await (const descriptor of descriptorsToInitialize) {
+    for await (const descriptor of descriptorList) {
       const device = await this._createDevice(descriptor, initOptions);
 
-      const connectId = device.getConnectId();
-      if (connectId) {
-        if (this.devicesCache[connectId]) {
-          const cache = this.devicesCache[connectId];
+      if (device.features) {
+        const uuid = getDeviceUUID(device.features);
+        if (this.devicesCache[uuid]) {
+          const cache = this.devicesCache[uuid];
           cache.updateDescriptor(descriptor, true);
         }
-        this.devicesCache[connectId] = device;
-        devices[connectId] = device;
+        this.devicesCache[uuid] = device;
+        devices[uuid] = device;
       }
 
       deviceList.push(device);
@@ -139,7 +133,7 @@ export class DevicePool extends EventEmitter {
     // Log.debug('get devices result : ', devices, deviceList);
     // console.log('device poll -> connected: ', this.connectedPool);
     // console.log('device poll -> disconnected: ', this.disconnectPool);
-    await this._checkDevicePool(initOptions, matchedDescriptor ? connectId : undefined);
+    await this._checkDevicePool(initOptions);
     return { devices, deviceList };
   }
 
@@ -156,74 +150,33 @@ export class DevicePool extends EventEmitter {
     if (!device) {
       device = Device.fromDescriptor(descriptor);
       device.deviceConnector = this.connector;
-      await device.connect(initOptions?.connectProtocol);
-      try {
-        await device.initialize(initOptions);
-        if (initOptions?.refreshRuntimeState && device.isProtocolV2()) {
-          await this._refreshProtocolV2DiscoveryState(device);
-        }
-      } finally {
-        await device.release();
-      }
+      await device.connect();
+      await device.initialize(initOptions);
+      await device.release();
     }
     return device;
   }
 
-  static async _refreshRuntimeState(device: Device, initOptions?: InitOptions) {
-    if (!initOptions?.refreshRuntimeState || !device.isProtocolV2()) return;
-    let refreshError: unknown;
-    await device.run(
-      async () => {
-        try {
-          await this._refreshProtocolV2DiscoveryState(device);
-        } catch (error) {
-          // Device.run releases after the callback; then propagate the actual read error.
-          refreshError = error;
-        }
-      },
-      { connectProtocol: initOptions.connectProtocol }
-    );
-    if (refreshError instanceof Error) throw refreshError;
-    if (refreshError) throw new Error(String(refreshError));
-  }
-
-  /**
-   * Device lists require live mode and name data. A status failure remains a connection
-   * error; settings only supplies a label, so its failure retains the existing name.
-   * Device.getDeviceState skips unsupported status/settings calls in loader mode.
-   */
-  static async _refreshProtocolV2DiscoveryState(device: Device) {
-    await device.getDeviceState({ refreshSections: ['status'] });
-    try {
-      await device.getDeviceState({ refreshSections: ['settings'] });
-    } catch (error) {
-      Log.debug('Unable to refresh Protocol V2 device label during discovery', error);
-    }
-  }
-
-  static async _checkDevicePool(initOptions?: InitOptions, connectId?: string) {
-    await this._sendConnectMessage(initOptions, connectId);
+  static async _checkDevicePool(initOptions?: InitOptions) {
+    await this._sendConnectMessage(initOptions);
     this._sendDisconnectMessage();
   }
 
-  static async _sendConnectMessage(initOptions?: InitOptions, connectId?: string) {
+  static async _sendConnectMessage(initOptions?: InitOptions) {
     for (let i = this.connectedPool.length - 1; i >= 0; i--) {
       const descriptor = this.connectedPool[i];
-      if (!connectId || descriptor.path === connectId) {
-        const device = await this._createDevice(descriptor, initOptions);
-        Log.debug('emit DEVICE.CONNECT: ', device?.features);
-        this.emitter.emit(DEVICE.CONNECT, device);
-        this.connectedPool.splice(i, 1);
-      }
+      const device = await this._createDevice(descriptor, initOptions);
+      Log.debug('emit DEVICE.CONNECT: ', device?.features);
+      this.emitter.emit(DEVICE.CONNECT, device);
+      this.connectedPool.splice(i, 1);
     }
   }
 
   static _sendDisconnectMessage() {
     for (let i = this.disconnectPool.length - 1; i >= 0; i--) {
-      const descriptor = this.disconnectPool[i];
+      const descriptor = this.connectedPool[i];
       const device = descriptor?.path ? this.getDeviceByPath(descriptor.path) : null;
       if (device) {
-        device.markTransportDisconnected();
         this.emitter.emit(DEVICE.DISCONNECT, device);
       }
       this.disconnectPool.splice(i, 1);
@@ -263,7 +216,6 @@ export class DevicePool extends EventEmitter {
       }
 
       Log.debug('emit DEVICE.DISCONNECT: ', device.features);
-      device.markTransportDisconnected();
       this.emitter.emit(DEVICE.DISCONNECT, device);
     });
   }

package/src/events/call.ts

@@ -53,12 +53,6 @@ export interface IFrameCancelMessage {
   payload: { connectId?: string };
 }
 
-export interface IFrameCancelOperationMessage {
-  event: typeof IFRAME.CANCEL_OPERATION;
-  type: typeof IFRAME.CANCEL_OPERATION;
-  payload: { operationId: string };
-}
-
 export interface IFrameSwitchTransportMessage {
   event: typeof IFRAME.SWITCH_TRANSPORT;
   type: typeof IFRAME.SWITCH_TRANSPORT;

package/src/events/core.ts

@@ -5,7 +5,6 @@ import type {
   IFrameCallMessage,
   IFrameCallbackMessage,
   IFrameCancelMessage,
-  IFrameCancelOperationMessage,
   IFrameSwitchTransportMessage,
 } from './call';
 import type { DeviceEventMessage } from './device';
@@ -24,7 +23,6 @@ export type CoreMessage = {
   | IFrameEventMessage
   | IFrameCallMessage
   | IFrameCancelMessage
-  | IFrameCancelOperationMessage
   | IFrameSwitchTransportMessage
   | IFrameCallbackMessage
   | UiResponseMessage