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

package/__tests__/build-receive.test.js

@@ -1,7 +1,5 @@
 const { parseConfigure } = require('../src/serialization/protobuf/messages');
-const { buildOne } = require('../src/serialization/send');
-const { receiveOne } = require('../src/serialization/receive');
-const { buildEncodeBuffers } = require('../src/serialization/send');
+const { ProtocolV1 } = require('../src/protocols');
 
 const messages = {
   StellarPaymentOp: {
@@ -96,17 +94,17 @@ const parsedMessages = parseConfigure({
 describe('encoding json -> protobuf -> json', () => {
   fixtures.forEach(f => {
     describe(f.name, () => {
-      test('buildOne - receiveOne', () => {
+      test('encodeEnvelope - decodeMessage', () => {
         // encoded message
-        const encodedMessage = buildOne(parsedMessages, f.name, f.in);
+        const encodedMessage = ProtocolV1.encodeEnvelope(parsedMessages, f.name, f.in);
         // then decode message and check, whether decoded message matches original json
-        const decodedMessage = receiveOne(parsedMessages, encodedMessage);
+        const decodedMessage = ProtocolV1.decodeMessage(parsedMessages, encodedMessage);
         expect(decodedMessage.type).toEqual(f.name);
         expect(decodedMessage.message).toEqual(f.in);
       });
 
-      test('buildBuffers - receiveAndParse', () => {
-        const result = buildEncodeBuffers(parsedMessages, f.name, f.in);
+      test('encodeMessageChunks - receiveAndParse', () => {
+        const result = ProtocolV1.encodeMessageChunks(parsedMessages, f.name, f.in);
         result.forEach(r => {
           expect(r.byteLength).toBeLessThanOrEqual(63);
         });

package/__tests__/decode-features.test.js

@@ -1,8 +1,9 @@
+/* eslint-disable import/order */
 const ProtoBuf = require('protobufjs/light');
 const ByteBuffer = require('bytebuffer');
 
 const { decode } = require('../src/serialization/protobuf/decode');
-const { decode: decodeProtocol } = require('../src/serialization/protocol/decode');
+const { decodeEnvelope } = require('../src/protocols/v1/decode');
 
 // Reuse the messages.json already committed alongside @onekeyfe/hd-core
 // (runtime data for DataManager). hd-transport's own messages.json is
@@ -61,7 +62,7 @@ describe('Fix messages decode', () => {
       test('decode', () => {
         // deserialize
         const encoded = ByteBuffer.fromHex(f.encodeMessage);
-        const { buffer } = decodeProtocol(encoded);
+        const { buffer } = decodeEnvelope(encoded);
         const decoded = decode(Message, buffer);
 
         // filter null values

package/__tests__/messages.test.js

@@ -3,6 +3,11 @@ const {
   createMessageFromType,
   parseConfigure,
 } = require('../src/serialization/protobuf/messages');
+const v1Messages = require('../../core/src/data/messages/messages.json');
+const v2Messages = require('../messages-protocol-v2.json');
+const coreV2Messages = require('../../core/src/data/messages/messages-protocol-v2.json');
+const generatedTypes = require('../src/types/messages');
+
 // const json = require('./data/messages.json');
 
 const json = {
@@ -58,6 +63,116 @@ const json = {
 };
 
 describe('messages', () => {
+  test('V1 GetPassphraseState matches the current firmware schema', () => {
+    const { fields } = v1Messages.nested.GetPassphraseState;
+
+    expect(fields.passphrase_state).toMatchObject({ id: 1, type: 'string' });
+    expect(fields).not.toHaveProperty('_only_main_pin');
+    expect(fields).not.toHaveProperty('allow_create_attach_pin');
+  });
+
+  test('Protocol V2 firmware targets match the current firmware-pro2 enum', () => {
+    expect(v2Messages.nested.DeviceFirmwareTargetType.values).toEqual({
+      FW_MGMT_TARGET_INVALID: 0,
+      FW_MGMT_TARGET_CRATE: 1,
+      FW_MGMT_TARGET_ROMLOADER: 2,
+      FW_MGMT_TARGET_BOOTLOADER: 3,
+      FW_MGMT_TARGET_APPLICATION_P1: 4,
+      FW_MGMT_TARGET_APPLICATION_P2: 5,
+      FW_MGMT_TARGET_COPROCESSOR: 6,
+      FW_MGMT_TARGET_SE01: 7,
+      FW_MGMT_TARGET_SE02: 8,
+      FW_MGMT_TARGET_SE03: 9,
+      FW_MGMT_TARGET_SE04: 10,
+    });
+  });
+
+  test('Protocol V2 conflicting enums keep their own wire values', () => {
+    expect(generatedTypes.ProtocolV2FailureType).toMatchObject({
+      Failure_DataError: 4,
+      Failure_ProcessError: 5,
+    });
+    expect(generatedTypes.Enum_ProtocolV2Capability).toMatchObject({
+      Capability_AttachToPin: 18,
+    });
+  });
+
+  test('Protocol V2 device status and session messages match firmware-pro2', () => {
+    expect(v2Messages.nested.MessageType.values).toMatchObject({
+      MessageType_DeviceStatusGet: 60602,
+      MessageType_DeviceStatus: 60603,
+      MessageType_DeviceSessionOpen: 60606,
+      MessageType_DeviceSession: 60607,
+      MessageType_DeviceSessionAskPin: 60608,
+    });
+    expect(v2Messages.nested.DeviceStatusGet).toEqual({ fields: {} });
+    expect(v2Messages.nested.DeviceSessionResume.fields.session_id).toMatchObject({
+      id: 1,
+      type: 'bytes',
+    });
+    expect(v2Messages.nested.DeviceWalletSelect.oneofs.access.oneof).toEqual([
+      'host_passphrase',
+      'passphrase_on_device',
+      'attach_pin_on_device',
+    ]);
+    expect(v2Messages.nested.DeviceSessionOpen.oneofs.mode.oneof).toEqual(['resume', 'select']);
+    expect(v2Messages.nested).not.toHaveProperty('DeviceWalletType');
+    expect(v2Messages.nested).not.toHaveProperty('DeviceHiddenWalletSelect');
+    expect(v2Messages.nested.DeviceSession.fields).toMatchObject({
+      session_id: { id: 1, type: 'bytes' },
+      btc_test_address: { id: 2, type: 'string' },
+    });
+    expect(v2Messages.nested.DeviceSessionAskPin).toEqual({ fields: {} });
+    expect(v2Messages.nested.DeviceSessionAskPin_FailureSubCodes.values).toEqual({
+      UserCancel: 1,
+    });
+    expect(v2Messages.nested.MessageType.values).not.toHaveProperty(
+      'MessageType_DeviceSessionPinResult'
+    );
+    expect(v2Messages.nested.MessageType.values).not.toHaveProperty('MessageType_DeviceSessionGet');
+  });
+
+  test('Protocol V2 onboarding status matches the current firmware-pro2 schema', () => {
+    expect(v2Messages.nested.DevOnboardingStep.values).toMatchObject({
+      DEV_ONBOARDING_STEP_UNKNOWN: 0,
+      DEV_ONBOARDING_STEP_CHECKING: 1,
+      DEV_ONBOARDING_STEP_PERSONALIZATION: 2,
+      DEV_ONBOARDING_STEP_PIN: 3,
+      DEV_ONBOARDING_STEP_SETUP: 4,
+      DEV_ONBOARDING_STEP_DONE: 5,
+    });
+    expect(v2Messages.nested.DevOnboardingPhase.values).toBeDefined();
+    expect(v2Messages.nested.DevOnboardingSetupKind.values).toBeDefined();
+    expect(v2Messages.nested.DevOnboardingSetupMethod.values).toBeDefined();
+    expect(v2Messages.nested.DevOnboardingSetupStatus.fields).toMatchObject({
+      kind: { id: 1, type: 'DevOnboardingSetupKind' },
+      method: { id: 2, type: 'DevOnboardingSetupMethod' },
+    });
+    expect(v2Messages.nested.DevOnboardingStatus.fields).toMatchObject({
+      step: { id: 1, type: 'DevOnboardingStep' },
+      phase: { id: 2, type: 'DevOnboardingPhase' },
+      setup: { id: 3, type: 'DevOnboardingSetupStatus' },
+      pin_set: { id: 4, type: 'bool' },
+      wallet_initialized: { id: 5, type: 'bool' },
+    });
+    expect(v2Messages.nested).not.toHaveProperty('DevOnboardingStage');
+  });
+
+  test('Protocol V2 does not restore retired unlock or passphrase ids', () => {
+    expect(v2Messages.nested.MessageType.values).not.toHaveProperty('MessageType_UnLockDevice');
+    expect(v2Messages.nested.MessageType.values).not.toHaveProperty(
+      'MessageType_UnLockDeviceResponse'
+    );
+    expect(v2Messages.nested.MessageType.values).not.toHaveProperty(
+      'MessageType_GetPassphraseState'
+    );
+    expect(v2Messages.nested.MessageType.values).not.toHaveProperty('MessageType_PassphraseState');
+  });
+
+  test('Protocol V2 transport and core schemas stay identical', () => {
+    expect(coreV2Messages).toEqual(v2Messages);
+  });
+
   test('createMessageFromName (common case)', () => {
     const messages = parseConfigure(json);
     const name = 'Initialize';
@@ -70,6 +185,14 @@ describe('messages', () => {
     expect(() => createMessageFromType(messages, 0)).not.toThrow();
   });
 
+  test('createMessageFromType throws a readable error for unknown ids', () => {
+    const messages = parseConfigure(json);
+
+    expect(() => createMessageFromType(messages, 99999)).toThrow(
+      'MessageType id "99999" is not defined in protobuf schema'
+    );
+  });
+
   test('createMessageFromName (wire_type case)', () => {
     const messages = parseConfigure(json);
     const name = 'TxAckInput';
@@ -83,4 +206,12 @@ describe('messages', () => {
 
     expect(() => createMessageFromName(messages, name)).not.toThrow();
   });
+
+  test('createMessageFromName throws when message type id is missing', () => {
+    const messages = parseConfigure(json);
+
+    expect(() => createMessageFromName(messages, 'TxAckInputWrapper')).toThrow(
+      'MessageType for "TxAckInputWrapper" is not defined in protobuf schema'
+    );
+  });
 });

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

@@ -0,0 +1,351 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { ProtocolV2, ProtocolV2LinkManager } = require('../src');
+const { parseConfigure } = require('../src/serialization/protobuf/messages');
+const protocolV2 = require('../src/protocols/v2');
+
+const protocolV1Messages = parseConfigure({
+  nested: {
+    Failure: {
+      fields: {
+        code: { type: 'uint32', id: 1 },
+        message: { type: 'string', id: 2 },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Failure: 3,
+      },
+    },
+  },
+});
+
+const protocolV2Messages = parseConfigure({
+  nested: {
+    Ping: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    Success: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+      },
+    },
+  },
+});
+
+const schemas = {
+  protocolV1: protocolV1Messages,
+  protocolV2: protocolV2Messages,
+};
+
+const rewriteSeq = (frame, seq) => {
+  const copy = new Uint8Array(frame);
+  copy[6] = seq;
+  copy[copy.length - 1] = protocolV2.crc8(copy, copy.length - 1);
+  return copy;
+};
+
+const createAdapterFactory = sentSeqs => {
+  const adapters = [];
+  let generation = 0;
+  const success = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+
+  return {
+    adapters,
+    createAdapter: () => {
+      let requestSeq = 0;
+      const adapter = {
+        router: 1,
+        generation: ++generation,
+        prepareCall: jest.fn(),
+        writeFrame: jest.fn(frame => {
+          const [, , , , , , seq] = frame;
+          requestSeq = seq;
+          sentSeqs.push(requestSeq);
+          return Promise.resolve();
+        }),
+        readFrame: jest.fn(() => Promise.resolve(rewriteSeq(success, requestSeq))),
+        reset: jest.fn(() => Promise.resolve()),
+      };
+      adapters.push(adapter);
+      return adapter;
+    },
+  };
+};
+
+describe('ProtocolV2LinkManager', () => {
+  test('retains the device sequence cursor when an active link is rebuilt', async () => {
+    const sentSeqs = [];
+    const { adapters, createAdapter } = createAdapterFactory(sentSeqs);
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+
+    await manager.call('device-a', createAdapter, 'Ping', { message: '1' });
+    await manager.invalidateLink('device-a', 'reconnect');
+    await manager.call('device-a', createAdapter, 'Ping', { message: '2' });
+
+    expect(sentSeqs).toEqual([1, 2]);
+    expect(adapters).toHaveLength(2);
+    expect(adapters[0].reset).toHaveBeenCalledWith('reconnect');
+  });
+
+  test('prepares the active adapter with the same call context used for frame IO', async () => {
+    const sentSeqs = [];
+    const { adapters, createAdapter } = createAdapterFactory(sentSeqs);
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+
+    await manager.call('device-a', createAdapter, 'Ping', { message: '1' }, { timeoutMs: 123 });
+
+    expect(adapters[0].prepareCall).toHaveBeenCalledWith({
+      messageName: 'Ping',
+      timeoutMs: 123,
+      highVolume: false,
+      generation: 1,
+    });
+  });
+
+  test('invalidates a link-fatal call before the next call creates a new link', async () => {
+    const sentSeqs = [];
+    const onLinkInvalidated = jest.fn();
+    const { adapters, createAdapter: createWorkingAdapter } = createAdapterFactory(sentSeqs);
+    const createAdapter = jest
+      .fn()
+      .mockImplementationOnce(() => {
+        const adapter = createWorkingAdapter();
+        adapter.writeFrame.mockImplementationOnce(frame => {
+          sentSeqs.push(frame[6]);
+          return Promise.reject(new Error('transport write failed'));
+        });
+        return adapter;
+      })
+      .mockImplementation(() => createWorkingAdapter());
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'link-fatal',
+      onLinkInvalidated,
+    });
+
+    await expect(manager.call('device-a', createAdapter, 'Ping', { message: '1' })).rejects.toThrow(
+      'transport write failed'
+    );
+    await expect(
+      manager.call('device-a', createAdapter, 'Ping', { message: '2' })
+    ).resolves.toEqual({
+      type: 'Success',
+      message: { message: 'ok' },
+    });
+
+    expect(createAdapter).toHaveBeenCalledTimes(2);
+    expect(adapters[0].reset).toHaveBeenCalledWith(
+      expect.stringContaining('transport write failed')
+    );
+    expect(onLinkInvalidated).toHaveBeenCalledWith(
+      'device-a',
+      expect.stringContaining('transport write failed')
+    );
+    expect(sentSeqs).toEqual([1, 2]);
+  });
+
+  test('times out a stalled write and resets the link before releasing the call queue', async () => {
+    const adapter = {
+      router: 1,
+      generation: 1,
+      prepareCall: jest.fn(),
+      writeFrame: jest.fn(() => new Promise(() => {})),
+      readFrame: jest.fn(),
+      reset: jest.fn(() => Promise.resolve()),
+      writeTimeoutMs: 10,
+    };
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: error =>
+        String(error).includes('write timeout') ? 'link-fatal' : 'recoverable',
+    });
+
+    await expect(
+      manager.call('device-a', () => adapter, 'Ping', { message: 'pending' })
+    ).rejects.toThrow('Protocol V2 write timeout after 10ms for Ping');
+
+    expect(adapter.reset).toHaveBeenCalledWith(expect.stringContaining('write timeout'));
+    expect(adapter.readFrame).not.toHaveBeenCalled();
+    expect(manager.callQueues.size).toBe(0);
+  });
+
+  test('invalidates every active link while retaining per-device cursors', async () => {
+    const sentSeqs = [];
+    const { adapters, createAdapter } = createAdapterFactory(sentSeqs);
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+
+    await manager.call('device-a', createAdapter, 'Ping', { message: 'a1' });
+    await manager.call('device-b', createAdapter, 'Ping', { message: 'b1' });
+    await manager.invalidateAllLinks('schema changed');
+    await manager.call('device-a', createAdapter, 'Ping', { message: 'a2' });
+    await manager.call('device-b', createAdapter, 'Ping', { message: 'b2' });
+
+    expect(sentSeqs).toEqual([1, 1, 2, 2]);
+    expect(adapters).toHaveLength(4);
+    expect(adapters[0].reset).toHaveBeenCalledWith('schema changed');
+    expect(adapters[1].reset).toHaveBeenCalledWith('schema changed');
+  });
+
+  test('dispose clears active links and sequence cursors', async () => {
+    const sentSeqs = [];
+    const { adapters, createAdapter } = createAdapterFactory(sentSeqs);
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+
+    await manager.call('device-a', createAdapter, 'Ping', { message: '1' });
+    await manager.dispose('transport disposed');
+    await manager.call('device-a', createAdapter, 'Ping', { message: '2' });
+
+    expect(sentSeqs).toEqual([1, 1]);
+    expect(adapters[0].reset).toHaveBeenCalledWith('transport disposed');
+  });
+
+  test('serializes calls per device without blocking another device', async () => {
+    const events = [];
+    let releaseDeviceA;
+    const deviceABlocked = new Promise(resolve => {
+      releaseDeviceA = resolve;
+    });
+    const success = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+    const createAdapter = key => {
+      let requestSeq = 0;
+      return {
+        router: 1,
+        generation: 1,
+        prepareCall: jest.fn(),
+        writeFrame: jest.fn(frame => {
+          const [, , , , , , seq] = frame;
+          requestSeq = seq;
+          events.push(`write:${key}:${requestSeq}`);
+          return Promise.resolve();
+        }),
+        readFrame: jest.fn(async () => {
+          if (key === 'device-a' && requestSeq === 1) {
+            await deviceABlocked;
+          }
+          events.push(`read:${key}:${requestSeq}`);
+          return rewriteSeq(success, requestSeq);
+        }),
+        reset: jest.fn(),
+      };
+    };
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+
+    const firstA = manager.call('device-a', () => createAdapter('device-a'), 'Ping', {
+      message: 'a1',
+    });
+    const secondA = manager.call('device-a', () => createAdapter('device-a'), 'Ping', {
+      message: 'a2',
+    });
+    const firstB = manager.call('device-b', () => createAdapter('device-b'), 'Ping', {
+      message: 'b1',
+    });
+
+    await firstB;
+    expect(events).toEqual(['write:device-a:1', 'write:device-b:1', 'read:device-b:1']);
+    releaseDeviceA();
+    await Promise.all([firstA, secondA]);
+    expect(events).toEqual([
+      'write:device-a:1',
+      'write:device-b:1',
+      'read:device-b:1',
+      'read:device-a:1',
+      'write:device-a:2',
+      'read:device-a:2',
+    ]);
+  });
+
+  test('keeps a recoverable link after a call error', async () => {
+    const sentSeqs = [];
+    const { adapters, createAdapter } = createAdapterFactory(sentSeqs);
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+    const adapter = createAdapter();
+    adapter.writeFrame.mockImplementationOnce(frame => {
+      sentSeqs.push(frame[6]);
+      return Promise.reject(new Error('application retryable error'));
+    });
+    const factory = jest.fn(() => adapter);
+
+    await expect(manager.call('device-a', factory, 'Ping', { message: '1' })).rejects.toThrow(
+      'application retryable error'
+    );
+    await manager.call('device-a', factory, 'Ping', { message: '2' });
+
+    expect(factory).toHaveBeenCalledTimes(1);
+    expect(adapter.reset).not.toHaveBeenCalled();
+    expect(sentSeqs).toEqual([1, 2]);
+  });
+
+  test('removes a settled per-device call queue', async () => {
+    const sentSeqs = [];
+    const { createAdapter } = createAdapterFactory(sentSeqs);
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+
+    await manager.call('device-a', createAdapter, 'Ping', { message: 'done' });
+
+    expect(manager.callQueues.size).toBe(0);
+  });
+
+  test('stops an in-flight call before reading when its link is invalidated during write', async () => {
+    let releaseWrite;
+    let markWriteStarted;
+    const writeStarted = new Promise(resolve => {
+      markWriteStarted = resolve;
+    });
+    const writeBlocked = new Promise(resolve => {
+      releaseWrite = resolve;
+    });
+    const success = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+    const adapter = {
+      router: 1,
+      generation: 1,
+      prepareCall: jest.fn(),
+      writeFrame: jest.fn(async () => {
+        markWriteStarted();
+        await writeBlocked;
+      }),
+      readFrame: jest.fn(() => Promise.resolve(success)),
+      reset: jest.fn(),
+    };
+    const manager = new ProtocolV2LinkManager({
+      getSchemas: () => schemas,
+      classifyError: () => 'recoverable',
+    });
+
+    const call = manager.call('device-a', () => adapter, 'Ping', { message: 'pending' });
+    await writeStarted;
+    await manager.invalidateLink('device-a', 'device disconnected');
+    releaseWrite();
+
+    await expect(call).rejects.toThrow('device disconnected');
+    expect(adapter.readFrame).not.toHaveBeenCalled();
+  });
+});