@onekeyfe/hd-transport-react-native 1.2.0-alpha.18 → 1.2.0-alpha.180

package/dist/transportLog.d.ts

@@ -1,13 +1,2 @@
-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;
-};
+export { createTransportCallLog } from '@onekeyfe/hd-transport';
 //# sourceMappingURL=transportLog.d.ts.map

package/dist/transportLog.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"transportLog.d.ts","sourceRoot":"","sources":["../src/transportLog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/types.d.ts

@@ -7,5 +7,6 @@ export type BleAcquireInput = {
     uuid: string;
     forceCleanRunPromise?: boolean;
     expectedProtocol?: ProtocolType;
+    protocolHint?: 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,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"}
+{"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;IAChC,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC"}

package/jest.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  preset: '../../jest.config.js',
+  testEnvironment: 'node',
+  modulePathIgnorePatterns: ['node_modules', '<rootDir>/dist'],
+  moduleNameMapper: {
+    // The workspace symlinks resolve to prebuilt dist outputs that can lag behind src.
+    '^@onekeyfe/hd-transport$': '<rootDir>/../hd-transport/src/index.ts',
+    '^@onekeyfe/hd-shared$': '<rootDir>/../shared/src/index.ts',
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.0-alpha.18",
+  "version": "1.2.0-alpha.180",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -15,15 +15,16 @@
   "scripts": {
     "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
     "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "test": "jest",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.0-alpha.18",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.18",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.18",
+    "@onekeyfe/hd-core": "1.2.0-alpha.180",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.180",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.180",
     "@onekeyfe/react-native-ble-utils": "^0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "bdbc5bf74e48ca90f5c56f3079b2b974e61f7aa4"
+  "gitHead": "37976e13bb904ec6167ccba67a7b497e5a3744a2"
 }

package/src/BleTransport.ts

@@ -1,12 +1,5 @@
-import { BleErrorCode } from 'react-native-ble-plx';
-import { wait } from '@onekeyfe/hd-shared';
-
-import { bleLogger } from './logger';
-
 import type { Characteristic, Device, Subscription } from 'react-native-ble-plx';
 
-const Log = bleLogger;
-
 export default class BleTransport {
   id: string;
 
@@ -14,7 +7,7 @@ export default class BleTransport {
 
   device: Device;
 
-  mtuSize = 23;
+  mtuSize: number | undefined;
 
   writeCharacteristic: Characteristic;
 
@@ -28,10 +21,6 @@ export default class BleTransport {
 
   monitorToken?: number;
 
-  static MAX_RETRIES = 5;
-
-  static RETRY_DELAY = 2000;
-
   constructor(
     device: Device,
     writeCharacteristic: Characteristic,
@@ -44,36 +33,15 @@ export default class BleTransport {
   }
 
   /**
-   * @description only for pro / touch , while upgrade firmware
-   * @param data
-   * @param retryCount
-   * @returns
+   * Bulk-transfer write (Protocol V1 FirmwareUpload / EmmcFileWrite only).
+   *
+   * Must stay writeWithoutResponse on every platform. writeWithResponse serialises
+   * each packet into its own connection-interval round trip, which on iOS turned a
+   * 1.7MB firmware upload (~13.5k packets) into a >10 minute transfer that never
+   * finished before the app-level timeout. Protocol V2 and ordinary V1 control
+   * messages pick their write type separately and are unaffected by this method.
    */
-  async writeWithRetry(data: string, retryCount = BleTransport.MAX_RETRIES): Promise<void> {
-    try {
-      await this.writeCharacteristic.writeWithoutResponse(data);
-    } catch (error) {
-      Log?.debug(
-        `Write retry attempt ${BleTransport.MAX_RETRIES - retryCount + 1}, error: ${error}`
-      );
-      if (retryCount > 0) {
-        await wait(BleTransport.RETRY_DELAY);
-        if (
-          error.errorCode === BleErrorCode.DeviceDisconnected ||
-          error.errorCode === BleErrorCode.CharacteristicNotFound
-        ) {
-          try {
-            await this.device.connect();
-            await this.device.discoverAllServicesAndCharacteristics();
-          } catch (e) {
-            Log?.debug(`Connect or discoverAllServicesAndCharacteristics error: ${e}`);
-          }
-        } else {
-          Log?.debug(`writeCharacteristic error: ${error}`);
-        }
-        return this.writeWithRetry(data, retryCount - 1);
-      }
-      throw error;
-    }
+  async writeWithRetry(data: string): Promise<void> {
+    await this.writeCharacteristic.writeWithoutResponse(data);
   }
 }

package/src/__tests__/BleTransport.test.ts

@@ -0,0 +1,114 @@
+import { BleErrorCode } from 'react-native-ble-plx';
+import { Platform } from 'react-native';
+
+import BleTransport from '../BleTransport';
+
+jest.mock(
+  'react-native',
+  () => ({
+    Platform: { OS: 'ios' },
+  }),
+  { virtual: true }
+);
+
+jest.mock(
+  'react-native-ble-plx',
+  () => ({
+    BleErrorCode: {
+      DeviceDisconnected: 205,
+      CharacteristicNotFound: 404,
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('@onekeyfe/hd-shared', () => ({
+  ...jest.requireActual('@onekeyfe/hd-shared'),
+  wait: jest.fn(() => Promise.resolve()),
+}));
+
+describe('BleTransport side-effecting writes', () => {
+  beforeEach(() => {
+    Platform.OS = 'ios';
+  });
+
+  test('does not reconnect or replay after the device disconnects', async () => {
+    const error = Object.assign(new Error('device disconnected'), {
+      errorCode: BleErrorCode.DeviceDisconnected,
+    });
+    const writeCharacteristic = {
+      isWritableWithResponse: true,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.reject(error)),
+    };
+    const device = {
+      id: 'classic-id',
+      connect: jest.fn(() => Promise.resolve()),
+      discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(device as any, writeCharacteristic as any, {} as any);
+
+    await expect(transport.writeWithRetry('payload')).rejects.toBe(error);
+
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(device.connect).not.toHaveBeenCalled();
+  });
+
+  test('keeps iOS bulk transfer on writeWithoutResponse even when the characteristic supports responses', async () => {
+    // writeWithResponse serialises every packet into its own connection-interval
+    // round trip. On a ~1.7MB firmware (~13.5k packets) that stalled the upload past
+    // the 600s app-level timeout, so bulk transfer must never opt into it.
+    const writeCharacteristic = {
+      isWritableWithResponse: true,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(
+      { id: 'classic-id' } as any,
+      writeCharacteristic as any,
+      {} as any
+    );
+
+    await transport.writeWithRetry('payload');
+
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledWith('payload');
+  });
+
+  test('keeps Android Protocol V1 writes on writeWithoutResponse', async () => {
+    Platform.OS = 'android';
+    const writeCharacteristic = {
+      isWritableWithResponse: true,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(
+      { id: 'classic-id' } as any,
+      writeCharacteristic as any,
+      {} as any
+    );
+
+    await transport.writeWithRetry('payload');
+
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledWith('payload');
+  });
+
+  test('uses writeWithoutResponse on iOS when the characteristic lacks response support', async () => {
+    const writeCharacteristic = {
+      isWritableWithResponse: false,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(
+      { id: 'classic-id' } as any,
+      writeCharacteristic as any,
+      {} as any
+    );
+
+    await transport.writeWithRetry('payload');
+
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledWith('payload');
+  });
+});

package/src/__tests__/bleStrategy.test.ts

@@ -1,4 +1,9 @@
-import { hasWritableCapability, resolveProtocolV2PacketCapacity } from '../bleStrategy';
+import {
+  hasWritableCapability,
+  resolveProtocolV2PacketCapacity,
+  shouldRefreshNegotiatedMtu,
+  shouldWriteProtocolV2WithResponse,
+} from '../bleStrategy';
 
 describe('React Native BLE strategy', () => {
   test('accepts writeWithoutResponse-only characteristics', () => {
@@ -10,27 +15,52 @@ describe('React Native BLE strategy', () => {
     expect(hasWritableCapability(characteristic)).toBe(true);
   });
 
-  test('falls back to Android default ATT payload when MTU is unavailable', () => {
+  test('uses the conservative ATT payload when MTU is unavailable', () => {
     expect(
       resolveProtocolV2PacketCapacity({
         platform: 'android',
-        androidPacketLength: 192,
         mtu: null,
       })
     ).toBe(20);
   });
 
+  test('only refreshes an unavailable or default MTU snapshot', () => {
+    expect(shouldRefreshNegotiatedMtu(undefined)).toBe(true);
+    expect(shouldRefreshNegotiatedMtu(23)).toBe(true);
+    expect(shouldRefreshNegotiatedMtu(185)).toBe(false);
+    expect(shouldRefreshNegotiatedMtu(247)).toBe(false);
+  });
+
   test('caps Android packet length by negotiated MTU payload', () => {
     expect(
       resolveProtocolV2PacketCapacity({
         platform: 'android',
-        androidPacketLength: 192,
+        androidPacketLength: 244,
         mtu: 100,
       })
     ).toBe(97);
   });
 
-  test('keeps iOS packet length controlled by tuning profile', () => {
+  test('keeps the default Android packet length within the validated ceiling', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'android',
+        mtu: 517,
+      })
+    ).toBe(244);
+  });
+
+  test('allows an explicit Android packet length override for validated experiments', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'android',
+        androidPacketLength: 514,
+        mtu: 517,
+      })
+    ).toBe(514);
+  });
+
+  test('caps iOS packet length by the system-negotiated write payload', () => {
     expect(
       resolveProtocolV2PacketCapacity({
         platform: 'ios',
@@ -39,4 +69,62 @@ describe('React Native BLE strategy', () => {
       })
     ).toBe(244);
   });
+
+  test('uses the reported iOS MTU without a compatibility fallback', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'ios',
+        iosPacketLength: 128,
+        mtu: 23,
+      })
+    ).toBe(20);
+  });
+
+  test('uses a smaller system-negotiated iOS write payload', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'ios',
+        iosPacketLength: 244,
+        mtu: 185,
+      })
+    ).toBe(182);
+  });
+
+  test('uses withoutResponse for a high-volume write unless explicitly overridden', () => {
+    const characteristic = {
+      isWritableWithResponse: true,
+      isWritableWithoutResponse: true,
+    };
+
+    expect(
+      shouldWriteProtocolV2WithResponse({
+        platform: 'ios',
+        highThroughput: true,
+        requestedWithResponse: false,
+        characteristic,
+      })
+    ).toBe(false);
+    expect(
+      shouldWriteProtocolV2WithResponse({
+        platform: 'ios',
+        highThroughput: true,
+        requestedWithResponse: true,
+        characteristic,
+      })
+    ).toBe(true);
+  });
+
+  test('falls back to withResponse when withoutResponse is unavailable', () => {
+    expect(
+      shouldWriteProtocolV2WithResponse({
+        platform: 'ios',
+        highThroughput: true,
+        requestedWithResponse: false,
+        characteristic: {
+          isWritableWithResponse: true,
+          isWritableWithoutResponse: false,
+        },
+      })
+    ).toBe(true);
+  });
 });