@onekeyfe/hd-core 1.2.0-alpha.67 → 1.2.0-alpha.68

package/__tests__/pro2Nft.test.ts

@@ -0,0 +1,108 @@
+import { blake2s } from '@noble/hashes/blake2s';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import {
+  PRO2_NFT_IMAGE_HEIGHT,
+  PRO2_NFT_IMAGE_WIDTH,
+  PRO2_NFT_THUMBNAIL_HEIGHT,
+  PRO2_NFT_THUMBNAIL_WIDTH,
+  buildPro2NftBundle,
+} from '../src/utils/pro2Nft';
+
+const rgba = (width: number, height: number, alpha = 0xff) => {
+  const data = new Uint8Array(width * height * 4);
+  for (let index = 3; index < data.length; index += 4) data[index] = alpha;
+  return data;
+};
+
+describe('buildPro2NftBundle', () => {
+  test('builds the exact Pro2 RGB565 triplet and basename', () => {
+    const bundle = buildPro2NftBundle({
+      image: {
+        width: PRO2_NFT_IMAGE_WIDTH,
+        height: PRO2_NFT_IMAGE_HEIGHT,
+        rgba: rgba(PRO2_NFT_IMAGE_WIDTH, PRO2_NFT_IMAGE_HEIGHT),
+      },
+      thumbnail: {
+        width: PRO2_NFT_THUMBNAIL_WIDTH,
+        height: PRO2_NFT_THUMBNAIL_HEIGHT,
+        rgba: rgba(PRO2_NFT_THUMBNAIL_WIDTH, PRO2_NFT_THUMBNAIL_HEIGHT),
+      },
+      title: 'CryptoPunk #3100',
+      subtitle: 'CryptoPunks',
+      timestampMs: 1_760_000_000_000,
+    });
+
+    expect(bundle.image.byteLength).toBe(583_212);
+    expect(bundle.thumbnail.byteLength).toBe(138_876);
+    expect(Array.from(bundle.image.slice(0, 12))).toEqual([
+      0x19, 0x12, 0, 0, 28, 2, 28, 2, 56, 4, 0, 0,
+    ]);
+    expect(Array.from(bundle.thumbnail.slice(0, 12))).toEqual([
+      0x19, 0x12, 0, 0, 7, 1, 7, 1, 16, 2, 0, 0,
+    ]);
+    expect(new TextDecoder().decode(bundle.metadata)).toBe(
+      '{"title":"CryptoPunk #3100","subtitle":"CryptoPunks"}'
+    );
+    expect(bytesToHex(blake2s(bundle.image))).toBe(
+      'af4b5f8fe216cfd0ef4a9162a42b5c66a73466f2491066f66f756c4e28cc869e'
+    );
+    expect(bytesToHex(blake2s(bundle.thumbnail))).toBe(
+      '44591afae1163cc14651d77644501c6a110f96506889b825cab0351ff4de857d'
+    );
+    expect(bytesToHex(blake2s(bundle.metadata))).toBe(
+      'e30d4dc2cddd441c9f1438c783e05a623ccf76f2f6219d4281769dda1b3635b5'
+    );
+    expect(bundle.basename).toBe('nft-af4b5f8f-1760000000000');
+  });
+
+  test('composites transparent pixels onto black without an alpha plane', () => {
+    const image = rgba(PRO2_NFT_IMAGE_WIDTH, PRO2_NFT_IMAGE_HEIGHT);
+    image.set([255, 255, 255, 0], 0);
+    const bundle = buildPro2NftBundle({
+      image: { width: PRO2_NFT_IMAGE_WIDTH, height: PRO2_NFT_IMAGE_HEIGHT, rgba: image },
+      thumbnail: {
+        width: PRO2_NFT_THUMBNAIL_WIDTH,
+        height: PRO2_NFT_THUMBNAIL_HEIGHT,
+        rgba: rgba(PRO2_NFT_THUMBNAIL_WIDTH, PRO2_NFT_THUMBNAIL_HEIGHT, 0),
+      },
+      title: 'NFT',
+      subtitle: '',
+      timestampMs: 1,
+    });
+
+    expect(bundle.image[1]).toBe(0x12);
+    expect(Array.from(bundle.image.slice(12, 14))).toEqual([0, 0]);
+    expect(bundle.thumbnail.byteLength).toBe(138_876);
+  });
+
+  test('rejects invalid dimensions and metadata byte lengths', () => {
+    const validThumbnail = {
+      width: PRO2_NFT_THUMBNAIL_WIDTH,
+      height: PRO2_NFT_THUMBNAIL_HEIGHT,
+      rgba: rgba(PRO2_NFT_THUMBNAIL_WIDTH, PRO2_NFT_THUMBNAIL_HEIGHT),
+    };
+    expect(() =>
+      buildPro2NftBundle({
+        image: { width: 1, height: 1, rgba: new Uint8Array(4) },
+        thumbnail: validThumbnail,
+        title: 'NFT',
+        subtitle: '',
+        timestampMs: 1,
+      })
+    ).toThrow('540x540');
+    expect(() =>
+      buildPro2NftBundle({
+        image: {
+          width: PRO2_NFT_IMAGE_WIDTH,
+          height: PRO2_NFT_IMAGE_HEIGHT,
+          rgba: rgba(PRO2_NFT_IMAGE_WIDTH, PRO2_NFT_IMAGE_HEIGHT),
+        },
+        thumbnail: validThumbnail,
+        title: 'a'.repeat(64),
+        subtitle: '',
+        timestampMs: 1,
+      })
+    ).toThrow('1 to 63');
+  });
+});

