@onekeyfe/hd-transport 1.2.0-alpha.4 → 1.2.0-alpha.41

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,177 @@ 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_DeviceSessionGet: 61200,
+      MessageType_DeviceSession: 61201,
+      MessageType_DeviceSessionAskPin: 61202,
+      MessageType_DeviceSessionAskPassphrase: 61203,
+    });
+    expect(v2Messages.nested.DeviceStatusGet).toEqual({ fields: {} });
+    expect(v2Messages.nested.ProtocolInfoRequest.fields.eventless_wallet_session).toMatchObject({
+      id: 1,
+      type: 'bool',
+      options: { default: false },
+    });
+    expect(v2Messages.nested.ProtocolInfo.fields).toMatchObject({
+      version: { id: 1, type: 'uint32', rule: 'required' },
+      build_fingerprint: { id: 2, type: 'string', rule: 'required' },
+      supported_messages: { id: 3, type: 'uint32', rule: 'repeated' },
+    });
+    expect(v2Messages.nested.DeviceSessionGet.fields.session_id).toMatchObject({
+      id: 1,
+      type: 'bytes',
+    });
+    expect(v2Messages.nested.DeviceSessionPinType.values).toEqual({
+      Any: 1,
+      Main: 2,
+      AttachToPin: 3,
+    });
+    expect(v2Messages.nested.DeviceSessionErrorCode.values).toEqual({
+      DeviceSessionError_None: 0,
+      DeviceSessionError_UserCancelled: 1,
+      DeviceSessionError_InvalidSession: 2,
+      DeviceSessionError_AttachPinUnavailable: 3,
+      DeviceSessionError_PassphraseDisabled: 4,
+      DeviceSessionError_Busy: 5,
+    });
+    expect(v2Messages.nested).not.toHaveProperty('DeviceWalletSelect');
+    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.fields.type).toMatchObject({
+      id: 1,
+      type: 'DeviceSessionPinType',
+    });
+    expect(v2Messages.nested.DeviceSessionAskPassphrase).toEqual({
+      fields: {
+        passphrase: {
+          type: 'string',
+          id: 1,
+        },
+        on_device: {
+          rule: 'required',
+          type: 'bool',
+          id: 2,
+        },
+      },
+    });
+    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_DeviceSessionOpen'
+    );
+  });
+
+  test('Protocol V2 passphrase selection explicitly selects host or device input on wire', () => {
+    const messages = parseConfigure(v2Messages);
+    const { Message } = createMessageFromName(messages, 'DeviceSessionAskPassphrase');
+
+    const onHost = Message.encode(
+      Message.create({ passphrase: 'host hidden wallet', on_device: false })
+    ).finish();
+    const onDevice = Message.encode(Message.create({ on_device: true })).finish();
+
+    expect(Buffer.from(onHost).toString('hex')).toBe(
+      '0a12686f73742068696464656e2077616c6c65741000'
+    );
+    expect(Buffer.from(onDevice).toString('hex')).toBe('1001');
+    expect(Message.decode(onHost)).toMatchObject({
+      passphrase: 'host hidden wallet',
+      on_device: false,
+    });
+    expect(Message.decode(onDevice)).toMatchObject({ on_device: true });
+  });
+
+  test('Protocol V2 onboarding status matches the current firmware-pro2 schema', () => {
+    expect(v2Messages.nested.MessageType.values).toMatchObject({
+      MessageType_OnboardingStatusGet: 61600,
+      MessageType_OnboardingStatus: 61601,
+    });
+    expect(v2Messages.nested.OnboardingStep.values).toMatchObject({
+      ONBOARDING_STEP_UNKNOWN: 0,
+      ONBOARDING_STEP_CHECKING: 1,
+      ONBOARDING_STEP_PERSONALIZATION: 2,
+      ONBOARDING_STEP_PIN: 3,
+      ONBOARDING_STEP_SETUP: 4,
+      ONBOARDING_STEP_DONE: 5,
+    });
+    expect(v2Messages.nested.OnboardingPhase.values).toBeDefined();
+    expect(v2Messages.nested.OnboardingSetupKind.values).toBeDefined();
+    expect(v2Messages.nested.OnboardingSetupMethod.values).toBeDefined();
+    expect(v2Messages.nested.OnboardingSetupStatus.fields).toMatchObject({
+      kind: { id: 1, type: 'OnboardingSetupKind' },
+      method: { id: 2, type: 'OnboardingSetupMethod' },
+    });
+    expect(v2Messages.nested.OnboardingStatus.fields).toMatchObject({
+      step: { id: 1, type: 'OnboardingStep' },
+      phase: { id: 2, type: 'OnboardingPhase' },
+      setup: { id: 3, type: 'OnboardingSetupStatus' },
+      pin_set: { id: 4, type: 'bool' },
+      wallet_initialized: { id: 5, type: 'bool' },
+    });
+    expect(v2Messages.nested).not.toHaveProperty('DevOnboardingStatus');
+  });
+
+  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';

