@onekeyfe/hd-core 1.2.0-alpha.52 → 1.2.0-alpha.53

package/src/api/firmware/uploadFirmware.ts

@@ -10,7 +10,6 @@ import { bytesToHex } from '../helpers/hexUtils';
 import { DataManager } from '../../data-manager';
 import { DevicePool } from '../../device/DevicePool';
 import { buildProtocolV1FeaturesPayload } from '../../deviceProfile';
-import { openFirmwareByteSource, readFirmwareByteSourceFully } from './FirmwareArtifactSource';
 
 import type { KnownDevice } from '../../types';
 import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
@@ -18,7 +17,6 @@ import type { PROTO } from '../../constants';
 import type { CoreMessage, IFirmwareUpdateProgressType } from '../../events';
 import type { Success } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const NEW_BOOT_UPRATE_FIRMWARE_VERSION = '2.4.5';
 const SESSION_ERROR = 'session not found';
@@ -90,20 +88,17 @@ export const waitBleInstall = async (updateType: string) => {
   }
 };
 
-const toArrayBuffer = (payload: ArrayBuffer | Buffer): ArrayBuffer => {
-  if (payload instanceof ArrayBuffer) {
-    return payload;
-  }
-  return new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength).slice().buffer;
-};
-
-export const uploadFirmwareFromSource = async (
+export const uploadFirmware = async (
   updateType: 'firmware' | 'ble',
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  source: FirmwareByteSource,
-  rebootOnSuccess?: boolean,
+  {
+    payload,
+    rebootOnSuccess,
+  }: PROTO.FirmwareUpload & {
+    rebootOnSuccess?: boolean;
+  },
   isUpdateBootloader?: boolean
 ) => {
   const deviceType = device.getCurrentDeviceType();
@@ -124,20 +119,20 @@ export const uploadFirmwareFromSource = async (
       if (supportUpgradeFileHeader) {
         // Extract and validate firmware header (first 1KB)
         const HEADER_SIZE = 1024;
-        if (source.size < HEADER_SIZE) {
+        if (payload.byteLength < HEADER_SIZE) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            `firmware payload too small: ${source.size} bytes, expected at least ${HEADER_SIZE} bytes`
+            `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`
           );
         }
 
         Log.debug('Uploading firmware header:', {
           size: HEADER_SIZE,
-          totalSize: source.size,
+          totalSize: payload.byteLength,
         });
         postProgressTip(device, 'UploadingFirmwareHeader', postMessage);
 
-        const header = new Uint8Array(await source.readAt(0, HEADER_SIZE));
+        const header = new Uint8Array(payload.slice(0, HEADER_SIZE));
 
         try {
           const headerRes = await typedCall('UpgradeFileHeader', 'Success', {
@@ -174,9 +169,6 @@ export const uploadFirmwareFromSource = async (
     postProgressMessage(device, 0, 'installingFirmware', postMessage);
     let updateResponse: TypedResponseMessage<'Success'>;
     try {
-      // Classic/Mini bootloaders accept one protobuf payload and do not expose
-      // a request-range protocol. Other device families remain fully streamed.
-      const payload = await readFirmwareByteSourceFully(source);
       updateResponse = await typedCall('FirmwareUpload', 'Success', {
         payload,
       });
@@ -208,7 +200,9 @@ export const uploadFirmwareFromSource = async (
           updateType,
           postMessage,
           device,
-          source,
+          {
+            payload,
+          },
           rebootOnSuccess
         );
         return response.message;
@@ -217,7 +211,7 @@ export const uploadFirmwareFromSource = async (
 
     postConfirmationMessage(device);
     postProgressTip(device, 'ConfirmOnDevice', postMessage);
-    const length = source.size;
+    const length = payload.byteLength;
 
     let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
     postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
@@ -226,7 +220,7 @@ export const uploadFirmwareFromSource = async (
       const start = response.message.offset!;
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const end = response.message.offset! + response.message.length!;
-      const chunk = await source.readAt(start, end - start);
+      const chunk = payload.slice(start, end);
 
       if (start > 0) {
         postProgressMessage(
@@ -255,45 +249,11 @@ export const uploadFirmwareFromSource = async (
   throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown device model');
 };
 
-export const uploadFirmware = async (
-  updateType: 'firmware' | 'ble',
-  typedCall: TypedCall,
-  postMessage: (message: CoreMessage) => void,
-  device: Device,
-  {
-    payload,
-    rebootOnSuccess,
-  }: PROTO.FirmwareUpload & {
-    rebootOnSuccess?: boolean;
-  },
-  isUpdateBootloader?: boolean
-) => {
-  const source = await openFirmwareByteSource({
-    binary: toArrayBuffer(payload),
-  });
-  if (!source) {
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'firmware payload is empty');
-  }
-  try {
-    return await uploadFirmwareFromSource(
-      updateType,
-      typedCall,
-      postMessage,
-      device,
-      source,
-      rebootOnSuccess,
-      isUpdateBootloader
-    );
-  } finally {
-    await source.close();
-  }
-};
-
 const newTouchUpdateProcess = async (
   updateType: 'firmware' | 'ble',
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  source: FirmwareByteSource,
+  { payload }: PROTO.FirmwareUpload,
   rebootOnSuccess = true
 ) => {
   let typedCall = device.getCommands().typedCall.bind(device.getCommands());
@@ -303,13 +263,13 @@ const newTouchUpdateProcess = async (
   const env = DataManager.getSettings('env');
   const perPackageSize = DataManager.isBleConnect(env) ? 16 : 128;
   const chunkSize = 1024 * perPackageSize;
-  const totalChunks = Math.ceil(source.size / chunkSize);
+  const totalChunks = Math.ceil(payload.byteLength / chunkSize);
   let offset = 0;
   for (let i = 0; i < totalChunks; i++) {
     const chunkStart = i * chunkSize;
-    const chunkEnd = Math.min(chunkStart + chunkSize, source.size);
+    const chunkEnd = Math.min(chunkStart + chunkSize, payload.byteLength);
     const chunkLength = chunkEnd - chunkStart;
-    const chunk = await source.readAt(chunkStart, chunkLength);
+    const chunk = payload.slice(chunkStart, chunkEnd);
     const overwrite = i === 0;
     const progress = Math.round(((i + 1) / totalChunks) * 100);
     const writeRes = await emmcFileWriteWithRetry(
@@ -362,7 +322,12 @@ const newTouchUpdateProcess = async (
       try {
         if (isBleReconnect) {
           try {
-            await device.deviceConnector?.acquire(device.originalDescriptor.id, null, true);
+            await device.deviceConnector?.acquire(
+              device.originalDescriptor.id,
+              null,
+              true,
+              device.originalDescriptor.protocolType
+            );
             const typedCall = device.getCommands().typedCall.bind(device.getCommands());
             await Promise.race([
               typedCall('Initialize', 'Features', {}),
@@ -381,7 +346,8 @@ const newTouchUpdateProcess = async (
           const devicesDescriptor = deviceDiff?.descriptors ?? [];
           const { deviceList } = await DevicePool.getDevices(
             devicesDescriptor,
-            device.originalDescriptor.id
+            device.originalDescriptor.id,
+            { connectProtocol: device.originalDescriptor.protocolType }
           );
           if (deviceList.length === 1) {
             device.updateFromCache(deviceList[0]);
@@ -456,7 +422,12 @@ const emmcFileWriteWithRetry = async (
       const env = DataManager.getSettings('env');
       if (DataManager.isBleConnect(env)) {
         await wait(3000);
-        await device.deviceConnector?.acquire(device.originalDescriptor.id, null, true);
+        await device.deviceConnector?.acquire(
+          device.originalDescriptor.id,
+          null,
+          true,
+          device.originalDescriptor.protocolType
+        );
         await device.initialize();
       } else if (
         error?.message?.indexOf(SESSION_ERROR) > -1 ||
@@ -464,7 +435,9 @@ const emmcFileWriteWithRetry = async (
       ) {
         const deviceDiff = await device.deviceConnector?.enumerate();
         const devicesDescriptor = deviceDiff?.descriptors ?? [];
-        const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined);
+        const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
+          connectProtocol: device.originalDescriptor.protocolType,
+        });
         if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
           device.updateFromCache(deviceList[0]);
           await device.acquire();
@@ -530,67 +503,6 @@ export const updateResource = async (
   return processResourceRequest(typedCall, res, data);
 };
 
-export const updateResourceFromSource = async (
-  typedCall: TypedCall,
-  fileName: string,
-  source: FirmwareByteSource,
-  onConfirmAfter?: () => void
-) => {
-  const initialLength = Math.min(INIT_DATA_CHUNK_SIZE, source.size);
-  const initialChunk = new Uint8Array(await source.readAt(0, initialLength));
-  let response = await typedCall('ResourceUpdate', ['ResourceRequest', 'Success'], {
-    file_name: fileName,
-    data_length: source.size,
-    initial_data_chunk: bytesToHex(initialChunk),
-    hash: bytesToHex(blake2s(initialChunk)),
-  });
-  onConfirmAfter?.();
-
-  while (response.type !== 'Success') {
-    const { offset, data_length: dataLength } = response.message;
-    if (
-      !Number.isSafeInteger(offset) ||
-      offset === undefined ||
-      offset < 0 ||
-      !Number.isSafeInteger(dataLength) ||
-      dataLength === undefined ||
-      dataLength <= 0 ||
-      offset + dataLength > source.size
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Device requested an invalid firmware resource range'
-      );
-    }
-    const chunk = new Uint8Array(await source.readAt(offset, dataLength));
-    response = await typedCall('ResourceAck', ['ResourceRequest', 'Success'], {
-      data_chunk: bytesToHex(chunk),
-      hash: bytesToHex(blake2s(chunk)),
-    });
-  }
-  return response.message;
-};
-
-export const updateResourcesFromSources = async (
-  typedCall: TypedCall,
-  postMessage: (message: CoreMessage) => void,
-  device: Device,
-  entries: ReadonlyArray<{ entryName: string; source: FirmwareByteSource }>
-) => {
-  postProgressTip(device, 'UpdateSysResource', postMessage);
-  for (const [index, entry] of entries.entries()) {
-    await updateResourceFromSource(typedCall, entry.entryName, entry.source);
-    postProgressMessage(
-      device,
-      Math.floor(((index + 1) / entries.length) * 100),
-      'installingFirmware',
-      postMessage
-    );
-  }
-  postProgressTip(device, 'UpdateSysResourceSuccess', postMessage);
-  return true;
-};
-
 export const updateResources = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
@@ -625,28 +537,11 @@ export const updateBootloader = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  data: ArrayBuffer
-) => {
-  const source = await openFirmwareByteSource({ binary: data });
-  if (!source) {
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'bootloader payload is empty');
-  }
-  try {
-    return await updateBootloaderFromSource(typedCall, postMessage, device, source);
-  } finally {
-    await source.close();
-  }
-};
-
-export const updateBootloaderFromSource = async (
-  typedCall: TypedCall,
-  postMessage: (message: CoreMessage) => void,
-  device: Device,
-  source: FirmwareByteSource
+  source: ArrayBuffer
 ) => {
   postProgressTip(device, 'UpdateBootloader', postMessage);
   postProgressMessage(device, Math.floor(0), 'installingFirmware', postMessage);
-  await updateResourceFromSource(typedCall, 'bootloader.bin', source, () => {
+  await updateResource(typedCall, 'bootloader.bin', source, () => {
     postProcessingMessage('resource', postMessage);
   });
   postProgressMessage(device, Math.floor(100), 'installingFirmware', postMessage);

package/src/api/helpers/protocolV2FileWrite.ts

@@ -31,19 +31,21 @@ export type ProtocolV2FileWriteOptions = {
   uiPercentage?: number;
   timeoutMs?: number;
   maxChunkRetries?: number;
+  paceMs?: number;
   throwIfAborted?: () => void;
   onProgress?: (progress: ProtocolV2FileWriteProgress) => void;
 };
 
 const MIN_FILE_CHUNK_SIZE = 64;
 
-function isRetryableFileWriteTimeout(error: unknown) {
+export function isProtocolV2ResponseTimeout(error: unknown) {
   if (!error || typeof error !== 'object') return false;
-  const candidate = error as { errorCode?: number; code?: number; message?: string };
+  const candidate = error as { errorCode?: number; code?: number | string; message?: string };
   const code = candidate.errorCode ?? candidate.code;
   return (
     code === HardwareErrorCode.BleTimeoutError ||
-    /Lowlevel response timeout/i.test(candidate.message ?? '')
+    code === 'response-timeout' ||
+    /(?:BLE|Lowlevel|Protocol V2) response timeout/i.test(candidate.message ?? '')
   );
 }
 
@@ -147,7 +149,7 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
         );
         isWritePending = false;
       } catch (error) {
-        if (retryCount >= maxChunkRetries || !isRetryableFileWriteTimeout(error)) throw error;
+        if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
         retryCount += 1;
         options.throwIfAborted?.();
       }
@@ -186,6 +188,11 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
         elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
       elapsedMs,
     });
+    if (options.paceMs && options.paceMs > 0) {
+      await new Promise(resolve => {
+        setTimeout(resolve, options.paceMs);
+      });
+    }
   }
 
   return {

package/src/api/index.ts

@@ -3,6 +3,7 @@ export { default as testProtocolV2Ping } from './protocol-v2/Ping';
 export { default as preInitialize } from './device/PreInitialize';
 
 export { default as searchDevices } from './SearchDevices';
+export { default as detectDeviceConnectProtocol } from './DetectDeviceConnectProtocol';
 export { default as getFeatures } from './GetFeatures';
 export { default as getDeviceState } from './GetDeviceState';
 export { default as getOnekeyFeatures } from './GetOnekeyFeatures';
@@ -49,6 +50,7 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
 export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
 export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
+export { default as deviceUploadNft } from './protocol-v2/DeviceUploadNft';
 export { default as uploadPortfolio } from './UploadPortfolio';
 
 export { default as cipherKeyValue } from './CipherKeyValue';

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

@@ -0,0 +1,189 @@
+import { ERRORS, HardwareErrorCode, createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
+import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
+import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
+import {
+  PRO2_NFT_DEFAULT_CHUNK_SIZE,
+  PRO2_NFT_DEFAULT_PACE_MS,
+  PRO2_NFT_DEFAULT_TIMEOUT_MS,
+  PRO2_NFT_DIRECTORY,
+  PRO2_NFT_MAX_CHUNK_SIZE,
+  PRO2_NFT_MAX_ITEMS,
+  PRO2_NFT_MIN_CHUNK_SIZE,
+  type Pro2NftBundle,
+  type Pro2NftImage,
+  buildPro2NftBundle,
+  getCompletePro2NftBasenames,
+} from '../../utils/pro2Nft';
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+import { isProtocolV2ResponseTimeout, writeProtocolV2File } from '../helpers/protocolV2FileWrite';
+
+export type DeviceUploadNftParams = {
+  image: Pro2NftImage;
+  thumbnail: Pro2NftImage;
+  title: string;
+  subtitle: string;
+  timestampMs?: number;
+  chunkSize?: number;
+  paceMs?: number;
+  timeoutMs?: number;
+};
+
+export type DeviceUploadNftResponse = {
+  basename: string;
+  imagePath: string;
+  thumbnailPath: string;
+  metadataPath: string;
+  totalSize: number;
+  nftUpdated: true;
+  message?: string;
+};
+
+const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
+const FILESYSTEM_DIR_LIST_MESSAGE_TYPE = 60808;
+const NFT_UPDATE_MESSAGE_TYPE = 61500;
+
+export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
+  private bundle?: Pro2NftBundle;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    const {
+      image,
+      thumbnail,
+      title,
+      subtitle,
+      timestampMs = Date.now(),
+      chunkSize = PRO2_NFT_DEFAULT_CHUNK_SIZE,
+      paceMs = PRO2_NFT_DEFAULT_PACE_MS,
+      timeoutMs = PRO2_NFT_DEFAULT_TIMEOUT_MS,
+    } = this.payload;
+    if (
+      !Number.isInteger(chunkSize) ||
+      chunkSize < PRO2_NFT_MIN_CHUNK_SIZE ||
+      chunkSize > PRO2_NFT_MAX_CHUNK_SIZE
+    ) {
+      throw invalidParameter(
+        `Parameter [chunkSize] must be an integer between ${PRO2_NFT_MIN_CHUNK_SIZE} and ${PRO2_NFT_MAX_CHUNK_SIZE}.`
+      );
+    }
+    if (!Number.isInteger(paceMs) || paceMs < 0) {
+      throw invalidParameter('Parameter [paceMs] must be a non-negative integer.');
+    }
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+      throw invalidParameter('Parameter [timeoutMs] must be a positive integer.');
+    }
+
+    this.bundle = buildPro2NftBundle({ image, thumbnail, title, subtitle, timestampMs });
+    this.params = { image, thumbnail, title, subtitle, timestampMs, chunkSize, paceMs, timeoutMs };
+    this.unlockPolicy = 'none';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+  }
+
+  private async assertCapabilities() {
+    const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
+    const hasFileWrite = supportsProtocolV2Message(
+      protocolInfo,
+      FILESYSTEM_FILE_WRITE_MESSAGE_TYPE
+    );
+    const hasDirList = supportsProtocolV2Message(protocolInfo, FILESYSTEM_DIR_LIST_MESSAGE_TYPE);
+    const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
+    if (!hasFileWrite || !hasDirList || !hasNftUpdate) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+  }
+
+  private async assertStorageCapacity(basename: string) {
+    const { message } = await this.device.commands.typedCall(
+      'FilesystemDirList',
+      'FilesystemDir',
+      { path: PRO2_NFT_DIRECTORY, depth: 1 },
+      { timeoutMs: this.params.timeoutMs }
+    );
+    const existingBasenames = getCompletePro2NftBasenames(message.child_files);
+    if (existingBasenames.size >= PRO2_NFT_MAX_ITEMS && !existingBasenames.has(basename)) {
+      throw ERRORS.TypedError(HardwareErrorCode.NftStorageLimitReached, undefined, {
+        count: existingBasenames.size,
+        limit: PRO2_NFT_MAX_ITEMS,
+      });
+    }
+  }
+
+  private async updateNft(basename: string) {
+    const params = { file_name_no_ext: basename };
+    const options = { timeoutMs: this.params.timeoutMs };
+    try {
+      return await this.device.commands.typedCall('NftUpdate', 'Success', params, options);
+    } catch (error) {
+      if (!isProtocolV2ResponseTimeout(error)) {
+        throw error;
+      }
+      this.throwIfAborted();
+      return this.device.commands.typedCall('NftUpdate', 'Success', params, options);
+    }
+  }
+
+  async run(): Promise<DeviceUploadNftResponse> {
+    const { bundle } = this;
+    if (!bundle) throw invalidParameter('NFT data has not been initialized.');
+
+    await this.assertCapabilities();
+    this.throwIfAborted();
+    await this.assertStorageCapacity(bundle.basename);
+    this.throwIfAborted();
+
+    const files = [
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.bin`, data: bundle.image },
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}_m.bin`, data: bundle.thumbnail },
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.json`, data: bundle.metadata },
+    ];
+    const totalSize = files.reduce((sum, file) => sum + file.data.byteLength, 0);
+    let transferredBeforeFile = 0;
+
+    for (const file of files) {
+      const transferredAtFileStart = transferredBeforeFile;
+      await writeProtocolV2File({
+        commands: this.device.commands,
+        path: file.path,
+        data: file.data,
+        totalSize: file.data.byteLength,
+        chunkSize: this.params.chunkSize,
+        timeoutMs: this.params.timeoutMs,
+        paceMs: this.params.paceMs,
+        overwrite: true,
+        append: false,
+        throwIfAborted: () => this.throwIfAborted(),
+        onProgress: progress => {
+          if (typeof this.postMessage !== 'function') return;
+          const transferredBytes = transferredAtFileStart + progress.transferredBytes;
+          this.postMessage(
+            createUiMessage(UI_REQUEST.DEVICE_PROGRESS, {
+              ...progress,
+              progress: Math.floor((transferredBytes / totalSize) * 100),
+              transferredBytes,
+              totalBytes: totalSize,
+            })
+          );
+        },
+      });
+      transferredBeforeFile += file.data.byteLength;
+    }
+
+    this.throwIfAborted();
+    const response = await this.updateNft(bundle.basename);
+    return {
+      basename: bundle.basename,
+      imagePath: files[0].path,
+      thumbnailPath: files[1].path,
+      metadataPath: files[2].path,
+      totalSize,
+      nftUpdated: true,
+      message: response.message?.message,
+    };
+  }
+}

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

@@ -13,7 +13,9 @@ export default class ProtocolInfoRequest extends BaseMethod {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {});
+    const res = await this.device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
     return Promise.resolve(res.message);
   }
 }

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

@@ -118,6 +118,7 @@ export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
     message.includes('connection has timed out unexpectedly') ||
     message.includes('connection error has occured') ||
     message.includes('connection error has occurred') ||
+    message.includes('react native ble transport released') ||
     message.includes('multiplatformbleadapter') ||
     message.includes('multipalformebleadapter') ||
     compactMessage.includes('rxerrorerror6') ||

package/src/core/deviceEventRegistration.ts

@@ -4,6 +4,8 @@ import type { Device, DeviceEvents } from '../device/Device';
 
 export type HardwareUiEventHandlers = {
   pin: (...event: DeviceEvents[typeof DEVICE.PIN]) => void;
+  pinOnDevice: (...event: DeviceEvents[typeof DEVICE.PIN_ON_DEVICE]) => void;
+  pinOnDeviceComplete: (...event: DeviceEvents[typeof DEVICE.PIN_ON_DEVICE_COMPLETE]) => void;
   button: (...event: DeviceEvents[typeof DEVICE.BUTTON]) => void;
   passphrase: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE]) => void;
   passphraseOnDevice: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE_ON_DEVICE]) => void;
@@ -15,6 +17,8 @@ export function registerHardwareUiEventListeners(
   handlers: HardwareUiEventHandlers
 ) {
   device.on(DEVICE.PIN, handlers.pin);
+  device.on(DEVICE.PIN_ON_DEVICE, handlers.pinOnDevice);
+  device.on(DEVICE.PIN_ON_DEVICE_COMPLETE, handlers.pinOnDeviceComplete);
   device.on(DEVICE.BUTTON, handlers.button);
   device.on(DEVICE.PASSPHRASE, handlers.passphrase);
   device.on(DEVICE.PASSPHRASE_ON_DEVICE, handlers.passphraseOnDevice);