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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.8-alpha.1",
+  "version": "1.2.8-alpha.100",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.8-alpha.1",
-    "@onekeyfe/hd-transport": "1.2.8-alpha.1",
+    "@onekeyfe/hd-shared": "1.2.8-alpha.100",
+    "@onekeyfe/hd-transport": "1.2.8-alpha.100",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "buffer": "^6.0.3",
@@ -46,5 +46,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "df614dc773e3e1075e5fbcdaee62d10a7a641eed"
+  "gitHead": "53ada5b79a51f0edf8a7392f70c8da063144d33c"
 }

package/src/api/FirmwareUpdateV4.ts

@@ -1,11 +1,4 @@
-import {
-  EDeviceType,
-  ERRORS,
-  HardwareError,
-  HardwareErrorCode,
-  isBleStaleBondHardwareError,
-  wait,
-} from '@onekeyfe/hd-shared';
+import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
 import JSZip from 'jszip';
 import {
   DeviceRebootType,
@@ -393,12 +386,11 @@ const getProtocolV2ErrorCode = (error: unknown): number | string | undefined =>
 };
 
 const isProtocolV2TerminalInstallStatusError = (error: unknown) =>
-  isBleStaleBondHardwareError(error) ||
-  (error instanceof HardwareError &&
-    (error.errorCode === HardwareErrorCode.ActionCancelled ||
-      error.errorCode === HardwareErrorCode.FirmwareError ||
-      error.errorCode === HardwareErrorCode.FirmwareVerificationFailed ||
-      error.params?.firmwareUpdateCode === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE));
+  error instanceof HardwareError &&
+  (error.errorCode === HardwareErrorCode.ActionCancelled ||
+    error.errorCode === HardwareErrorCode.FirmwareError ||
+    error.errorCode === HardwareErrorCode.FirmwareVerificationFailed ||
+    error.params?.firmwareUpdateCode === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE);
 
 const isProtocolV2TargetStatusFinished = (status: ProtocolV2FirmwareUpdateStatusTarget['status']) =>
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_FINISHED;
@@ -1880,9 +1872,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       if (!expectedHeaderHash || header.headerHash !== expectedHeaderHash) return false;
       return true;
     } catch (error) {
-      if (isBleStaleBondHardwareError(error)) {
-        throw error;
-      }
       Log.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
       return false;
     }
@@ -1976,7 +1965,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         }
         lastError = new Error('Protocol V2 device is reachable but is not in bootloader mode');
       } catch (error) {
-        if (isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
           throw error;
         }
         shouldReconnect = true;
@@ -2274,9 +2263,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         return processedSize + source.size;
       } catch (error) {
         this.throwIfAborted();
-        if (isBleStaleBondHardwareError(error)) {
-          throw error;
-        }
         lastError = error;
         if (attempt < PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
           await this.recoverProtocolV2FileTransfer();
@@ -2944,9 +2930,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         return;
       }
     } catch (error) {
-      if (isBleStaleBondHardwareError(error)) {
-        throw error;
-      }
       Log.log('[FirmwareUpdateV4] unable to confirm App mode before Normal reboot: ', error);
     }
     await this.protocolV2Reboot(DeviceRebootType.Normal);
@@ -3039,7 +3022,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           'Protocol V2 device is still in bootloader mode'
         );
       } catch (error) {
-        if (isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
           throw error;
         }
         shouldReconnect = true;

package/src/api/GetDeviceState.ts

@@ -1,4 +1,4 @@
-import { ERRORS, HardwareErrorCode, createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { BaseMethod } from './BaseMethod';
@@ -49,10 +49,7 @@ export default class GetDeviceState extends BaseMethod<
       this.device.isProtocolV2() &&
       isLoaderMode(state.status.mode)
     ) {
-      throw createDeviceNotSupportMethodError(
-        `${this.name}:${this.params.scope}`,
-        this.device.getCurrentFirmwareType()
-      );
+      throw ERRORS.TypedError(HardwareErrorCode.NotAllowInBootloaderMode);
     }
     return state;
   }