package/__tests__/protocol-binding.test.ts

@@ -0,0 +1,89 @@
+import { createCoreApi, createProtocolAwareCall } from '../src/inject';
+
+import type { CoreApi } from '../src/types/api';
+
+describe('SDK protocol binding', () => {
+  test('exposes a minimal API that returns the actively detected protocol', async () => {
+    const response = { success: true as const, payload: 'V2' as const };
+    const rawCall = jest.fn().mockResolvedValue(response);
+    const api = createCoreApi(rawCall as CoreApi['call']);
+
+    await expect(api.detectDeviceConnectProtocol('USB_DEVICE_A')).resolves.toBe(response);
+    expect(rawCall).toHaveBeenCalledWith({
+      connectId: 'USB_DEVICE_A',
+      forceProtocolDetection: true,
+      method: 'detectDeviceConnectProtocol',
+    });
+  });
+
+  test('injects a strict protocol into every later call and isolates devices', async () => {
+    const rawCall = jest.fn(params => Promise.resolve({ success: true, payload: params }));
+    const protocolAwareCall = createProtocolAwareCall(rawCall as CoreApi['call']);
+    const api = createCoreApi(protocolAwareCall.call);
+
+    protocolAwareCall.setDeviceConnectProtocol('USB_DEVICE_A', 'V2');
+    protocolAwareCall.setDeviceConnectProtocol('ble-device-b', 'V1');
+
+    await api.deviceWipe('usb_device_a');
+    await api.deviceSupportFeatures('BLE-DEVICE-B');
+    await api.getFeatures('USB_DEVICE_A', { connectProtocol: 'V1' });
+    await api.getDeviceState('USB_DEVICE_A', { forceProtocolDetection: true });
+    await protocolAwareCall.call({
+      connectId: 'USB_DEVICE_A',
+      method: 'deviceUpdateReboot',
+    });
+
+    expect(rawCall).toHaveBeenNthCalledWith(1, {
+      connectId: 'usb_device_a',
+      method: 'deviceWipe',
+      connectProtocol: 'V2',
+    });
+    expect(rawCall).toHaveBeenNthCalledWith(2, {
+      connectId: 'BLE-DEVICE-B',
+      method: 'deviceSupportFeatures',
+      connectProtocol: 'V1',
+    });
+    expect(rawCall).toHaveBeenNthCalledWith(3, {
+      connectId: 'USB_DEVICE_A',
+      method: 'getFeatures',
+      connectProtocol: 'V1',
+    });
+    expect(rawCall).toHaveBeenNthCalledWith(4, {
+      connectId: 'USB_DEVICE_A',
+      method: 'getDeviceState',
+      forceProtocolDetection: true,
+    });
+    expect(rawCall).toHaveBeenNthCalledWith(5, {
+      connectId: 'USB_DEVICE_A',
+      method: 'deviceUpdateReboot',
+      connectProtocol: 'V2',
+    });
+  });
+
+  test('keeps bindings local to one SDK instance and supports clearing them', async () => {
+    const firstRawCall = jest.fn(() => Promise.resolve({ success: true, payload: {} }));
+    const secondRawCall = jest.fn(() => Promise.resolve({ success: true, payload: {} }));
+    const first = createProtocolAwareCall(firstRawCall as CoreApi['call']);
+    const second = createProtocolAwareCall(secondRawCall as CoreApi['call']);
+
+    first.setDeviceConnectProtocol('same-device', 'V2');
+    await first.call({ connectId: 'same-device', method: 'deviceWipe' });
+    await second.call({ connectId: 'same-device', method: 'deviceWipe' });
+    first.setDeviceConnectProtocol('same-device', undefined);
+    await first.call({ connectId: 'same-device', method: 'deviceWipe' });
+
+    expect(firstRawCall).toHaveBeenNthCalledWith(1, {
+      connectId: 'same-device',
+      method: 'deviceWipe',
+      connectProtocol: 'V2',
+    });
+    expect(secondRawCall).toHaveBeenCalledWith({
+      connectId: 'same-device',
+      method: 'deviceWipe',
+    });
+    expect(firstRawCall).toHaveBeenNthCalledWith(2, {
+      connectId: 'same-device',
+      method: 'deviceWipe',
+    });
+  });
+});

