@onekeyfe/hd-core 1.2.0-alpha.13 → 1.2.0-alpha.131

package/__tests__/search-devices.test.ts

@@ -0,0 +1,191 @@
+import SearchDevices from '../src/api/SearchDevices';
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  __esModule: true,
+  default: {
+    configure: jest.fn(),
+  },
+}));
+
+jest.mock('../src/data-manager', () => ({
+  DataManager: {
+    getSettings: jest.fn(() => 'webusb'),
+    isBleConnect: jest.fn(() => false),
+  },
+}));
+
+jest.mock('../src/device/DevicePool', () => ({
+  DevicePool: {
+    getDevices: jest.fn(),
+  },
+}));
+
+const transportManagerMock: { default: { configure: jest.Mock } } = jest.requireMock(
+  '../src/data-manager/TransportManager'
+);
+const devicePoolMock: { DevicePool: { getDevices: jest.Mock } } = jest.requireMock(
+  '../src/device/DevicePool'
+);
+const dataManagerMock: {
+  DataManager: {
+    getSettings: jest.Mock;
+    isBleConnect: jest.Mock;
+  };
+} = jest.requireMock('../src/data-manager');
+const { configure: mockConfigureTransport } = transportManagerMock.default;
+const { getDevices: mockGetDevices } = devicePoolMock.DevicePool;
+const { isBleConnect: mockIsBleConnect } = dataManagerMock.DataManager;
+
+describe('SearchDevices', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockIsBleConnect.mockReturnValue(false);
+  });
+
+  test('搜索忽略调用方协议并主动探测，单个无响应设备不阻断后续结果', async () => {
+    const unresponsiveDescriptor = {
+      path: 'stale-usb-device',
+      id: 'stale-usb-device',
+    } as any;
+    const availableDescriptor = {
+      path: 'available-usb-device',
+      id: 'available-usb-device',
+    } as any;
+    const availableDeviceInfo = {
+      connectId: 'available-usb-device',
+      deviceType: 'pro2',
+    };
+    const availableDevice = {
+      toMessageObject: jest.fn(() => availableDeviceInfo),
+    } as any;
+
+    mockGetDevices
+      .mockRejectedValueOnce(
+        new Error(
+          'Unable to detect USB protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping'
+        )
+      )
+      .mockResolvedValueOnce({
+        devices: { 'available-usb-device': availableDevice },
+        deviceList: [availableDevice],
+      });
+
+    const method = new SearchDevices({
+      id: 1,
+      payload: {
+        method: 'searchDevices',
+        connectProtocol: 'V2',
+      },
+    } as any);
+    method.init();
+    method.connector = {
+      enumerate: jest.fn().mockResolvedValue({
+        descriptors: [unresponsiveDescriptor, availableDescriptor],
+      }),
+    } as any;
+
+    await expect(method.run()).resolves.toEqual([availableDeviceInfo]);
+    expect(mockConfigureTransport).toHaveBeenCalledTimes(1);
+    expect(mockGetDevices).toHaveBeenNthCalledWith(
+      1,
+      [unresponsiveDescriptor],
+      unresponsiveDescriptor.path,
+      {
+        connectProtocol: undefined,
+        forceProtocolDetection: true,
+        refreshRuntimeState: true,
+      }
+    );
+    expect(mockGetDevices).toHaveBeenNthCalledWith(
+      2,
+      [availableDescriptor],
+      availableDescriptor.path,
+      {
+        connectProtocol: undefined,
+        forceProtocolDetection: true,
+        refreshRuntimeState: true,
+      }
+    );
+  });
+
+  test.each([
+    ['OneKey Pro', 'pro'],
+    ['OneKey Pro 2', 'pro2'],
+    ['Neo A1B2', 'neo'],
+  ])(
+    'BLE discovery keeps the %s transport identity separate from device identity',
+    async (name, deviceType) => {
+      mockIsBleConnect.mockReturnValue(true);
+
+      const descriptor = {
+        id: 'ble-peripheral-id',
+        path: 'ble-peripheral-id',
+        name,
+        commType: 'ble',
+      };
+      const method = new SearchDevices({
+        id: 1,
+        payload: {
+          method: 'searchDevices',
+        },
+      } as any);
+      method.init();
+      method.connector = {
+        enumerate: jest.fn().mockResolvedValue({
+          descriptors: [descriptor],
+        }),
+      } as any;
+
+      await expect(method.run()).resolves.toEqual([
+        {
+          ...descriptor,
+          connectId: 'ble-peripheral-id',
+          serialNo: null,
+          uuid: '',
+          deviceId: null,
+          deviceType,
+        },
+      ]);
+      expect(mockGetDevices).not.toHaveBeenCalled();
+    }
+  );
+
+  test.each([
+    ['Pro2 A1B2 - Find My', undefined, 'Pro2 A1B2'],
+    ['Pro2 5E9D - Finde My', undefined, 'Pro2 5E9D'],
+    ['Pro2 22D8FindMy', undefined, 'Pro2 22D8'],
+    [undefined, 'OneKey Pro 2 A1B2 - Find My', 'OneKey Pro 2 A1B2'],
+  ])(
+    'BLE discovery normalizes the Find My display name from name=%s localName=%s',
+    async (name, localName, expectedName) => {
+      mockIsBleConnect.mockReturnValue(true);
+
+      const method = new SearchDevices({
+        id: 1,
+        payload: { method: 'searchDevices' },
+      } as any);
+      method.init();
+      method.connector = {
+        enumerate: jest.fn().mockResolvedValue({
+          descriptors: [
+            {
+              id: 'ble-peripheral-id',
+              path: 'ble-peripheral-id',
+              name,
+              localName,
+              commType: 'ble',
+            },
+          ],
+        }),
+      } as any;
+
+      await expect(method.run()).resolves.toEqual([
+        expect.objectContaining({
+          connectId: 'ble-peripheral-id',
+          name: expectedName,
+          deviceType: 'pro2',
+        }),
+      ]);
+    }
+  );
+});