package/src/api/btc/BTCDeriveContextHash.ts

@@ -0,0 +1,90 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { Buffer } from 'buffer';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter, validateParams } from '../helpers/paramsValidator';
+import { getScriptType, validatePath } from '../helpers/pathUtils';
+
+import type { BabylonDeriveContextHash, CanonicalBitcoinNetwork } from '@onekeyfe/hd-transport';
+import type { BTCDeriveContextHashParams } from '../../types';
+
+const NETWORKS: Record<BTCDeriveContextHashParams['network'], CanonicalBitcoinNetwork> = {
+  'bitcoin-mainnet': 'BITCOIN_MAINNET',
+  'bitcoin-testnet': 'BITCOIN_TESTNET',
+  'bitcoin-signet': 'BITCOIN_SIGNET',
+  'bitcoin-regtest': 'BITCOIN_REGTEST',
+};
+
+export default class BTCDeriveContextHash extends BaseMethod<BabylonDeriveContextHash> {
+  strictCheckDeviceSupport = true;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowUsePreInitialize = true;
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'appName', type: 'string', required: true },
+      { name: 'context', type: 'string', required: true },
+      { name: 'network', type: 'string', required: true },
+    ]);
+
+    const { path, appName, context, network } = this.payload;
+    if (typeof appName !== 'string' || !/^[a-z0-9-]{1,64}$/.test(appName)) {
+      throw invalidParameter(
+        'appName must contain 1..64 ASCII lowercase letters, digits or hyphens'
+      );
+    }
+    if (typeof context !== 'string' || !/^(?:[0-9a-f]{2}){1,1024}$/.test(context)) {
+      throw invalidParameter('context must be 1..1024 bytes of lowercase hex without a prefix');
+    }
+    if (typeof network !== 'string' || !Object.prototype.hasOwnProperty.call(NETWORKS, network)) {
+      throw invalidParameter('Unsupported Bitcoin network');
+    }
+
+    // Reject malformed or overflowing indices before validatePath can truncate them.
+    if (
+      (typeof path === 'string' &&
+        (!/^m(?:\/\d+'?)+$/i.test(path) ||
+          path
+            .split('/')
+            .slice(1)
+            .some(index => Number(index.replace(/'/g, '')) >= 0x80000000))) ||
+      (Array.isArray(path) &&
+        path.findIndex(index => !Number.isInteger(index) || index < 0 || index > 0xffffffff) !== -1)
+    ) {
+      throw invalidParameter('Not a valid BIP-32 path');
+    }
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      script_type: getScriptType(addressN),
+      app_name: Buffer.from(appName, 'ascii').toString('hex'),
+      context,
+      network: NETWORKS[network as BTCDeriveContextHashParams['network']],
+    };
+  }
+
+  getVersionRange() {
+    return {
+      classic1s: { min: '3.21.0' },
+      classicpure: { min: '3.21.0' },
+    };
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'BabylonDeriveContextHash',
+      'BabylonDerivedContextHash',
+      this.params
+    );
+    if (typeof message.secret !== 'string' || !/^[0-9a-f]{64}$/.test(message.secret)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodError,
+        'Invalid Babylon context hash response'
+      );
+    }
+    return message;
+  }
+}

package/src/api/index.ts

@@ -60,6 +60,7 @@ export { default as allNetworkGetAddressByLoop } from './allnetwork/AllNetworkGe
 
 export { default as btcGetAddress } from './btc/BTCGetAddress';
 export { default as btcGetPublicKey } from './btc/BTCGetPublicKey';
+export { default as btcDeriveContextHash } from './btc/BTCDeriveContextHash';
 export { default as btcSignMessage } from './btc/BTCSignMessage';
 export { default as btcSignPsbt } from './btc/BTCSignPsbt';
 export { default as btcSignTransaction } from './btc/BTCSignTransaction';
@@ -174,3 +175,5 @@ export { default as benfenSignTransaction } from './benfen/BenfenSignTransaction
 
 export { default as neoGetAddress } from './neo/NeoGetAddress';
 export { default as neoSignTransaction } from './neo/NeoSignTransaction';
+export { default as zcashGetAddress } from './zcash/ZcashGetAddress';
+export { default as zcashSignPczt } from './zcash/ZcashSignPczt';

package/src/api/protocol-v2/DeviceReboot.ts

@@ -1,5 +1,6 @@
 import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
+import { UI_REQUEST } from '../../constants/ui-request';
 import { BaseMethod } from '../BaseMethod';
 import { normalizeRebootType } from './helpers';
 
@@ -11,6 +12,7 @@ export default class DeviceReboot extends BaseMethod<DeviceRebootParams> {
   }
 
   init() {
+    this.allowDeviceMode.push(UI_REQUEST.BOOTLOADER);
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     this.unlockPolicy = 'unlock-before-run';

package/src/api/zcash/ZcashGetAddress.ts

@@ -0,0 +1,121 @@
+import { ZcashAddressScope, ZcashAddressType } from '@onekeyfe/hd-transport';
+
+import { BaseMethod } from '../BaseMethod';
+import { serializedPath, toHardened, validatePath } from '../helpers/pathUtils';
+import { invalidParameter, validateParams, validateResult } from '../helpers/paramsValidator';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { ZcashGetAddress as HardwareZcashGetAddress } from '@onekeyfe/hd-transport';
+import type { ZcashGetAddressParams, ZcashAddress } from '../../types/api/zcashGetAddress';
+import type { DeviceFirmwareRange } from '../../types';
+
+export default class ZcashGetAddress extends BaseMethod<HardwareZcashGetAddress[]> {
+  hasBundle = false;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+    payload.bundle.forEach((batch: ZcashGetAddressParams) => {
+      // ZIP-32 account path: m/32'/133'/account'
+      const addressN = validatePath(batch.path, 3);
+      if (
+        addressN.length !== 3 ||
+        addressN[0] !== toHardened(32) ||
+        addressN[1] !== toHardened(133) ||
+        addressN[2] < toHardened(0) ||
+        addressN[2] > 0xffffffff
+      ) {
+        throw invalidParameter("Zcash requires a ZIP-32 account path m/32'/133'/account'");
+      }
+      const addressType = batch.addressType ?? ZcashAddressType.UNIFIED_ORCHARD_P2PKH;
+      const scope = batch.scope ?? ZcashAddressScope.EXTERNAL;
+      const diversifierIndex = batch.diversifierIndex ?? 0;
+      if (
+        ![
+          ZcashAddressType.UNIFIED_ORCHARD_P2PKH,
+          ZcashAddressType.TRANSPARENT_P2PKH,
+          ZcashAddressType.UNIFIED_ORCHARD,
+        ].includes(addressType) ||
+        ![ZcashAddressScope.EXTERNAL, ZcashAddressScope.INTERNAL].includes(scope)
+      ) {
+        throw invalidParameter('Invalid Zcash address type or scope');
+      }
+      const maxIndex = addressType === ZcashAddressType.UNIFIED_ORCHARD ? 0xffffffff : 0x7fffffff;
+      if (
+        !Number.isSafeInteger(diversifierIndex) ||
+        diversifierIndex < 0 ||
+        diversifierIndex > maxIndex
+      ) {
+        throw invalidParameter('Invalid Zcash diversifier index');
+      }
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'includeUfvk', type: 'boolean' },
+        { name: 'includeSeedFingerprint', type: 'boolean' },
+      ]);
+
+      this.params.push({
+        address_n: addressN,
+        address_type: addressType,
+        scope,
+        diversifier_index: diversifierIndex,
+        show_display: batch.showOnOneKey ?? true,
+        include_ufvk: batch.includeUfvk ?? false,
+        include_seed_fingerprint: batch.includeSeedFingerprint ?? false,
+      });
+    });
+  }
+
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      model_pro2: {
+        min: '0.0.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: ZcashAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('ZcashGetAddress', 'ZcashAddress', {
+        ...param,
+      });
+
+      const path = serializedPath(param.address_n);
+      responses.push({
+        path,
+        address: res.message.address,
+        ufvk: res.message.ufvk,
+        seedFingerprint: res.message.seed_fingerprint,
+      });
+
+      this.postPreviousAddressMessage({
+        address: res.message.address,
+        path,
+      });
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/zcash/ZcashSignPczt.ts

