@onekeyfe/hd-transport-react-native 1.1.34-alpha.2 → 1.1.34-alpha.3

package/dist/logger.d.ts

@@ -0,0 +1,14 @@
+type LogMethod = (...args: unknown[]) => void;
+type TransportLogger = {
+    debug?: LogMethod;
+    error?: LogMethod;
+    warn?: LogMethod;
+};
+export declare const setBleLogger: (logger?: TransportLogger) => void;
+export declare const bleLogger: {
+    debug: (...args: unknown[]) => void | undefined;
+    error: (...args: unknown[]) => void | undefined;
+    warn: (...args: unknown[]) => void | undefined;
+};
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;AAE9C,KAAK,eAAe,GAAG;IACrB,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB,CAAC;AAIF,eAAO,MAAM,YAAY,YAAa,eAAe,SAEpD,CAAC;AAEF,eAAO,MAAM,SAAS;qBACH,OAAO,EAAE;qBACT,OAAO,EAAE;oBACV,OAAO,EAAE;CAC1B,CAAC"}

package/dist/subscribeBleOn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscribeBleOn.d.ts","sourceRoot":"","sources":["../src/subscribeBleOn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,eAAO,MAAM,cAAc,eAAgB,aAAa,kBAAc,QAAQ,IAAI,CAqB9E,CAAC"}
+{"version":3,"file":"subscribeBleOn.d.ts","sourceRoot":"","sources":["../src/subscribeBleOn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,eAAO,MAAM,cAAc,eAAgB,aAAa,kBAAc,QAAQ,IAAI,CAmB9E,CAAC"}

package/dist/transportLog.d.ts

@@ -0,0 +1,13 @@
+import type { ProtocolType } from '@onekeyfe/hd-transport';
+export declare function createTransportCallLog(name: string, protocol: ProtocolType, data: Record<string, unknown>): {
+    name: string;
+    protocol: ProtocolType;
+    file_name: unknown;
+    hash: unknown;
+} | {
+    name: string;
+    protocol: ProtocolType;
+    file_name?: undefined;
+    hash?: undefined;
+};
+//# sourceMappingURL=transportLog.d.ts.map

package/dist/transportLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transportLog.d.ts","sourceRoot":"","sources":["../src/transportLog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;EAY9B"}

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { ProtocolType } from '@onekeyfe/hd-transport';
 export type { BleManager as BlePlxManager } from 'react-native-ble-plx';
 export type TransportOptions = {
     scanTimeout?: number;
@@ -5,5 +6,6 @@ export type TransportOptions = {
 export type BleAcquireInput = {
     uuid: string;
     forceCleanRunPromise?: boolean;
+    expectedProtocol?: ProtocolType;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAExE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,YAAY,EAAE,UAAU,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAExE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gBAAgB,CAAC,EAAE,YAAY,CAAC;CACjC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.1.34-alpha.2",
+  "version": "1.1.34-alpha.3",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -19,11 +19,11 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.1.34-alpha.2",
-    "@onekeyfe/hd-shared": "1.1.34-alpha.2",
-    "@onekeyfe/hd-transport": "1.1.34-alpha.2",
+    "@onekeyfe/hd-core": "1.1.34-alpha.3",
+    "@onekeyfe/hd-shared": "1.1.34-alpha.3",
+    "@onekeyfe/hd-transport": "1.1.34-alpha.3",
     "@onekeyfe/react-native-ble-utils": "^0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "dee167c35d191f3f4e02c4cb6228e1f926f929ec"
+  "gitHead": "3688bc8495eeb2ffd5616270d13fa29e8967623a"
 }

package/src/BleManager.ts

@@ -1,10 +1,11 @@
 import BleUtils from '@onekeyfe/react-native-ble-utils';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { LoggerNames, getLogger } from '@onekeyfe/hd-core';
+
+import { bleLogger } from './logger';
 
 import type { Peripheral } from '@onekeyfe/react-native-ble-utils';
 
-const Logger = getLogger(LoggerNames.HdBleTransport);
+const Logger = bleLogger;
 
 /**
  * get the device basic info of connected devices
@@ -20,36 +21,32 @@ export const pairDevice = (macAddress: string) => BleUtils.pairDevice(macAddress
 
 export const onDeviceBondState = (bleMacAddress: string): Promise<Peripheral | undefined> =>
   new Promise((resolve, reject) => {
-    let timeout: any | undefined;
-
-    const cleanup = (cleanupListener: (() => void) | undefined) => {
+    const cleanup = () => {
       if (timeout) {
         clearTimeout(timeout);
       }
       if (cleanupListener) cleanupListener();
     };
 
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded'));
+    }, 60 * 1000);
+
     const cleanupListener = BleUtils.onDeviceBondState(peripheral => {
       if (peripheral.id?.toLowerCase() !== bleMacAddress.toLowerCase()) {
         return;
       }
       const { bondState } = peripheral;
 
-      if (bondState.preState === 'BOND_NONE' && bondState.state === 'BOND_BONDING') {
-        timeout = setTimeout(() => {
-          cleanup(cleanupListener);
-          reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded'));
-        }, 60 * 1000);
-      }
-
       const hasBonded = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_BONDED';
       const hasCanceled = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_NONE';
       Logger.debug('onDeviceBondState bondState:', bondState);
       if (hasBonded) {
-        cleanup(cleanupListener);
+        cleanup();
         resolve(peripheral);
       } else if (hasCanceled) {
-        cleanup(cleanupListener);
+        cleanup();
         reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceBondedCanceled, 'bonding canceled'));
       }
     });

package/src/BleTransport.ts

@@ -1,10 +1,11 @@
 import { BleErrorCode } from 'react-native-ble-plx';
-import { LoggerNames, getLogger, wait } from '@onekeyfe/hd-core';
+import { wait } from '@onekeyfe/hd-shared';
+
+import { bleLogger } from './logger';
 
 import type { Characteristic, Device, Subscription } from 'react-native-ble-plx';
-// import { wait } from '@onekeyfe/hd-core/src/utils';
 
-const Log = getLogger(LoggerNames.HdBleTransport);
+const Log = bleLogger;
 
 export default class BleTransport {
   id: string;
@@ -13,7 +14,7 @@ export default class BleTransport {
 
   device: Device;
 
-  mtuSize = 20;
+  mtuSize = 23;
 
   writeCharacteristic: Characteristic;
 
@@ -23,6 +24,10 @@ export default class BleTransport {
 
   disconnectSubscription?: Subscription;
 
+  notifyTransactionId?: string;
+
+  monitorToken?: number;
+
   static MAX_RETRIES = 5;
 
   static RETRY_DELAY = 2000;
@@ -36,7 +41,6 @@ export default class BleTransport {
     this.device = device;
     this.writeCharacteristic = writeCharacteristic;
     this.notifyCharacteristic = notifyCharacteristic;
-    console.log(`BleTransport(${String(this.id)}) new instance`);
   }
 
   /**

package/src/__tests__/bleStrategy.test.ts

@@ -0,0 +1,42 @@
+import { hasWritableCapability, resolveProtocolV2PacketCapacity } from '../bleStrategy';
+
+describe('React Native BLE strategy', () => {
+  test('accepts writeWithoutResponse-only characteristics', () => {
+    const characteristic = {
+      isWritableWithResponse: false,
+      isWritableWithoutResponse: true,
+    };
+
+    expect(hasWritableCapability(characteristic)).toBe(true);
+  });
+
+  test('falls back to Android default ATT payload when MTU is unavailable', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'android',
+        androidPacketLength: 192,
+        mtu: null,
+      })
+    ).toBe(20);
+  });
+
+  test('caps Android packet length by negotiated MTU payload', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'android',
+        androidPacketLength: 192,
+        mtu: 100,
+      })
+    ).toBe(97);
+  });
+
+  test('keeps iOS packet length controlled by tuning profile', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'ios',
+        iosPacketLength: 244,
+        mtu: 256,
+      })
+    ).toBe(244);
+  });
+});

package/src/__tests__/constants.test.ts

@@ -0,0 +1,18 @@
+import { getBleUuidKey, getBluetoothServiceUuids, getInfosForServiceUuid } from '../constants';
+
+describe('React Native BLE service constants', () => {
+  it('includes the Pro2 advertisement service in scan filters', () => {
+    expect(getBluetoothServiceUuids().map(getBleUuidKey)).toContain('fffd');
+  });
+
+  it.each(['fffd', '0000fffd-0000-1000-8000-00805f9b34fb'])(
+    'resolves Pro2 service configuration for %s',
+    serviceUuid => {
+      expect(getInfosForServiceUuid(serviceUuid, 'classic')).toEqual({
+        serviceUuid: 'fffd',
+        writeUuid: '00000002-0000-1000-8000-00805f9b34fb',
+        notifyUuid: '00000003-0000-1000-8000-00805f9b34fb',
+      });
+    }
+  );
+});

package/src/__tests__/protocolV2Link.test.ts

@@ -0,0 +1,243 @@
+import { EventEmitter } from 'events';
+import transportPackage, {
+  PROTOCOL_V2_CHANNEL_BLE_UART,
+  ProtocolV2,
+  bytesToHex,
+} from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport from '../index';
+
+jest.mock(
+  'react-native',
+  () => ({
+    PermissionsAndroid: {},
+    Platform: { OS: 'ios' },
+  }),
+  { virtual: true }
+);
+
+jest.mock('react-native-ble-plx', () => ({
+  BleATTErrorCode: { UnlikelyError: 14 },
+  BleError: class BleError extends Error {},
+  BleErrorCode: {
+    DeviceAlreadyConnected: 203,
+    DeviceDisconnected: 205,
+    DeviceMTUChangeFailed: 206,
+    OperationCancelled: 2,
+    CharacteristicNotFound: 404,
+  },
+  BleManager: jest.fn(),
+  ScanMode: { LowLatency: 2 },
+}));
+
+jest.mock('../BleManager', () => ({
+  getConnectedDeviceIds: jest.fn(() => Promise.resolve([])),
+  onDeviceBondState: jest.fn(() => Promise.resolve()),
+  pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
+}));
+
+jest.mock('../subscribeBleOn', () => ({
+  subscribeBleOn: jest.fn(() => Promise.resolve()),
+}));
+
+const { parseConfigure } = transportPackage;
+
+const protocolV1Schema = {
+  nested: {
+    Initialize: { fields: {} },
+    Success: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Initialize: 1,
+        MessageType_Success: 2,
+      },
+    },
+  },
+};
+
+const protocolV2Schema = {
+  nested: {
+    Ping: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    FileWrite: { fields: {} },
+    Success: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+        MessageType_FileWrite: 60805,
+      },
+    },
+  },
+};
+
+const schemas = {
+  protocolV1: parseConfigure(protocolV1Schema),
+  protocolV2: parseConfigure(protocolV2Schema),
+};
+
+const createHarness = () => {
+  const uuid = 'rn-pro2-id';
+  const sentSeqs: number[] = [];
+  let shouldRespond = true;
+  let notifyCallback:
+    | ((
+        error: (Error & { reason?: string }) | null,
+        characteristic: { value: string } | null
+      ) => void)
+    | undefined;
+  const notifyCharacteristic = {
+    uuid: '0003',
+    deviceID: uuid,
+    isNotifiable: true,
+    monitor: jest.fn(callback => {
+      notifyCallback = callback;
+      return { remove: jest.fn() };
+    }),
+  };
+  const handleWrite = (base64: string) => {
+    const frame = Buffer.from(base64, 'base64');
+    sentSeqs.push(frame[6]);
+    if (shouldRespond) {
+      const response = ProtocolV2.encodeFrame(
+        schemas,
+        'Success',
+        { message: 'ok' },
+        { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+      );
+      notifyCallback?.(null, { value: Buffer.from(response).toString('base64') });
+    }
+    return Promise.resolve();
+  };
+  const writeCharacteristic = {
+    uuid: '0002',
+    deviceID: uuid,
+    isWritableWithResponse: true,
+    isWritableWithoutResponse: true,
+    writeWithResponse: jest.fn(handleWrite),
+    writeWithoutResponse: jest.fn(handleWrite),
+  };
+  const device = {
+    id: uuid,
+    name: 'OneKey Pro 2',
+    localName: 'OneKey Pro 2',
+    serviceUUIDs: ['fffd'],
+    isConnected: jest.fn(() => Promise.resolve(true)),
+    onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+  };
+  const bleManager = {
+    devices: jest.fn(() => Promise.resolve([device])),
+    connectedDevices: jest.fn(() => Promise.resolve([])),
+    cancelTransaction: jest.fn(() => Promise.resolve()),
+  };
+  const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
+  transport.blePlxManager = bleManager;
+  transport.resolveCharacteristics = jest.fn(() =>
+    Promise.resolve({ writeCharacteristic, notifyCharacteristic })
+  );
+  transport.init({ debug: jest.fn(), error: jest.fn() }, new EventEmitter());
+  transport.configure(protocolV1Schema);
+  transport.configureProtocolV2(protocolV2Schema);
+
+  return {
+    transport,
+    uuid,
+    sentSeqs,
+    writeCharacteristic,
+    setShouldRespond(value: boolean) {
+      shouldRespond = value;
+    },
+    emitMonitorError(error: Error & { reason?: string }) {
+      notifyCallback?.(error, null);
+    },
+  };
+};
+
+describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
+  test('keeps the Protocol V2 sequence across probe and the next call', async () => {
+    const { transport, uuid, sentSeqs } = createHarness();
+
+    await transport.acquire({ uuid });
+    await transport.call(uuid, 'Ping', { message: 'after-probe' });
+
+    expect(sentSeqs).toEqual([1, 2]);
+    expect(bytesToHex(new Uint8Array([sentSeqs[0], sentSeqs[1]]))).toBe('0102');
+    await transport.release(uuid, true);
+  });
+
+  test('rejects the active Protocol V2 reader when the current monitor errors', async () => {
+    const harness = createHarness();
+    const { transport, uuid, sentSeqs } = harness;
+    await transport.acquire({ uuid });
+    harness.setShouldRespond(false);
+
+    const call = transport.call(uuid, 'Ping', { message: 'wait-for-monitor' }, { timeoutMs: 50 });
+    while (sentSeqs.length < 2) {
+      await Promise.resolve();
+    }
+    await new Promise(resolve => {
+      setTimeout(resolve, 0);
+    });
+    harness.emitMonitorError(Object.assign(new Error('monitor failed'), { reason: 'link lost' }));
+
+    await expect(call).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleCharacteristicNotifyError,
+    });
+  });
+
+  test('retains the sequence cursor when a new monitor generation is acquired', async () => {
+    const { transport, uuid, sentSeqs } = createHarness();
+
+    await transport.acquire({ uuid });
+    await transport.release(uuid, true);
+    await transport.acquire({ uuid });
+
+    expect(sentSeqs).toEqual([1, 2]);
+    await transport.release(uuid, true);
+  });
+
+  test('uses withoutResponse for normal and high-volume calls', async () => {
+    const { transport, uuid, writeCharacteristic } = createHarness();
+
+    await transport.acquire({ uuid });
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+
+    await transport.call(uuid, 'Ping', { message: 'normal' });
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(2);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+
+    await transport.call(uuid, 'FileWrite', {});
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(3);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
+  test('rejects an active Protocol V2 reader when disconnect resets the link', async () => {
+    const harness = createHarness();
+    const { transport, uuid, sentSeqs } = harness;
+    await transport.acquire({ uuid });
+    harness.setShouldRespond(false);
+
+    const call = transport.call(uuid, 'Ping', { message: 'disconnect' }, { timeoutMs: 50 });
+    while (sentSeqs.length < 2) {
+      await Promise.resolve();
+    }
+
+    const rejection = expect(call).rejects.toThrow('React Native BLE transport disconnected');
+    await transport.disconnect(uuid);
+    await rejection;
+  });
+});

package/src/bleStrategy.ts

@@ -0,0 +1,35 @@
+import { ANDROID_DEFAULT_MTU, ANDROID_PACKET_LENGTH, IOS_PACKET_LENGTH } from './constants';
+
+export type BlePlatform = 'ios' | 'android' | string;
+
+export type BleWriteCapability = {
+  isWritableWithResponse?: boolean | null;
+  isWritableWithoutResponse?: boolean | null;
+};
+
+export function hasWritableCapability(characteristic: BleWriteCapability) {
+  return !!(characteristic.isWritableWithResponse || characteristic.isWritableWithoutResponse);
+}
+
+export function resolveProtocolV2PacketCapacity({
+  platform,
+  iosPacketLength = IOS_PACKET_LENGTH,
+  androidPacketLength = ANDROID_PACKET_LENGTH,
+  mtu,
+}: {
+  platform: BlePlatform;
+  iosPacketLength?: number;
+  androidPacketLength?: number;
+  mtu?: number | null;
+}) {
+  if (platform === 'ios') {
+    return iosPacketLength;
+  }
+
+  if (platform === 'android') {
+    const payloadLength = Math.max((mtu ?? ANDROID_DEFAULT_MTU) - 3, 1);
+    return Math.min(androidPacketLength, payloadLength);
+  }
+
+  return androidPacketLength;
+}

package/src/constants.ts

@@ -1,5 +1,14 @@
 export const IOS_PACKET_LENGTH = 128;
 export const ANDROID_PACKET_LENGTH = 192;
+export const ANDROID_DEFAULT_MTU = 23;
+
+export const normalizeBleUuid = (uuid?: string | null) =>
+  (uuid ?? '').replace(/-/g, '').toLowerCase();
+
+export const getBleUuidKey = (uuid?: string | null) => {
+  const normalized = normalizeBleUuid(uuid);
+  return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
+};
 
 type BluetoothServices = Record<
   string,
@@ -11,6 +20,7 @@ type BluetoothServices = Record<
 >;
 
 const ClassicServiceUUID = '00000001-0000-1000-8000-00805f9b34fb';
+const Pro2ServiceUUID = 'fffd';
 
 const OneKeyServices: Record<string, BluetoothServices> = {
   classic: {
@@ -19,6 +29,11 @@ const OneKeyServices: Record<string, BluetoothServices> = {
       writeUuid: '00000002-0000-1000-8000-00805f9b34fb',
       notifyUuid: '00000003-0000-1000-8000-00805f9b34fb',
     },
+    [Pro2ServiceUUID]: {
+      serviceUuid: Pro2ServiceUUID,
+      writeUuid: '00000002-0000-1000-8000-00805f9b34fb',
+      notifyUuid: '00000003-0000-1000-8000-00805f9b34fb',
+    },
   },
 };
 
@@ -35,9 +50,26 @@ export const getInfosForServiceUuid = (serviceUuid: string, deviceType: 'classic
   if (!services) {
     return null;
   }
-  const service = services[serviceUuid];
+  const normalizedServiceUuid = normalizeBleUuid(serviceUuid);
+  const service =
+    services[serviceUuid] ??
+    Object.values(services).find(
+      item =>
+        normalizeBleUuid(item.serviceUuid) === normalizedServiceUuid ||
+        getBleUuidKey(item.serviceUuid) === getBleUuidKey(serviceUuid)
+    );
   if (!service) {
     return null;
   }
   return service;
 };
+
+export const isSameBleUuid = (left?: string | null, right?: string | null) => {
+  const normalizedLeft = normalizeBleUuid(left);
+  const normalizedRight = normalizeBleUuid(right);
+
+  return (
+    normalizedLeft === normalizedRight ||
+    (getBleUuidKey(left) !== '' && getBleUuidKey(left) === getBleUuidKey(right))
+  );
+};