package/__tests__/ton-sign-message.test.ts

@@ -0,0 +1,84 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import TonSignMessage from '../src/api/ton/TonSignMessage';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+const createMethod = (deviceType: EDeviceType) => {
+  const method = new TonSignMessage({
+    id: 1,
+    payload: {
+      method: 'tonSignMessage',
+    },
+  });
+
+  Object.defineProperty(method, 'device', {
+    value: {
+      getCurrentDeviceType: () => deviceType,
+    },
+  });
+
+  return method;
+};
+
+describe('TonSignMessage response compatibility', () => {
+  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
+    'uses the corrected signing_message field for %s',
+    async deviceType => {
+      const method = createMethod(deviceType);
+
+      await expect(
+        method.processTxRequest(
+          {
+            signature: 'signature',
+            signing_message: 'serialized-message',
+          },
+          ''
+        )
+      ).resolves.toEqual({
+        signature: 'signature',
+        signing_message: 'serialized-message',
+        skip_validate: false,
+      });
+    }
+  );
+
+  test('normalizes the legacy Protocol V1 field without removing it', async () => {
+    const method = createMethod(EDeviceType.Classic1s);
+
+    await expect(
+      method.processTxRequest(
+        {
+          signature: 'signature',
+          signning_message: 'message-hash',
+        },
+        ''
+      )
+    ).resolves.toEqual({
+      signature: 'signature',
+      signning_message: 'message-hash',
+      signing_message: 'message-hash',
+      skip_validate: true,
+    });
+  });
+
+  test('skips validation when blind signing omits the signing message', async () => {
+    const method = createMethod(EDeviceType.Pro2);
+
+    await expect(
+      method.processTxRequest(
+        {
+          signature: 'signature',
+        },
+        ''
+      )
+    ).resolves.toEqual({
+      signature: 'signature',
+      signing_message: undefined,
+      skip_validate: true,
+    });
+  });
+});

package/__tests__/tron-sign-message-init.test.ts