@@ -0,0 +1,153 @@
+import { bytesToHex } from '@noble/hashes/utils';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter, validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { ZcashSignPczt as HardwareZcashSignPczt } from '@onekeyfe/hd-transport';
+import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
+import type { ZcashSignedPczt } from '../../types/api/zcashSignPczt';
+import type { DeviceFirmwareRange } from '../../types';
+
+// Firmware buffers the whole PCZT in RAM in both directions.
+export const ZCASH_PCZT_MAX_BYTES = 24 * 1024;
+const CHUNK_BYTE_SIZE = 1024;
+
+export default class ZcashSignPczt extends BaseMethod<HardwareZcashSignPczt> {
+  pczt: Buffer = Buffer.alloc(0);
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+
+    validateParams(this.payload, [{ name: 'pczt', type: 'hexString', required: true }]);
+
+    this.pczt = Buffer.from(formatAnyHex(this.payload.pczt), 'hex');
+    if (this.pczt.length === 0) {
+      throw invalidParameter('pczt is empty');
+    }
+    if (this.pczt.length > ZCASH_PCZT_MAX_BYTES) {
+      throw invalidParameter(`pczt exceeds ${ZCASH_PCZT_MAX_BYTES} bytes (${this.pczt.length})`);
+    }
+
+    this.params = {
+      pczt_length: this.pczt.length,
+      pczt_initial_chunk: bytesToHex(this.pczt.subarray(0, CHUNK_BYTE_SIZE)),
+    };
+  }
+
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      model_pro2: {
+        min: '0.0.0',
+      },
+    };
+  }
+
+  // Upload: the device decides every chunk length via ZcashPcztChunkRequest and
+  // the host must answer with exactly that many bytes.
+  uploadPczt = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'ZcashSignedPczt'> | TypedResponseMessage<'ZcashPcztChunkRequest'>,
+    offset: number
+  ): Promise<TypedResponseMessage<'ZcashSignedPczt'>> => {
+    if (res.type === 'ZcashSignedPczt') {
+      if (offset !== this.pczt.length) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.ResponseUnexpectTypeError,
+          'device completed signing before receiving the whole pczt'
+        );
+      }
+      return res;
+    }
+
+    const { chunk_length: chunkLength } = res.message;
+    if (
+      !Number.isSafeInteger(chunkLength) ||
+      chunkLength <= 0 ||
+      offset + chunkLength > this.pczt.length
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        `device requested ${chunkLength} bytes at offset ${offset} of ${this.pczt.length}`
+      );
+    }
+
+    const chunk = this.pczt.subarray(offset, offset + chunkLength);
+    const next = await typedCall(
+      'ZcashPcztChunkAck',
+      ['ZcashSignedPczt', 'ZcashPcztChunkRequest'],
+      {
+        data_chunk: bytesToHex(chunk),
+      }
+    );
+
+    return this.uploadPczt(typedCall, next, offset + chunkLength);
+  };
+
+  // Download: the host decides chunk lengths via ZcashSignedPcztChunkRequest
+  // until the announced pczt_length has been received.
+  downloadSignedPczt = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'ZcashSignedPczt'>
+  ): Promise<Buffer> => {
+    const { pczt_length: total, pczt_initial_chunk: initial } = res.message;
+    if (!Number.isSafeInteger(total) || total <= 0 || total > ZCASH_PCZT_MAX_BYTES) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        `device announced invalid signed pczt length ${total}`
+      );
+    }
+
+    const parts: Buffer[] = [Buffer.from(initial ?? '', 'hex')];
+    let received = parts[0].length;
+    if (received > total) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        'device returned more initial pczt bytes than announced'
+      );
+    }
+
+    while (received < total) {
+      const chunkLength = Math.min(CHUNK_BYTE_SIZE, total - received);
+      const ack = await typedCall('ZcashSignedPcztChunkRequest', 'ZcashPcztChunkAck', {
+        chunk_length: chunkLength,
+      });
+      const chunk = Buffer.from(ack.message.data_chunk ?? '', 'hex');
+      if (chunk.length === 0 || received + chunk.length > total) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.ResponseUnexpectTypeError,
+          `device returned ${chunk.length} bytes at offset ${received} of ${total}`
+        );
+      }
+      parts.push(chunk);
+      received += chunk.length;
+    }
+
+    return Buffer.concat(parts);
+  };
+
+  async run(): Promise<ZcashSignedPczt> {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const first = await typedCall('ZcashSignPczt', ['ZcashSignedPczt', 'ZcashPcztChunkRequest'], {
+      ...this.params,
+    });
+
+    const signed = await this.uploadPczt(
+      typedCall,
+      first,
+      Math.min(CHUNK_BYTE_SIZE, this.pczt.length)
+    );
+    const pczt = await this.downloadSignedPczt(typedCall, signed);
+
+    return { pczt: bytesToHex(pczt) };
+  }
+}