package/__tests__/protocol-v2-ble-frame-writer.test.js

@@ -0,0 +1,119 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { writeProtocolV2BleFrame } = require('../src');
+
+describe('Protocol V2 BLE frame writer', () => {
+  test('splits one complete Protocol V2 frame without changing packet order', async () => {
+    const packets = [];
+
+    await writeProtocolV2BleFrame({
+      frame: new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+      packetCapacity: 4,
+      writePacket: packet => {
+        packets.push(Array.from(packet));
+        return Promise.resolve();
+      },
+    });
+
+    expect(packets).toEqual([
+      [0, 1, 2, 3],
+      [4, 5, 6, 7],
+      [8, 9],
+    ]);
+  });
+
+  test('stops before the next packet when the connection generation changes', async () => {
+    const packets = [];
+    let active = true;
+
+    await expect(
+      writeProtocolV2BleFrame({
+        frame: new Uint8Array(9),
+        packetCapacity: 4,
+        assertActive: () => {
+          if (!active) throw new Error('stale BLE generation');
+        },
+        writePacket: packet => {
+          packets.push(packet);
+          active = false;
+          return Promise.resolve();
+        },
+      })
+    ).rejects.toThrow('stale BLE generation');
+
+    expect(packets).toHaveLength(1);
+  });
+
+  test('does not write when the call is already aborted', async () => {
+    const controller = new AbortController();
+    const writePacket = jest.fn();
+    controller.abort();
+
+    await expect(
+      writeProtocolV2BleFrame({
+        frame: new Uint8Array(4),
+        packetCapacity: 4,
+        signal: controller.signal,
+        abortMessage: 'Protocol V2 BLE write aborted for Ping',
+        writePacket,
+      })
+    ).rejects.toThrow('Protocol V2 BLE write aborted for Ping');
+
+    expect(writePacket).not.toHaveBeenCalled();
+  });
+
+  test('surfaces an abort that occurs while the final packet write is completing', async () => {
+    const controller = new AbortController();
+    const writePacket = jest.fn().mockImplementation(() => {
+      controller.abort();
+      return Promise.resolve();
+    });
+
+    await expect(
+      writeProtocolV2BleFrame({
+        frame: new Uint8Array(4),
+        packetCapacity: 4,
+        signal: controller.signal,
+        abortMessage: 'Protocol V2 BLE write aborted for Ping',
+        writePacket,
+      })
+    ).rejects.toThrow('Protocol V2 BLE write aborted for Ping');
+
+    expect(writePacket).toHaveBeenCalledTimes(1);
+  });
+
+  test('applies bounded burst pauses and one final flush delay', async () => {
+    const waits = [];
+    const writePacket = jest.fn().mockResolvedValue(undefined);
+
+    await writeProtocolV2BleFrame({
+      frame: new Uint8Array(10),
+      packetCapacity: 3,
+      initialDelayMs: 3,
+      burstSize: 2,
+      burstPauseMs: 7,
+      flushDelayMs: 11,
+      wait: ms => {
+        waits.push(ms);
+        return Promise.resolve();
+      },
+      writePacket,
+    });
+
+    expect(writePacket).toHaveBeenCalledTimes(4);
+    expect(waits).toEqual([3, 7, 11]);
+  });
+
+  test('rejects an invalid packet capacity before writing', async () => {
+    const writePacket = jest.fn();
+
+    await expect(
+      writeProtocolV2BleFrame({
+        frame: new Uint8Array(4),
+        packetCapacity: 0,
+        writePacket,
+      })
+    ).rejects.toThrow('Protocol V2 BLE packet capacity must be a positive integer');
+
+    expect(writePacket).not.toHaveBeenCalled();
+  });
+});