@onekeyfe/hd-transport 1.2.2-alpha.100 → 1.2.2-alpha.12

package/README.md

@@ -20,7 +20,7 @@ In order to be able to use new features of onekey-firmware you need to update pr
 1. `yarn update-submodules` to update firmware submodule
 1. `yarn update-protobuf` to generate new `./messages.json`, `./messages-protocol-v2.json` and `./src/types/messages.ts`
 
-The same task can be run from the repository root with `yarn update-protobuf`. The Protocol V2 schema requires the `firmware-pro2` submodule checked out on branch `dev`.
+The same task can be run from the repository root with `yarn update-protobuf`. The Protocol V2 schema requires the `firmware-pro2` submodule checked out on branch `main`.
 
 ## Docs
 

package/__tests__/messages.test.js

@@ -88,6 +88,31 @@ describe('messages', () => {
     });
   });
 
+  test('Protocol V2 firmware update progress matches firmware-pro2 main', () => {
+    expect(v2Messages.nested.MessageType.values).toMatchObject({
+      MessageType_DeviceFindMyTokenState: 60450,
+      MessageType_DeviceFindMyTokenUpdate: 60451,
+      MessageType_DeviceFindMyTokenStateGet: 60452,
+    });
+    expect(v2Messages.nested.DeviceFirmwareUpdatePhase.values).toEqual({
+      FW_MGMT_UPDATER_PHASE_PREPARE: 0,
+      FW_MGMT_UPDATER_PHASE_INSTALL: 1,
+      FW_MGMT_UPDATER_PHASE_VERIFY: 2,
+    });
+    expect(v2Messages.nested.DeviceFirmwareUpdateRequest.fields.reboot_after_update).toMatchObject({
+      id: 1,
+      type: 'bool',
+    });
+    expect(v2Messages.nested.DeviceFirmwareUpdateRecord.fields).toMatchObject({
+      progress_percent: { id: 11, type: 'uint32' },
+      phase_info: { id: 12, type: 'DeviceFirmwareUpdatePhaseInfo' },
+    });
+    expect(v2Messages.nested.DeviceFirmwareUpdateRecordFields.fields).toMatchObject({
+      progress_percent: { id: 11, type: 'bool' },
+      phase_info: { id: 12, type: 'bool' },
+    });
+  });
+
   test('Protocol V2 conflicting enums keep their own wire values', () => {
     expect(generatedTypes.ProtocolV2FailureType).toMatchObject({
       Failure_DataError: 4,
@@ -125,11 +150,6 @@ describe('messages', () => {
     expect(v2Messages.nested.DeviceSessionGet.fields).toEqual({
       session_id: { id: 1, type: 'bytes' },
       btc_test_address: { id: 2, type: 'string' },
-      seed_domains: {
-        id: 3,
-        rule: 'repeated',
-        type: 'DeviceSessionSeedDomain',
-      },
     });
     expect(v2Messages.nested.DeviceSessionSeedDomain.values).toEqual({
       SeedDomain_Standard: 1,
@@ -151,9 +171,14 @@ describe('messages', () => {
     expect(v2Messages.nested).not.toHaveProperty('DeviceWalletSelect');
     expect(v2Messages.nested).not.toHaveProperty('DeviceWalletType');
     expect(v2Messages.nested).not.toHaveProperty('DeviceHiddenWalletSelect');
-    expect(v2Messages.nested.DeviceSession.fields).toMatchObject({
+    expect(v2Messages.nested.DeviceSession.fields).toEqual({
       session_id: { id: 1, type: 'bytes' },
       btc_test_address: { id: 2, type: 'string' },
+      seed_domains: {
+        rule: 'repeated',
+        type: 'DeviceSessionSeedDomain',
+        id: 3,
+      },
     });
     expect(v2Messages.nested.DeviceSessionAskPin.fields.type).toMatchObject({
       id: 1,
@@ -170,6 +195,11 @@ describe('messages', () => {
           type: 'bool',
           id: 2,
         },
+        seed_domains: {
+          rule: 'repeated',
+          type: 'DeviceSessionSeedDomain',
+          id: 3,
+        },
       },
     });
     expect(v2Messages.nested.DeviceSessionAskPin_FailureSubCodes.values).toEqual({
@@ -187,38 +217,77 @@ describe('messages', () => {
     const messages = parseConfigure(v2Messages);
     const { Message } = createMessageFromName(messages, 'DeviceSessionAskPassphrase');
 
-    const standardWallet = encode(Message, { passphrase: '', on_device: false });
+    const standardWallet = encode(Message, {
+      passphrase: '',
+      on_device: false,
+      seed_domains: [],
+    });
     const onHost = Message.encode(
-      Message.create({ passphrase: 'host hidden wallet', on_device: false })
+      Message.create({
+        passphrase: 'host hidden wallet',
+        on_device: false,
+        seed_domains: [
+          generatedTypes.DeviceSessionSeedDomain.SeedDomain_Standard,
+          generatedTypes.DeviceSessionSeedDomain.SeedDomain_Cardano,
+        ],
+      })
+    ).finish();
+    const onDevice = Message.encode(
+      Message.create({
+        on_device: true,
+        seed_domains: [generatedTypes.DeviceSessionSeedDomain.SeedDomain_Standard],
+      })
     ).finish();
-    const onDevice = Message.encode(Message.create({ on_device: true })).finish();
 
     expect(standardWallet.toString('hex')).toBe('0a001000');
     expect(Buffer.from(onHost).toString('hex')).toBe(
-      '0a12686f73742068696464656e2077616c6c65741000'
+      '0a12686f73742068696464656e2077616c6c657410001a020102'
     );
-    expect(Buffer.from(onDevice).toString('hex')).toBe('1001');
+    expect(Buffer.from(onDevice).toString('hex')).toBe('10011a0101');
     expect(Message.decode(onHost)).toMatchObject({
       passphrase: 'host hidden wallet',
       on_device: false,
+      seed_domains: [
+        generatedTypes.DeviceSessionSeedDomain.SeedDomain_Standard,
+        generatedTypes.DeviceSessionSeedDomain.SeedDomain_Cardano,
+      ],
+    });
+    expect(Message.decode(onDevice)).toMatchObject({
+      on_device: true,
+      seed_domains: [generatedTypes.DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(Message.decode(onDevice)).toMatchObject({ on_device: true });
   });
 
-  test('Protocol V2 wallet recovery carries the expected wallet and seed domains on wire', () => {
+  test('Protocol V2 wallet recovery carries the expected wallet on wire', () => {
     const messages = parseConfigure(v2Messages);
     const { Message } = createMessageFromName(messages, 'DeviceSessionGet');
     const payload = encode(Message, {
       btc_test_address: 'tb1qwallet',
-      seed_domains: [
-        generatedTypes.DeviceSessionSeedDomain.SeedDomain_Standard,
-        generatedTypes.DeviceSessionSeedDomain.SeedDomain_Cardano,
-      ],
     });
 
-    expect(payload.toString('hex')).toBe('120a7462317177616c6c65741a020102');
+    expect(payload.toString('hex')).toBe('120a7462317177616c6c6574');
     expect(Message.decode(payload.toBuffer())).toMatchObject({
       btc_test_address: 'tb1qwallet',
+    });
+    expect(Message.decode(payload.toBuffer())).not.toHaveProperty('seed_domains');
+  });
+
+  test('Protocol V2 DeviceSession reports generated seed domains on wire', () => {
+    const messages = parseConfigure(v2Messages);
+    const { Message } = createMessageFromName(messages, 'DeviceSession');
+    const encoded = Message.encode(
+      Message.create({
+        btc_test_address: 'tb1qwallet',
+        seed_domains: [
+          generatedTypes.DeviceSessionSeedDomain.SeedDomain_Standard,
+          generatedTypes.DeviceSessionSeedDomain.SeedDomain_Cardano,
+        ],
+      })
+    ).finish();
+
+    expect(Buffer.from(encoded).toString('hex')).toBe('120a7462317177616c6c65741a020102');
+    expect(Message.decode(encoded)).toMatchObject({
+      btc_test_address: 'tb1qwallet',
       seed_domains: [
         generatedTypes.DeviceSessionSeedDomain.SeedDomain_Standard,
         generatedTypes.DeviceSessionSeedDomain.SeedDomain_Cardano,

package/__tests__/protocol-v2-link-manager.test.js

@@ -317,6 +317,76 @@ describe('ProtocolV2LinkManager', () => {
     ]);
   });
 
+  test('times out a queued call without sending it after the active call settles', async () => {
+    let releaseActiveRead;
+    let markActiveReadStarted;
+    const activeReadStarted = new Promise(resolve => {
+      markActiveReadStarted = resolve;
+    });
+    const activeReadBlocked = new Promise(resolve => {
+      releaseActiveRead = resolve;
+    });
+    const sentSeqs = [];
+    const success = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: 1, packetSrc: 0, seq: 1 }
+    );
+    let requestSeq = 0;
+    let readCount = 0;
+    const adapter = {
+      router: 1,
+      generation: 1,
+      prepareCall: jest.fn(),
+      writeFrame: jest.fn(frame => {
+        [, , , , , , requestSeq] = frame;
+        sentSeqs.push(requestSeq);
+        return Promise.resolve();
+      }),
+      readFrame: jest.fn(async () => {
+        readCount += 1;
+        if (readCount === 1) {
+          markActiveReadStarted();
+          await activeReadBlocked;
+        }
+        return rewriteSeq(success, requestSeq);
+      }),
+      reset: jest.fn(),
+      createTimeoutError: (name, timeoutMs) =>
+        new Error(`response timeout after ${timeoutMs}ms for ${name}`),
+    };
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+    const createAdapter = jest.fn(() => adapter);
+
+    const activeCall = manager.call('device-a', createAdapter, 'Ping', { message: 'active' });
+    await activeReadStarted;
+    const queuedCall = manager.call(
+      'device-a',
+      createAdapter,
+      'Ping',
+      { message: 'queued' },
+      { timeoutMs: 20 }
+    );
+
+    await expect(queuedCall).rejects.toThrow('response timeout after 20ms for Ping');
+    expect(sentSeqs).toEqual([1]);
+
+    releaseActiveRead();
+    await activeCall;
+    await expect(
+      manager.call('device-a', createAdapter, 'Ping', { message: 'after-timeout' })
+    ).resolves.toEqual({
+      type: 'Success',
+      message: { message: 'ok' },
+    });
+
+    expect(sentSeqs).toEqual([1, 2]);
+  });
+
   test('writes flow control while the active call is waiting for its response', async () => {
     const sentSeqs = [];
     let releaseRead;

package/__tests__/protocol-v2-usb-transport-base.test.js

@@ -217,7 +217,7 @@ describe('ProtocolV2UsbTransportBase', () => {
     expect(transport.nativeResets).toEqual([['device-a', 'USB reconnected']]);
   });
 
-  test('passes each queued call its own timeout context', async () => {
+  test('passes each queued call its remaining timeout context', async () => {
     const transport = new FakeUsbTransport();
     await transport.rotate('device-a');
 
@@ -226,12 +226,14 @@ describe('ProtocolV2UsbTransportBase', () => {
       transport.callDevice('device-a', 'second', 222),
     ]);
 
-    expect(transport.readContexts).toEqual([
+    expect(transport.readContexts.slice(0, 2)).toEqual([
       ['device-a', 111],
       ['device-a', 111],
-      ['device-a', 222],
-      ['device-a', 222],
     ]);
+    const secondCallTimeouts = transport.readContexts.slice(2).map(([, timeoutMs]) => timeoutMs);
+    expect(secondCallTimeouts[0]).toBeGreaterThan(0);
+    expect(secondCallTimeouts[0]).toBeLessThanOrEqual(222);
+    expect(secondCallTimeouts[1]).toBe(secondCallTimeouts[0]);
   });
 
   test('keeps a coalesced response buffered for the next call', async () => {

package/__tests__/protocol-v2.test.js

@@ -5,6 +5,7 @@ const {
   ProtocolV2LinkError,
   ProtocolV2SequenceCursor,
   ProtocolV2Session,
+  detectProtocolV2LinkDisabledError,
   hexToBytes,
   isProtocolV2HighThroughputCall,
   probeProtocolV2,
@@ -12,6 +13,7 @@ const {
 } = require('../src/protocols/v2/session');
 const protocolV2 = require('../src/protocols/v2');
 const {
+  PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
   PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE,
   PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
   PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS,
@@ -451,12 +453,13 @@ describe('Protocol V2 framing and session', () => {
     ).toThrow('Protocol V2 frame too large: 4201 > 4200');
   });
 
-  test('keeps optimized BLE firmware chunks inside the transport frame boundary', () => {
+  test('keeps optimized BLE fixed-path chunks inside the transport frame boundary', () => {
     const productionSchemas = {
       protocolV1: protocolV1Messages,
       protocolV2: productionProtocolV2Messages,
     };
-    const stagingPaths = [
+    const fixedPaths = [
+      'vol1:/wallpapers/wallpaper.okpkg',
       'vol0:/bootloader.bin',
       'vol0:/application_p1.bin',
       'vol0:/application_p2.bin',
@@ -467,7 +470,7 @@ describe('Protocol V2 framing and session', () => {
       'vol0:/se04.bin',
     ];
 
-    for (const path of stagingPaths) {
+    for (const path of fixedPaths) {
       const frame = ProtocolV2.encodeFrame(productionSchemas, 'FilesystemFileWrite', {
         file: {
           path,
@@ -484,6 +487,35 @@ describe('Protocol V2 framing and session', () => {
     }
   });
 
+  test('keeps the generic BLE chunk safe for the longest valid filesystem path', () => {
+    const productionSchemas = {
+      protocolV1: protocolV1Messages,
+      protocolV2: productionProtocolV2Messages,
+    };
+    const longestValidPath = `vol0:/${'a'.repeat(121)}`;
+    const encodeFileWrite = dataLength =>
+      ProtocolV2.encodeFrame(productionSchemas, 'FilesystemFileWrite', {
+        file: {
+          path: longestValidPath,
+          offset: 0xffffffff,
+          total_size: 0xffffffff,
+          data: new Uint8Array(dataLength),
+        },
+        overwrite: true,
+        append: true,
+        ui_percentage: 100,
+      });
+
+    expect(Buffer.byteLength(longestValidPath, 'utf8')).toBe(127);
+    expect(encodeFileWrite(PROTOCOL_V2_BLE_FILE_CHUNK_SIZE).length).toBeLessThanOrEqual(
+      PROTOCOL_V2_BLE_FRAME_MAX_BYTES
+    );
+    expect(encodeFileWrite(PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE).length).toBeGreaterThan(
+      PROTOCOL_V2_BLE_FRAME_MAX_BYTES
+    );
+    expect(encodeFileWrite(1885)).toHaveLength(PROTOCOL_V2_BLE_FRAME_MAX_BYTES);
+  });
+
   test('keeps bytes after the first complete frame for the next read', () => {
     const first = ProtocolV2.encodeFrame(schemas, 'ProtocolInfo', {
       version: 1,
@@ -1003,6 +1035,126 @@ describe('Protocol V2 framing and session', () => {
     expect(result).toEqual({ type: 'WriteCompleted', message: {} });
   });
 
+  test('session consumes a delayed write-only response without completing the next call', async () => {
+    const requestSuccess = ProtocolV2.encodeFrame(schemas, 'Success', {
+      message: 'install accepted',
+    });
+    const statusResponse = ProtocolV2.encodeFrame(schemas, 'DeviceFirmwareUpdateStatus', {
+      records: [{ target_id: 6, status: 1, path: 'vol0:/coprocessor.bin' }],
+    });
+    const prepareCall = jest.fn();
+    const onResponseAfterWrite = jest.fn();
+    const readFrame = jest
+      .fn()
+      .mockResolvedValueOnce(rewriteSeq(requestSuccess, 1))
+      .mockResolvedValueOnce(rewriteSeq(statusResponse, 2));
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      prepareCall,
+      writeFrame: () => Promise.resolve(),
+      readFrame,
+    });
+
+    await expect(
+      session.call(
+        'DeviceFirmwareUpdateRequest',
+        {},
+        {
+          returnAfterWrite: true,
+          expectedTypes: ['Success'],
+          onResponseAfterWrite,
+        }
+      )
+    ).resolves.toEqual({ type: 'WriteCompleted', message: {} });
+
+    await expect(
+      session.call(
+        'Ping',
+        { message: 'status-poll' },
+        {
+          expectedTypes: ['DeviceFirmwareUpdateStatus'],
+        }
+      )
+    ).resolves.toMatchObject({
+      type: 'DeviceFirmwareUpdateStatus',
+      message: {
+        records: [{ target_id: 6, status: 1, path: 'vol0:/coprocessor.bin' }],
+      },
+    });
+
+    expect(prepareCall).toHaveBeenCalledTimes(1);
+    expect(onResponseAfterWrite).toHaveBeenCalledWith({
+      type: 'Success',
+      message: { message: 'install accepted' },
+    });
+    expect(readFrame).toHaveBeenCalledTimes(2);
+  });
+
+  test('session preserves a delayed write-only Failure for the next caller', async () => {
+    const requestFailure = ProtocolV2.encodeFrame(schemas, 'Failure', {
+      code: 4,
+      message: 'install cancelled',
+    });
+    const prepareCall = jest.fn();
+    const onResponseAfterWrite = jest.fn();
+    const readFrame = jest.fn().mockResolvedValueOnce(rewriteSeq(requestFailure, 1));
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      prepareCall,
+      writeFrame: () => Promise.resolve(),
+      readFrame,
+    });
+
+    await expect(
+      session.call(
+        'DeviceFirmwareUpdateRequest',
+        {},
+        {
+          returnAfterWrite: true,
+          expectedTypes: ['Success'],
+          onResponseAfterWrite,
+        }
+      )
+    ).resolves.toEqual({ type: 'WriteCompleted', message: {} });
+
+    await expect(
+      session.call(
+        'Ping',
+        { message: 'status-poll' },
+        {
+          expectedTypes: ['DeviceFirmwareUpdateStatus'],
+        }
+      )
+    ).resolves.toMatchObject({
+      type: 'Failure',
+      message: {
+        code: 4,
+        message: 'install cancelled',
+      },
+    });
+
+    expect(prepareCall).toHaveBeenCalledTimes(1);
+    expect(onResponseAfterWrite).not.toHaveBeenCalled();
+    expect(readFrame).toHaveBeenCalledTimes(1);
+  });
+
+  test('probeProtocolV2 rethrows caller-selected fatal errors without treating them as a miss', async () => {
+    const onProbeFailed = jest.fn();
+    const staleBond = Object.assign(new Error('Bluetooth pairing failed'), { errorCode: 715 });
+
+    await expect(
+      probeProtocolV2({
+        call: () => Promise.reject(staleBond),
+        timeoutMs: 1,
+        onProbeFailed,
+        shouldRethrow: error => error?.errorCode === 715,
+      })
+    ).rejects.toBe(staleBond);
+    expect(onProbeFailed).not.toHaveBeenCalled();
+  });
+
   test('probeProtocolV2 accepts Success as a normal V2 probe response', async () => {
     await expect(
       probeProtocolV2({
@@ -1025,6 +1177,36 @@ describe('Protocol V2 framing and session', () => {
     expect(isProtocolV2LinkDisabledFailure('Failure_ProcessError', 'busy')).toBe(false);
   });
 
+  test('detects a split Protocol V2 link-disabled frame in the shared transport layer', () => {
+    const assembler = new ProtocolV2FrameAssembler();
+    const frame = ProtocolV2.encodeFrame(
+      schemas,
+      'Failure',
+      { code: 5, message: 'link disabled' },
+      { router: 2 }
+    );
+    const splitAt = 4;
+
+    expect(
+      detectProtocolV2LinkDisabledError({
+        schemas,
+        assembler,
+        bytes: frame.subarray(0, splitAt),
+      })
+    ).toBeUndefined();
+    expect(
+      detectProtocolV2LinkDisabledError({
+        schemas,
+        assembler,
+        bytes: frame.subarray(splitAt),
+      })
+    ).toMatchObject({
+      name: 'ProtocolV2LinkDisabledError',
+      failureCode: 5,
+      firmwareMessage: 'link disabled',
+    });
+  });
+
   test.each(['Failure_ProcessError', 5])(
     'probeProtocolV2 surfaces link disabled without resetting the link for code %s',
     async code => {