package/src/core/index.ts

@@ -23,7 +23,6 @@ import {
   createNeedUpgradeFirmwareHardwareError,
   createNewFirmwareForceUpdateHardwareError,
   createNewFirmwareUnReleaseHardwareError,
-  isBleStaleBondHardwareError,
 } from '@onekeyfe/hd-shared';
 
 import { LoggerNames, enableLog, getLogger, setLoggerPostMessage, wait } from '../utils';
@@ -1035,10 +1034,6 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
   );
 }
 
-export function isTerminalBleStaleBondError(error: unknown) {
-  return isBleStaleBondHardwareError(error);
-}
-
 export function isDeviceIdentityMismatchError(error: unknown) {
   return (
     (error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.DeviceCheckDeviceIdError
@@ -1277,6 +1272,7 @@ const ensureConnected = async (
             HardwareErrorCode.BridgeNotInstalled,
             HardwareErrorCode.BridgeTimeoutError,
             HardwareErrorCode.BridgeNeedsPermission,
+            HardwareErrorCode.WebUsbDeviceAccessError,
           ].includes(error.errorCode)
         ) {
           _deviceList = undefined;
@@ -1363,6 +1359,7 @@ const ensureConnected = async (
             HardwareErrorCode.DeviceDetectInBootloaderMode,
             HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
             HardwareErrorCode.BridgeNeedsPermission,
+            HardwareErrorCode.WebUsbDeviceAccessError,
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
           ].includes(error.errorCode) ||
@@ -1370,7 +1367,6 @@ const ensureConnected = async (
             [HardwareErrorCode.BleDeviceDisconnected, HardwareErrorCode.PollingTimeout].includes(
               error.errorCode
             )) ||
-          isTerminalBleStaleBondError(error) ||
           isDeviceIdentityMismatchError(error)
         ) {
           reject(error);
@@ -1593,7 +1589,7 @@ const onDeviceConnectHandler = (device: Device) => {
 
 const onDeviceDisconnectHandler = (device: Device) => {
   device.clearPreInitialized();
-  const deviceObject = device.toMessageObject();
+  const deviceObject = device.toDisconnectMessageObject();
   if (!deviceObject) return;
   postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject }));
 };