package/__tests__/protocol-v2-resources.test.ts

@@ -0,0 +1,340 @@
+import axios from 'axios';
+import { sha256 } from '@noble/hashes/sha256';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { DataManager } from '../src/data-manager';
+import {
+  PROTOCOL_V2_RESOURCE_DEVICE_PATHS,
+  PROTOCOL_V2_RESOURCE_TYPES,
+  buildProtocolV2ResourceUpdatePlan,
+  isProtocolV2ResourceFileValid,
+  parseProtocolV2Resources,
+  readProtocolV2ResourceInventory,
+} from '../src/protocols/protocol-v2/resources';
+
+import type {
+  ConnectSettings,
+  IProtocolV2BootResources,
+  IProtocolV2Resource,
+  RemoteConfigResponse,
+} from '../src/types';
+
+jest.mock('axios');
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+const bytesToHex = (bytes: Uint8Array) =>
+  Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+
+const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
+
+const createResourceHeader = (headerHash: string) => {
+  const header = new Uint8Array(PROTOCOL_V2_OKPP_HEADER_SIZE);
+  const view = new DataView(header.buffer);
+  'OKPP'.split('').forEach((char, index) => {
+    header[index] = char.charCodeAt(0);
+  });
+  'RESC'.split('').forEach((char, index) => {
+    header[0x08 + index] = char.charCodeAt(0);
+  });
+  view.setUint32(0x0c, header.byteLength, true);
+  for (let index = 0; index < headerHash.length / 2; index++) {
+    header[0x240 + index] = Number.parseInt(headerHash.slice(index * 2, index * 2 + 2), 16);
+  }
+  return header;
+};
+
+const resources: IProtocolV2Resource[] = PROTOCOL_V2_RESOURCE_TYPES.map((type, index) => ({
+  type,
+  url: `https://example.com/${type}.okpkg`,
+  size: index + 100,
+  fileHash: index.toString(16).padStart(64, '0'),
+  headerHash: index.toString(16).padStart(128, '0'),
+}));
+
+const bootResources: IProtocolV2BootResources = {
+  required: false,
+  target: 'RES',
+  manifestUrl: 'https://example.com/manifest.json',
+  files: [
+    {
+      name: 'bootloader_crest.bin',
+      url: 'https://example.com/assets/bootloader_crest.bin',
+      devicePath: 'vol0:/assets/loaders/boot.staging/graphics/bootloader_crest.bin',
+      size: 1234,
+      fileHash: 'ab'.repeat(32),
+    },
+  ],
+};
+
+const createSettings = (configFetcher: ConnectSettings['configFetcher']): ConnectSettings =>
+  ({
+    env: 'node',
+    fetchConfig: true,
+    preRelease: true,
+    configFetcher,
+  } as ConnectSettings);
+
+const createRemoteConfig = (): RemoteConfigResponse =>
+  ({
+    classic: { firmware: [], ble: [] },
+    classic1s: { firmware: [], ble: [] },
+    classicpure: { firmware: [], ble: [] },
+    mini: { firmware: [], ble: [] },
+    touch: { firmware: [], ble: [] },
+    pro: { firmware: [], ble: [] },
+    pro2: { firmware: [], ble: [], resources: { stable: resources, boot: bootResources } },
+    bridge: {},
+  } as unknown as RemoteConfigResponse);
+
+describe('Pro2 resource configuration', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    DataManager.lastCheckTimestamp = 0;
+  });
+
+  test('accepts exactly six resources and normalizes their deterministic order', () => {
+    const parsed = parseProtocolV2Resources({
+      stable: [...resources].reverse(),
+      boot: bootResources,
+    });
+
+    expect(parsed?.stable.map(item => item.type)).toEqual(PROTOCOL_V2_RESOURCE_TYPES);
+    expect(parsed?.boot).toEqual(bootResources);
+    expect(PROTOCOL_V2_RESOURCE_DEVICE_PATHS.translations).toBe(
+      'vol0:/bundles/translations/translations.okpkg'
+    );
+  });
+
+  test('rejects incomplete, duplicate, or malformed stable sets', () => {
+    expect(() => parseProtocolV2Resources({ stable: resources.slice(1) })).toThrow(
+      'six unique resource types'
+    );
+    expect(() =>
+      parseProtocolV2Resources({ stable: [...resources.slice(0, 5), resources[0]] })
+    ).toThrow('six unique resource types');
+    expect(() =>
+      parseProtocolV2Resources({
+        stable: resources.map((resource, index) =>
+          index === 0 ? { ...resource, headerHash: 'bad' } : resource
+        ),
+      })
+    ).toThrow('headerHash');
+  });
+
+  test('requires boot resources to remain optional and use RES file entries', () => {
+    expect(() =>
+      parseProtocolV2Resources({
+        stable: resources,
+        boot: { ...bootResources, required: true },
+      })
+    ).toThrow('required flag');
+    expect(() =>
+      parseProtocolV2Resources({
+        stable: resources,
+        boot: { ...bootResources, target: 'INVALID' },
+      })
+    ).toThrow('expected RES');
+    expect(() =>
+      parseProtocolV2Resources({
+        stable: resources,
+        boot: {
+          ...bootResources,
+          files: [{ ...bootResources.files[0], devicePath: '../outside.bin' }],
+        },
+      })
+    ).toThrow('devicePath');
+
+    for (const devicePath of [
+      'vol0:/assets/loaders\\bootloader_crest.bin',
+      'vol0:/assets/loaders\\\\bootloader_crest.bin',
+    ]) {
+      expect(() =>
+        parseProtocolV2Resources({
+          stable: resources,
+          boot: {
+            ...bootResources,
+            files: [{ ...bootResources.files[0], devicePath }],
+          },
+        })
+      ).toThrow('devicePath');
+    }
+  });
+
+  test('downloads nothing when all resource identities match', () => {
+    const inventory = resources.map(({ type, size, headerHash }) => ({ type, size, headerHash }));
+
+    expect(
+      buildProtocolV2ResourceUpdatePlan({ resources, inventory, mode: 'application' })
+    ).toEqual({ status: 'valid', resources: [] });
+  });
+
+  test('builds inventory from existing filesystem calls without ResourceInventoryGet', async () => {
+    const installedResources = resources.map((resource, index) => ({
+      ...resource,
+      size: PROTOCOL_V2_OKPP_HEADER_SIZE + index + 1,
+    }));
+    const resourceByPath = new Map(
+      installedResources.map(resource => [
+        PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type],
+        resource,
+      ])
+    );
+    const typedCall = jest.fn(
+      (requestType: string, _responseType: string, payload: Record<string, any>) => {
+        if (requestType === 'ResourceInventoryGet') {
+          throw new Error('ResourceInventoryGet is unavailable on released firmware');
+        }
+        if (requestType === 'FilesystemPathInfoQuery') {
+          const resource = resourceByPath.get(payload.path);
+          return {
+            message: {
+              exist: Boolean(resource),
+              directory: false,
+              size: resource?.size ?? 0,
+            },
+          };
+        }
+        if (requestType === 'FilesystemFileRead') {
+          const resource = resourceByPath.get(payload.file.path);
+          if (!resource) throw new Error('missing resource');
+          const header = createResourceHeader(resource.headerHash);
+          const offset = Number(payload.file.offset);
+          const chunkLength = Number(payload.chunk_len);
+          return {
+            message: {
+              data: header.slice(offset, offset + chunkLength),
+            },
+          };
+        }
+        throw new Error(`Unexpected request: ${requestType}`);
+      }
+    );
+
+    await expect(
+      readProtocolV2ResourceInventory({
+        commands: { typedCall },
+        resources: installedResources,
+        chunkSize: 4000,
+      })
+    ).resolves.toEqual(
+      installedResources.map(({ type, size, headerHash }) => ({ type, size, headerHash }))
+    );
+    expect(typedCall.mock.calls.some(call => call[0] === 'ResourceInventoryGet')).toBe(false);
+    expect(typedCall.mock.calls.filter(call => call[0] === 'FilesystemPathInfoQuery')).toHaveLength(
+      6
+    );
+    expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileRead')).toBe(true);
+  });
+
+  test('selects only the changed or missing resource in application mode', () => {
+    const inventory = resources
+      .filter(resource => resource.type !== 'noto')
+      .map(({ type, size, headerHash }) => ({
+        type,
+        size: type === 'images' ? size + 1 : size,
+        headerHash,
+      }));
+
+    const result = buildProtocolV2ResourceUpdatePlan({
+      resources,
+      inventory,
+      mode: 'application',
+    });
+
+    expect(result.status).toBe('outdated');
+    expect(result.resources.map(resource => resource.type)).toEqual(['images', 'noto']);
+  });
+
+  test('reports unknown without an application inventory and selects all in recovery mode', () => {
+    expect(buildProtocolV2ResourceUpdatePlan({ resources, mode: 'application' })).toEqual({
+      status: 'unknown',
+      resources: [],
+    });
+    expect(
+      buildProtocolV2ResourceUpdatePlan({ resources, mode: 'bootloader-recovery' }).resources
+    ).toHaveLength(6);
+  });
+
+  test('uses a filesystem inventory for incremental recovery mode updates', () => {
+    const inventory = resources.slice(1).map(({ type, size, headerHash }) => ({
+      type,
+      size,
+      headerHash,
+    }));
+
+    expect(
+      buildProtocolV2ResourceUpdatePlan({
+        resources,
+        inventory,
+        mode: 'bootloader-recovery',
+      }).resources.map(resource => resource.type)
+    ).toEqual(['images']);
+  });
+
+  test('verifies both full file size and SHA-256 before transfer', () => {
+    const bytes = new Uint8Array([1, 2, 3]);
+    const binary = bytes.buffer;
+    const identity = { size: bytes.byteLength, fileHash: bytesToHex(sha256(bytes)) };
+
+    expect(isProtocolV2ResourceFileValid(binary, identity)).toBe(true);
+    expect(isProtocolV2ResourceFileValid(binary, { ...identity, size: 4 })).toBe(false);
+    expect(isProtocolV2ResourceFileValid(binary, { ...identity, fileHash: '0'.repeat(64) })).toBe(
+      false
+    );
+  });
+
+  test('applies a validated pre-release config and exposes the stable resource set', async () => {
+    const configFetcher = jest.fn().mockResolvedValue(createRemoteConfig());
+
+    await expect(DataManager.load(createSettings(configFetcher))).resolves.toBe(true);
+
+    expect(configFetcher).toHaveBeenCalledWith(
+      expect.stringMatching(/^https:\/\/data\.onekey\.so\/pre-config\.json\?noCache=/)
+    );
+    expect(DataManager.getProtocolV2Resources()).toEqual(resources);
+    expect(DataManager.getProtocolV2BootResources()).toEqual(bootResources);
+  });
+
+  test('keeps base SDK initialization available when remote Pro2 resources are invalid', async () => {
+    const remoteConfig = createRemoteConfig();
+    (remoteConfig.pro2 as { resources?: unknown }).resources = { stable: [] };
+    const configFetcher = jest.fn().mockResolvedValue(remoteConfig);
+
+    await expect(DataManager.load(createSettings(configFetcher))).resolves.toBe(true);
+
+    expect(DataManager.getProtocolV2Resources()).toBeUndefined();
+    expect(DataManager.getProtocolV2BootResources()).toBeUndefined();
+  });
+
+  test('only blocks resource mutation when the refreshed Pro2 resources are invalid', async () => {
+    const remoteConfig = createRemoteConfig();
+    (remoteConfig.pro2 as { resources?: unknown }).resources = { stable: [] };
+    const settings = createSettings(jest.fn().mockResolvedValue(remoteConfig));
+    DataManager.settings = settings;
+
+    await expect(DataManager.forceReloadData()).resolves.toBeUndefined();
+    await expect(DataManager.forceReloadData({ requireResources: true })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+      message: expect.stringContaining('Invalid Pro2 resources config'),
+    });
+    expect(DataManager.lastCheckTimestamp).toBeGreaterThan(0);
+  });
+
+  test('does not advance the cache timestamp when refresh fails', async () => {
+    jest.spyOn(axios, 'get').mockRejectedValue(new Error('offline'));
+    const settings = createSettings(jest.fn().mockResolvedValue(null));
+    DataManager.settings = settings;
+
+    await DataManager.checkAndReloadData();
+
+    expect(DataManager.lastCheckTimestamp).toBe(0);
+    await expect(DataManager.forceReloadData()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.NetworkError,
+      message: 'Unable to refresh the latest remote config',
+    });
+    expect(DataManager.lastCheckTimestamp).toBe(0);
+  });
+});