@@ -0,0 +1,74 @@
+import { EFirmwareType, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import TronSignMessage from '../src/api/tron/TronSignMessage';
+
+import type { Device } from '../src/device/Device';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('TronSignMessage legacy message validation', () => {
+  test.each([EFirmwareType.BitcoinOnly, EFirmwareType.Universal])(
+    'reports the current device firmware type after binding: %s',
+    async firmwareType => {
+      const method = new TronSignMessage({
+        id: 1,
+        payload: {
+          method: 'tronSignMessage',
+          path: "m/44'/195'/0'/0/0",
+          messageHex: '00',
+          messageType: 'V1',
+        },
+      });
+
+      method.init();
+      method.device = {
+        getCurrentFirmwareType: jest.fn(() => firmwareType),
+      } as unknown as Device;
+
+      try {
+        await method.run();
+        throw new Error('Expected run to reject the legacy message type');
+      } catch (error: unknown) {
+        expect(error).toBeInstanceOf(HardwareError);
+        if (!(error instanceof HardwareError)) return;
+
+        expect(error.errorCode).toBe(HardwareErrorCode.DeviceNotSupportMethod);
+        expect(error.params).toMatchObject({
+          firmwareType,
+          method: 'TronSignMessage',
+        });
+      }
+    }
+  );
+
+  test('allows Protocol V2 message signing on the Pro2 product family', async () => {
+    const method = new TronSignMessage({
+      id: 1,
+      payload: {
+        method: 'tronSignMessage',
+        path: "m/44'/195'/0'/0/0",
+        messageHex: '00',
+        messageType: 'V2',
+      },
+    });
+    method.init();
+
+    const typedCall = jest.fn().mockResolvedValue({ message: { signature: 'signature' } });
+    method.device = {
+      commands: { typedCall },
+      getCurrentFirmwareVersionString: jest.fn(() => '0.0.0'),
+      getCurrentMethodVersionRange: jest.fn(selector => selector('model_pro2')),
+      getCurrentFirmwareType: jest.fn(() => EFirmwareType.Universal),
+    } as unknown as Device;
+
+    await expect(method.run()).resolves.toEqual({ signature: 'signature' });
+    expect(typedCall).toHaveBeenCalledWith('TronSignMessage', 'TronMessageSignature', {
+      address_n: [2147483692, 2147483843, 2147483648, 0, 0],
+      message: '00',
+      message_type: 2,
+    });
+  });
+});

package/__tests__/uiProgressThrottle.test.ts

@@ -0,0 +1,74 @@
+import { createUiMessage } from '../src/events';
+import { UI_REQUEST } from '../src/events/ui-request';
+import { createUiProgressMessageFilter } from '../src/utils/uiProgressThrottle';
+
+import type { KnownDevice } from '../src/types';
+
+describe('createUiProgressMessageFilter', () => {
+  let currentTime: number;
+  let shouldPostMessage: ReturnType<typeof createUiProgressMessageFilter>;
+
+  beforeEach(() => {
+    currentTime = 1_000;
+    shouldPostMessage = createUiProgressMessageFilter(250, () => currentTime);
+  });
+
+  const firmwareProgress = (
+    progress: number,
+    progressType: 'transferData' | 'installingFirmware' = 'transferData'
+  ) =>
+    createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
+      device: {} as KnownDevice,
+      progress,
+      progressType,
+    });
+
+  test('limits firmware progress to one event per interval', () => {
+    expect(shouldPostMessage(firmwareProgress(1))).toBe(true);
+
+    currentTime += 100;
+    expect(shouldPostMessage(firmwareProgress(1))).toBe(false);
+
+    currentTime += 150;
+    expect(shouldPostMessage(firmwareProgress(1))).toBe(true);
+  });
+
+  test('limits transfer and install progress independently', () => {
+    expect(shouldPostMessage(firmwareProgress(1, 'transferData'))).toBe(true);
+    expect(shouldPostMessage(firmwareProgress(1, 'installingFirmware'))).toBe(true);
+
+    currentTime += 10;
+    expect(shouldPostMessage(firmwareProgress(2, 'transferData'))).toBe(false);
+    expect(shouldPostMessage(firmwareProgress(2, 'installingFirmware'))).toBe(false);
+  });
+
+  test('emits phase boundaries immediately and suppresses duplicate boundaries', () => {
+    expect(shouldPostMessage(firmwareProgress(0))).toBe(true);
+    expect(shouldPostMessage(firmwareProgress(0))).toBe(false);
+
+    currentTime += 10;
+    expect(shouldPostMessage(firmwareProgress(50))).toBe(false);
+    expect(shouldPostMessage(firmwareProgress(100))).toBe(true);
+    expect(shouldPostMessage(firmwareProgress(100))).toBe(false);
+
+    expect(shouldPostMessage(firmwareProgress(0))).toBe(true);
+  });
+
+  test('treats decreasing progress as a new phase', () => {
+    expect(shouldPostMessage(firmwareProgress(80))).toBe(true);
+
+    currentTime += 10;
+    expect(shouldPostMessage(firmwareProgress(20))).toBe(true);
+  });
+
+  test('also limits device progress and leaves other UI events unchanged', () => {
+    const deviceProgress = (progress: number) =>
+      createUiMessage(UI_REQUEST.DEVICE_PROGRESS, { progress });
+
+    expect(shouldPostMessage(deviceProgress(1))).toBe(true);
+    currentTime += 10;
+    expect(shouldPostMessage(deviceProgress(2))).toBe(false);
+
+    expect(shouldPostMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW))).toBe(true);
+  });
+});

