@onekeyfe/hd-transport 1.2.0-alpha.99 → 1.2.1-alpha.0

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,

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

@@ -26,6 +26,9 @@ const protocolV2Messages = parseConfigure({
         message: { type: 'string', id: 1 },
       },
     },
+    Cancel: {
+      fields: {},
+    },
     Success: {
       fields: {
         message: { type: 'string', id: 1 },
@@ -35,6 +38,7 @@ const protocolV2Messages = parseConfigure({
       values: {
         MessageType_Ping: 60206,
         MessageType_Success: 60207,
+        MessageType_Cancel: 60004,
       },
     },
   },
@@ -313,6 +317,128 @@ 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;
+    let markReadStarted;
+    const readStarted = new Promise(resolve => {
+      markReadStarted = resolve;
+    });
+    const readBlocked = new Promise(resolve => {
+      releaseRead = resolve;
+    });
+    const success = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: 1, packetSrc: 0, seq: 1 }
+    );
+    let requestSeq = 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 () => {
+        markReadStarted();
+        await readBlocked;
+        return rewriteSeq(success, 1);
+      }),
+      reset: jest.fn(),
+    };
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+    const createAdapter = jest.fn(() => adapter);
+
+    const activeCall = manager.call('device-a', createAdapter, 'Ping', { message: 'pending' });
+    await readStarted;
+    await expect(manager.sendFlowControl('device-a', createAdapter, 'Cancel', {})).resolves.toEqual(
+      { type: 'WriteCompleted', message: {} }
+    );
+
+    expect(sentSeqs).toEqual([1, 2]);
+    expect(adapter.prepareCall).toHaveBeenCalledTimes(1);
+    expect(adapter.readFrame).toHaveBeenCalledTimes(1);
+    releaseRead();
+    await activeCall;
+  });
+
   test('keeps a recoverable link after a call error', async () => {
     const sentSeqs = [];
     const { adapters, createAdapter } = createAdapterFactory(sentSeqs);

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,9 +5,11 @@ const {
   ProtocolV2LinkError,
   ProtocolV2SequenceCursor,
   ProtocolV2Session,
+  detectProtocolV2LinkDisabledError,
   hexToBytes,
   isProtocolV2HighThroughputCall,
   probeProtocolV2,
+  isProtocolV2LinkDisabledFailure,
 } = require('../src/protocols/v2/session');
 const protocolV2 = require('../src/protocols/v2');
 const {
@@ -137,7 +139,7 @@ const protocolV2Messages = parseConfigure({
         },
       },
     },
-    DeviceFirmwareUpdateRequest: {
+    DeviceFirmwareUpdateStage: {
       fields: {
         targets: {
           type: 'DeviceFirmwareTarget',
@@ -146,6 +148,9 @@ const protocolV2Messages = parseConfigure({
         },
       },
     },
+    DeviceFirmwareUpdateRequest: {
+      fields: {},
+    },
     DeviceFirmwareUpdateRecord: {
       fields: {
         target_id: {
@@ -218,7 +223,8 @@ const protocolV2Messages = parseConfigure({
         MessageType_Success: 60207,
         MessageType_Failure: 60208,
         MessageType_FileWrite: 60805,
-        MessageType_DeviceFirmwareUpdateRequest: 61000,
+        MessageType_DeviceFirmwareUpdateStage: 61000,
+        MessageType_DeviceFirmwareUpdateRequest: 61001,
         MessageType_DeviceFirmwareUpdateStatus: 61002,
         MessageType_DeviceSession: 61201,
         MessageType_PartialNested: 62000,
@@ -233,6 +239,32 @@ const schemas = {
 };
 const productionProtocolV2Messages = parseConfigure(require('../messages-protocol-v2.json'));
 
+const legacyProtocolInfoMessage = parseConfigure({
+  nested: {
+    ProtocolInfo: {
+      fields: {
+        version: {
+          type: 'uint32',
+          id: 1,
+          rule: 'required',
+        },
+        supported_messages: {
+          type: 'uint32',
+          id: 2,
+          rule: 'repeated',
+          options: {
+            packed: false,
+          },
+        },
+        protobuf_definition: {
+          type: 'string',
+          id: 3,
+        },
+      },
+    },
+  },
+}).lookupType('ProtocolInfo');
+
 const rewriteSeq = (frame, seq) => {
   const copy = new Uint8Array(frame);
   copy[4] = 1;
@@ -267,6 +299,64 @@ describe('Protocol V2 framing and session', () => {
     });
   });
 
+  test('decodes a two-byte legacy ProtocolInfo at the generic frame boundary', () => {
+    const frame = protocolV2.encodeProtobufFrame(60201, new Uint8Array([0x08, 0x01]));
+    const productionSchemas = {
+      protocolV1: protocolV1Messages,
+      protocolV2: productionProtocolV2Messages,
+    };
+
+    expect(ProtocolV2.decodeFrame(productionSchemas, frame)).toMatchObject({
+      type: 'ProtocolInfo',
+      message: {
+        version: 1,
+        build_fingerprint: '',
+        supported_messages: [],
+        protobuf_definition: null,
+      },
+    });
+  });
+
+  test('does not reinterpret a malformed current ProtocolInfo as the legacy layout', () => {
+    const frame = protocolV2.encodeProtobufFrame(60201, new Uint8Array([0x08, 0x01, 0x18, 0x01]));
+
+    expect(() =>
+      ProtocolV2.decodeFrame(
+        {
+          protocolV1: protocolV1Messages,
+          protocolV2: productionProtocolV2Messages,
+        },
+        frame
+      )
+    ).toThrow('Protocol V2 protobuf decode failed for "ProtocolInfo"');
+  });
+
+  test('preserves legacy ProtocolInfo capabilities when using the old field numbers', () => {
+    const payload = legacyProtocolInfoMessage
+      .encode({
+        version: 1,
+        supported_messages: [60602],
+        protobuf_definition: 'legacy',
+      })
+      .finish();
+    const frame = protocolV2.encodeProtobufFrame(60201, payload);
+
+    const decoded = ProtocolV2.decodeFrame(
+      {
+        protocolV1: protocolV1Messages,
+        protocolV2: productionProtocolV2Messages,
+      },
+      frame
+    );
+
+    expect(decoded.message).toEqual({
+      version: 1,
+      build_fingerprint: '',
+      supported_messages: [60602],
+      protobuf_definition: null,
+    });
+  });
+
   test('does not encode V1-only messages into Protocol V2 frames', () => {
     expect(() => ProtocolV2.encodeFrame(schemas, 'Ping', { message: 'ok' })).not.toThrow();
     expect(() => ProtocolV2.encodeFrame(schemas, 'OnekeyGetFeatures', {})).toThrow(
@@ -446,6 +536,38 @@ describe('Protocol V2 framing and session', () => {
     });
   });
 
+  test('session decodes legacy ProtocolInfo through the generic frame boundary', async () => {
+    const productionSchemas = {
+      protocolV1: protocolV1Messages,
+      protocolV2: productionProtocolV2Messages,
+    };
+    const response = protocolV2.encodeProtobufFrame(60201, new Uint8Array([0x08, 0x01]));
+    const session = new ProtocolV2Session({
+      schemas: productionSchemas,
+      router: 1,
+      writeFrame: () => Promise.resolve(),
+      readFrame: () => Promise.resolve(rewriteSeq(response, 1)),
+    });
+
+    await expect(
+      session.call(
+        'ProtocolInfoRequest',
+        { eventless_wallet_session: true },
+        {
+          expectedTypes: ['ProtocolInfo'],
+        }
+      )
+    ).resolves.toEqual({
+      type: 'ProtocolInfo',
+      message: {
+        version: 1,
+        build_fingerprint: '',
+        supported_messages: [],
+        protobuf_definition: null,
+      },
+    });
+  });
+
   test('session does not log Protocol V2 TX and RX frames', async () => {
     const written = [];
     const logger = { debug: jest.fn() };
@@ -850,24 +972,10 @@ describe('Protocol V2 framing and session', () => {
     expect(logger.debug).toHaveBeenCalledWith(expect.stringContaining('skip unexpected response'));
   });
 
-  test('session consumes intermediate response frames before returning the final response', async () => {
+  test('session can return after a request frame is written', async () => {
     const written = [];
-    const progress = ProtocolV2.encodeFrame(schemas, 'DeviceFirmwareUpdateStatus', {
-      records: [{ target_id: 4, status: 1 }],
-    });
-    const success = ProtocolV2.encodeFrame(schemas, 'Success', {
-      message: 'ok',
-    });
-    const onIntermediateResponse = jest.fn();
-    const readFrame = jest.fn(() => {
-      const [writtenFrame] = written;
-      const { seq } = protocolV2.decodeFrame(writtenFrame);
-      return Promise.resolve(
-        readFrame.mock.calls.length === 1
-          ? rewriteSeq(progress, seq)
-          : rewriteSeq(success, protocolV2.nextProtoSeq(seq))
-      );
-    });
+    const readFrame = jest.fn();
+    const onWriteCompleted = jest.fn();
     const session = new ProtocolV2Session({
       schemas,
       router: 1,
@@ -880,26 +988,140 @@ describe('Protocol V2 framing and session', () => {
 
     const result = await session.call(
       'DeviceFirmwareUpdateRequest',
-      { targets: [{ target_id: 4, path: 'vol1:firmware.bin' }] },
+      {},
       {
-        intermediateTypes: ['DeviceFirmwareUpdateStatus'],
-        onIntermediateResponse,
+        returnAfterWrite: true,
+        onWriteCompleted,
       }
     );
 
-    expect(readFrame).toHaveBeenCalledTimes(2);
-    expect(onIntermediateResponse).toHaveBeenCalledWith({
+    expect(written).toHaveLength(1);
+    expect(ProtocolV2.decodeFrame(schemas, written[0]).messageName).toBe(
+      'DeviceFirmwareUpdateRequest'
+    );
+    expect(readFrame).not.toHaveBeenCalled();
+    expect(onWriteCompleted).toHaveBeenCalledTimes(1);
+    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: 4, status: 1, payload_version: null, path: null }],
+        records: [{ target_id: 6, status: 1, path: 'vol0:/coprocessor.bin' }],
       },
     });
-    expect(result).toEqual({
+
+    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: {
-        message: 'ok',
+        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 () => {
@@ -918,6 +1140,66 @@ describe('Protocol V2 framing and session', () => {
     ).resolves.toBe(false);
   });
 
+  test('recognizes USB-priority firmware failures independently of surrounding whitespace', () => {
+    expect(isProtocolV2LinkDisabledFailure('Failure_ProcessError', ' link disabled ')).toBe(true);
+    expect(isProtocolV2LinkDisabledFailure(5, 'Link Disabled')).toBe(true);
+    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 => {
+      const onProbeFailed = jest.fn();
+
+      await expect(
+        probeProtocolV2({
+          call: () =>
+            Promise.resolve({
+              type: 'Failure',
+              message: { code, message: ' link disabled ' },
+            }),
+          timeoutMs: 1,
+          onProbeFailed,
+        })
+      ).rejects.toMatchObject({
+        name: 'ProtocolV2LinkDisabledError',
+        failureCode: code,
+        firmwareMessage: ' link disabled ',
+      });
+      expect(onProbeFailed).not.toHaveBeenCalled();
+    }
+  );
+
   test('decodeFrame rejects frames that are too short', () => {
     expect(() => protocolV2.decodeFrame(new Uint8Array([0x5a, 0x08, 0x00]))).toThrow(
       'Protocol V2 frame too short'