package/__tests__/protocol-v2-ui-lifecycle.test.ts

@@ -0,0 +1,91 @@
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+
+import { DEVICE } from '../src/events';
+import { Device } from '../src/device/Device';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://example.com/',
+}));
+
+describe('Protocol V2 UI interaction lifecycle', () => {
+  test('synthesizes finish metadata for a progress-only operation', () => {
+    const device = new Device({ id: 'connect-progress' } as any);
+    device.isProtocolV2 = jest.fn(() => true);
+    device.beginProtocolV2UiInteraction();
+
+    const metadata = device.finishProtocolV2UiInteraction('succeeded', {
+      ensureMetadata: true,
+    });
+
+    expect(metadata).toMatchObject({
+      phase: 'processing',
+      transition: 'finish',
+      outcome: 'succeeded',
+      protocol: 'V2',
+    });
+  });
+
+  test('keeps finish metadata after the Protocol V2 transport is released', () => {
+    const device = new Device({ id: 'connect-released' } as any);
+    const isProtocolV2 = jest.fn().mockReturnValueOnce(true).mockReturnValue(false);
+    device.isProtocolV2 = isProtocolV2;
+    device.beginProtocolV2UiInteraction();
+
+    const metadata = device.finishProtocolV2UiInteraction('succeeded', {
+      ensureMetadata: true,
+    });
+
+    expect(metadata).toMatchObject({
+      phase: 'processing',
+      transition: 'finish',
+      outcome: 'succeeded',
+      protocol: 'V2',
+    });
+  });
+
+  test('emits a matching PIN phase completion after DeviceSessionAskPin succeeds', async () => {
+    const device = new Device({ id: 'connect-1' } as any);
+    device.isProtocolV2 = jest.fn(() => true);
+    device.updateProtocolV2Status = jest.fn(() => undefined as any);
+    device.commands = {
+      typedCall: jest.fn().mockResolvedValue({
+        message: { unlocked: true },
+      }),
+    } as any;
+    device.beginProtocolV2UiInteraction();
+
+    const starts: unknown[] = [];
+    const completions: unknown[] = [];
+    device.on(DEVICE.PIN_ON_DEVICE, (...args) => starts.push(args));
+    device.on(DEVICE.PIN_ON_DEVICE_COMPLETE, (...args) => completions.push(args));
+
+    await device.unlockDevice(DeviceSessionPinType.Main, {
+      source: 'unlock-coordinator',
+      reason: 'device-locked',
+      deviceOnly: true,
+    });
+
+    const startMetadata = (starts[0] as unknown[])[2] as Record<string, unknown>;
+    const completionMetadata = (completions[0] as unknown[])[1] as Record<string, unknown>;
+    expect(startMetadata.interaction).toMatchObject({
+      phase: 'pin',
+      transition: 'start',
+      protocol: 'V2',
+    });
+    expect(completionMetadata).toMatchObject({
+      interactionId: (startMetadata.interaction as { interactionId: string }).interactionId,
+      phaseId: (startMetadata.interaction as { phaseId: string }).phaseId,
+      phase: 'pin',
+      transition: 'complete',
+      outcome: 'succeeded',
+      protocol: 'V2',
+    });
+    expect(completionMetadata.sequence).toBeGreaterThan(
+      (startMetadata.interaction as { sequence: number }).sequence
+    );
+    expect(completionMetadata.phaseId).toBe(
+      (startMetadata.interaction as { phaseId: string }).phaseId
+    );
+  });
+});