package/__tests__/uiPromiseRegistry.test.ts

@@ -0,0 +1,115 @@
+import { createDeferred } from '@onekeyfe/hd-shared';
+
+import {
+  consumeUiPromise,
+  findUiPromiseForResponse,
+  rejectUiPromises,
+} from '../src/core/uiPromiseRegistry';
+import { UI_RESPONSE } from '../src/events';
+
+import type { UiPromise, UiPromiseResponse } from '../src/events';
+
+const createPinPromise = (interactionId: string, deviceId: string) => {
+  const promise = createDeferred(UI_RESPONSE.RECEIVE_PIN) as UiPromise<
+    typeof UI_RESPONSE.RECEIVE_PIN
+  >;
+  promise.responseCorrelation = { interactionId, deviceId };
+  return promise;
+};
+
+const asRegistry = (promises: UiPromise<typeof UI_RESPONSE.RECEIVE_PIN>[]) =>
+  promises as UiPromise<UiPromiseResponse['type']>[];
+
+describe('UI response promise correlation', () => {
+  test('consumes a rejected UI promise and normalizes its callback error', async () => {
+    const pending = createDeferred<string>();
+    const onFulfilled = jest.fn();
+    const onRejected = jest.fn();
+
+    consumeUiPromise(pending.promise, onFulfilled, onRejected);
+    pending.reject('cancelled' as unknown as Error);
+    await Promise.resolve();
+
+    expect(onFulfilled).not.toHaveBeenCalled();
+    expect(onRejected).toHaveBeenCalledWith(expect.any(Error));
+    expect(onRejected.mock.calls[0][0].message).toBe('cancelled');
+  });
+
+  test('matches a sensitive response by type, interactionId and deviceId', () => {
+    const deviceA = createPinPromise('interaction-a', 'device-a');
+    const deviceB = createPinPromise('interaction-b', 'device-b');
+
+    expect(
+      findUiPromiseForResponse(asRegistry([deviceA, deviceB]), {
+        type: UI_RESPONSE.RECEIVE_PIN,
+        payload: '123',
+        interactionId: 'interaction-b',
+        deviceId: 'device-b',
+      })
+    ).toBe(deviceB);
+  });
+
+  test('does not match incomplete or incorrect correlation metadata', () => {
+    const pending = createPinPromise('interaction-a', 'device-a');
+
+    expect(
+      findUiPromiseForResponse(asRegistry([pending]), {
+        type: UI_RESPONSE.RECEIVE_PIN,
+        payload: '123',
+        interactionId: 'interaction-a',
+      })
+    ).toBeUndefined();
+    expect(
+      findUiPromiseForResponse(asRegistry([pending]), {
+        type: UI_RESPONSE.RECEIVE_PIN,
+        payload: '123',
+        interactionId: 'interaction-a',
+        deviceId: 'device-b',
+      })
+    ).toBeUndefined();
+  });
+
+  test('keeps legacy responses only when the sensitive candidate is unique', () => {
+    const deviceA = createPinPromise('interaction-a', 'device-a');
+    const deviceB = createPinPromise('interaction-b', 'device-b');
+    const legacyResponse = {
+      type: UI_RESPONSE.RECEIVE_PIN,
+      payload: '123',
+    } as const;
+
+    expect(findUiPromiseForResponse(asRegistry([deviceA]), legacyResponse)).toBe(deviceA);
+    expect(
+      findUiPromiseForResponse(asRegistry([deviceA, deviceB]), legacyResponse)
+    ).toBeUndefined();
+  });
+
+  test('applies the same exact matching to passphrase responses', () => {
+    const promise = createDeferred(UI_RESPONSE.RECEIVE_PASSPHRASE) as UiPromise<
+      typeof UI_RESPONSE.RECEIVE_PASSPHRASE
+    >;
+    promise.responseCorrelation = {
+      interactionId: 'passphrase-interaction',
+      deviceId: 'device-a',
+    };
+
+    expect(
+      findUiPromiseForResponse([promise] as UiPromise<UiPromiseResponse['type']>[], {
+        type: UI_RESPONSE.RECEIVE_PASSPHRASE,
+        payload: { value: 'redacted' },
+        interactionId: 'passphrase-interaction',
+        deviceId: 'device-a',
+      })
+    ).toBe(promise);
+  });
+
+  test('rejects every pending UI promise removed during cleanup', async () => {
+    const deviceA = createPinPromise('interaction-a', 'device-a');
+    const deviceB = createPinPromise('interaction-b', 'device-b');
+    const cancellation = new Error('UI request was cancelled');
+
+    rejectUiPromises(asRegistry([deviceA, deviceB]), cancellation);
+
+    await expect(deviceA.promise).rejects.toBe(cancellation);
+    await expect(deviceB.promise).rejects.toBe(cancellation);
+  });
+});

package/dist/api/BaseMethod.d.ts

@@ -1,10 +1,16 @@
+import { type EFirmwareType } from '@onekeyfe/hd-shared';
+import { type DeviceSessionPinType, type ProtocolType } from '@onekeyfe/hd-transport';
 import type { Device } from '../device/Device';
 import type DeviceConnector from '../device/DeviceConnector';
 import type { DeviceFirmwareRange } from '../types';
 import type { CoreMessage } from '../events';
+import type { UnlockPolicy } from '../protocols/protocol-v2/unlockPolicy';
+import type { ProtocolV2InteractionDescriptor } from '../protocols/protocol-v2/uiInteraction';
+import type { ProtocolV2UnlockContext } from '../protocols/protocol-v2/unlockPolicyRunner';
 import type { RequestContext } from '../utils/tracing';
 import type { CoreContext } from '../core';
-export type UnlockPolicy = 'none' | 'retry-on-locked';
+export type { UnlockPolicy } from '../protocols/protocol-v2/unlockPolicy';
+export type ProtocolV2UiMode = 'auto' | 'none';
 export declare abstract class BaseMethod<Params = undefined> {
     abortSignal?: AbortSignal;
     responseID: number;
@@ -31,8 +37,14 @@ export declare abstract class BaseMethod<Params = undefined> {
     preWarmTtl: number;
     getPreWarmKey(): string;
     strictCheckDeviceSupport: boolean;
-    requireProtocolV2: boolean;
     unlockPolicy: UnlockPolicy;
+    protocolV2PreUnlockPinType?: DeviceSessionPinType;
+    protocolV2UnlockContext?: ProtocolV2UnlockContext;
+    getSupportedProtocols(): readonly ProtocolType[];
+    supportsProtocol(protocol: ProtocolType): boolean;
+    assertProtocolSupported(protocol: ProtocolType, firmwareType: EFirmwareType): void;
+    protocolV2UiInteraction?: ProtocolV2InteractionDescriptor;
+    protocolV2UiMode: ProtocolV2UiMode;
     protected throwIfAborted(): void;
     postMessage: (message: CoreMessage) => void;
     context?: CoreContext;

package/dist/api/BaseMethod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseMethod.d.ts","sourceRoot":"","sources":["../../src/api/BaseMethod.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,eAAe,MAAM,2BAA2B,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAe,MAAM,UAAU,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,iBAAiB,CAAC;AA6BtD,8BAAsB,UAAU,CAAC,MAAM,GAAG,SAAS;IACjD,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B,UAAU,EAAE,MAAM,CAAC;IAGnB,MAAM,EAAE,MAAM,CAAC;IAGf,MAAM,EAAE,MAAM,CAAC;IAOf,SAAS,CAAC,EAAE,MAAM,CAAC;IAKnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,WAAW,CAAC,EAAE,MAAM,CAAC;IAKrB,IAAI,EAAE,MAAM,CAAC;IAEb,UAAU,EAAG,MAAM,CAAC;IAEpB,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,cAAc,CAAC,EAAE,cAAc,CAAC;IAKhC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE7B,SAAS,CAAC,EAAE,eAAe,CAAC;IAK5B,SAAS,EAAE,OAAO,CAAC;IAMnB,eAAe,EAAE,MAAM,EAAE,CAAC;IAK1B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAK5B,qBAAqB,UAAQ;IAK7B,aAAa,UAAS;IAKtB,wBAAwB,UAAQ;IAMhC,oBAAoB,UAAS;IAG7B,qBAAqB,UAAS;IAG9B,eAAe,UAAS;IAGxB,UAAU,SAAa;IAGvB,aAAa,IAAI,MAAM;IAiBvB,wBAAwB,UAAS;IAQjC,iBAAiB,UAAS;IAG1B,YAAY,EAAE,YAAY,CAAU;IAEpC,SAAS,CAAC,cAAc;IAUxB,WAAW,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;IAE5C,OAAO,CAAC,EAAE,WAAW,CAAC;IAEtB,4BAA4B,UAAS;gBAEzB,OAAO,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,GAAG,CAAA;KAAE;IAYlD,QAAQ,CAAC,IAAI,IAAI,IAAI;IAErB,QAAQ,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC;IAE5B,eAAe,IAAI,mBAAmB;IAItC,UAAU,CAAC,OAAO,EAAE,WAAW;IAQ/B,SAAS,CAAC,MAAM,EAAE,MAAM;IA2BxB,oBAAoB;IAsBpB,yBAAyB;IAczB,SAAS,CAAC,wBAAwB,CAChC,cAAc,EAAE,MAAM,OAAO,EAC7B,eAAe,EAAE,MAAM,mBAAmB,EAC1C,OAAO,CAAC,EAAE;QACR,wBAAwB,CAAC,EAAE,OAAO,CAAC;KACpC;IA+BH,OAAO,CAAC,6CAA6C;IAqB/C,yBAAyB;IA4B/B,OAAO;IAGP,0BAA0B,SAAU;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,UAOrE;CACH"}
+{"version":3,"file":"BaseMethod.d.ts","sourceRoot":"","sources":["../../src/api/BaseMethod.ts"],"names":[],"mappings":"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"}

package/dist/api/CheckAllFirmwareRelease.d.ts

@@ -1,7 +1,31 @@
 import { BaseMethod } from './BaseMethod';
-import type { AllFirmwareRelease } from '../types/api/checkAllFirmwareRelease';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
+import type { AllFirmwareRelease, ProtocolV2FirmwareComponentRelease, ProtocolV2FirmwareReleaseStatus } from '../types/api/checkAllFirmwareRelease';
+import type { FirmwareUpdateV4Target } from '../types/api/firmwareUpdate';
+import type { DeviceFeaturesVerify, DeviceStateVersions, IFirmwareReleaseInfo } from '../types';
+export type ProtocolV2FirmwareReleasePlan = {
+    firmwareType: EFirmwareType;
+    status: ProtocolV2FirmwareReleaseStatus;
+    hasUpgrade: boolean;
+    required: boolean;
+    currentVersions: DeviceStateVersions;
+    components: ProtocolV2FirmwareComponentRelease[];
+    targetsToUpdate: FirmwareUpdateV4Target[];
+    release: IFirmwareReleaseInfo | undefined;
+};
+export declare function buildProtocolV2FirmwareRelease({ currentVersions, currentVerification, checkFirmwareHash, remotePayloadHashes, firmwareType, release, deviceType, }: {
+    currentVersions: DeviceStateVersions;
+    currentVerification?: Partial<DeviceFeaturesVerify>;
+    checkFirmwareHash?: boolean;
+    remotePayloadHashes?: Readonly<Record<string, string | null>>;
+    firmwareType: EFirmwareType;
+    release: IFirmwareReleaseInfo | undefined;
+    deviceType?: 'pro2' | 'neo';
+}): ProtocolV2FirmwareReleasePlan;
 export default class CheckAllFirmwareRelease extends BaseMethod {
+    getSupportedProtocols(): readonly ["V1", "V2"];
     init(): void;
     run(): Promise<AllFirmwareRelease | null>;
+    private runProtocolV2;
 }
 //# sourceMappingURL=CheckAllFirmwareRelease.d.ts.map

package/dist/api/CheckAllFirmwareRelease.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAU1C,OAAO,KAAK,EACV,kBAAkB,EAEnB,MAAM,sCAAsC,CAAC;AAE9C,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,IAAI;IAME,GAAG;CAkDV"}
+{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAgC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,kBAAkB,EAElB,kCAAkC,EAClC,+BAA+B,EAChC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EAGrB,MAAM,UAAU,CAAC;AAgIlB,MAAM,MAAM,6BAA6B,GAAG;IAC1C,YAAY,EAAE,aAAa,CAAC;IAC5B,MAAM,EAAE,+BAA+B,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,mBAAmB,CAAC;IACrC,UAAU,EAAE,kCAAkC,EAAE,CAAC;IACjD,eAAe,EAAE,sBAAsB,EAAE,CAAC;IAC1C,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,EAC7C,eAAe,EACf,mBAAwB,EACxB,iBAAyB,EACzB,mBAAwB,EACxB,YAAY,EACZ,OAAO,EACP,UAAU,GACX,EAAE;IACD,eAAe,EAAE,mBAAmB,CAAC;IACrC,mBAAmB,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACpD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IAC9D,YAAY,EAAE,aAAa,CAAC;IAC5B,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC7B,GAAG,6BAA6B,CAiFhC;AAID,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,qBAAqB;IAIrB,IAAI;IAME,GAAG;YAuFK,aAAa;CAyH5B"}

package/dist/api/CheckBLEFirmwareRelease.d.ts

@@ -1,7 +1,8 @@
 import { BaseMethod } from './BaseMethod';
 export default class CheckBLEFirmwareRelease extends BaseMethod {
+    getSupportedProtocols(): readonly ["V1", "V2"];
     init(): void;
-    run(): Promise<null> | Promise<{
+    run(): Promise<import("..").FirmwareReleaseCheckResult | {
         status: import("..").IDeviceBLEFirmwareStatus;
         changelog: {
             "zh-CN": string;
@@ -9,6 +10,6 @@ export default class CheckBLEFirmwareRelease extends BaseMethod {
         }[];
         release: import("..").IBLEFirmwareReleaseInfo | undefined;
         bootloaderMode: boolean;
-    }>;
+    } | null>;
 }
 //# sourceMappingURL=CheckBLEFirmwareRelease.d.ts.map

package/dist/api/CheckBLEFirmwareRelease.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CheckBLEFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckBLEFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAI1C,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,IAAI;IAUJ,GAAG;;;;;;;;;CAOJ"}
+{"version":3,"file":"CheckBLEFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckBLEFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAY1C,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,qBAAqB;IAIrB,IAAI;IAUE,GAAG;;;;;;;;;CA2BV"}

package/dist/api/CheckBootloaderRelease.d.ts

@@ -1,7 +1,8 @@
 import { BaseMethod } from './BaseMethod';
 export default class CheckBootloaderRelease extends BaseMethod {
+    getSupportedProtocols(): readonly ["V1", "V2"];
     init(): void;
-    run(): Promise<{
+    run(): Promise<import("..").FirmwareReleaseCheckResult | {
         status: string;
         changelog: ({
             "zh-CN": string;

package/dist/api/CheckBootloaderRelease.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CheckBootloaderRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckBootloaderRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAO1C,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,UAAU;IAC5D,IAAI;IAME,GAAG;;;;;;;;;;CAiBV"}
+{"version":3,"file":"CheckBootloaderRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckBootloaderRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAc1C,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,UAAU;IAC5D,qBAAqB;IAIrB,IAAI;IAME,GAAG;;;;;;;;;;CAsCV"}