@onekeyfe/hd-core 1.2.0-alpha.50 → 1.2.0-alpha.52

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

@@ -1,284 +0,0 @@
-import axios from 'axios';
-import { sha256 } from '@noble/hashes/sha256';
-
-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: 'CRATE',
-  url: 'https://example.com/boot-resources.crate.okpkg',
-  size: 1234,
-  fileHash: 'ab'.repeat(32),
-  payloadHash: 'cd'.repeat(64),
-  headerHash: 'ef'.repeat(64),
-};
-
-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 a CRATE package', () => {
-    expect(() =>
-      parseProtocolV2Resources({
-        stable: resources,
-        boot: { ...bootResources, required: true },
-      })
-    ).toThrow('required flag');
-    expect(() =>
-      parseProtocolV2Resources({
-        stable: resources,
-        boot: { ...bootResources, target: 'RESC' },
-      })
-    ).toThrow('expected CRATE');
-  });
-
-  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('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.toThrow(
-      'Unable to refresh the latest remote config'
-    );
-    expect(DataManager.lastCheckTimestamp).toBe(0);
-  });
-});

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

@@ -1,91 +0,0 @@
-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
-    );
-  });
-});

package/__tests__/uiProgressThrottle.test.ts

@@ -1,74 +0,0 @@
-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

@@ -1,86 +0,0 @@
-import { createDeferred } from '@onekeyfe/hd-shared';
-
-import { findUiPromiseForResponse } 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('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);
-  });
-});

package/dist/api/DetectDeviceConnectProtocol.d.ts

@@ -1,7 +0,0 @@
-import { BaseMethod } from './BaseMethod';
-export default class DetectDeviceConnectProtocol extends BaseMethod {
-    init(): void;
-    getSupportedProtocols(): readonly ["V1", "V2"];
-    run(): Promise<"V1" | "V2">;
-}
-//# sourceMappingURL=DetectDeviceConnectProtocol.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"DetectDeviceConnectProtocol.d.ts","sourceRoot":"","sources":["../../src/api/DetectDeviceConnectProtocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,2BAA4B,SAAQ,UAAU;IACjE,IAAI;IAOJ,qBAAqB;IAIrB,GAAG;CAGJ"}

package/dist/api/protocol-v2/DeviceUploadNft.d.ts

@@ -1,31 +0,0 @@
-import { type Pro2NftImage } from '../../utils/pro2Nft';
-import { BaseMethod } from '../BaseMethod';
-export type DeviceUploadNftParams = {
-    image: Pro2NftImage;
-    thumbnail: Pro2NftImage;
-    title: string;
-    subtitle: string;
-    timestampMs?: number;
-    chunkSize?: number;
-    paceMs?: number;
-    timeoutMs?: number;
-};
-export type DeviceUploadNftResponse = {
-    basename: string;
-    imagePath: string;
-    thumbnailPath: string;
-    metadataPath: string;
-    totalSize: number;
-    nftUpdated: true;
-    message?: string;
-};
-export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
-    private bundle?;
-    getSupportedProtocols(): readonly ["V2"];
-    init(): void;
-    private assertCapabilities;
-    private assertStorageCapacity;
-    private updateNft;
-    run(): Promise<DeviceUploadNftResponse>;
-}
-//# sourceMappingURL=DeviceUploadNft.d.ts.map

package/dist/api/protocol-v2/DeviceUploadNft.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DeviceUploadNft.d.ts","sourceRoot":"","sources":["../../../src/api/protocol-v2/DeviceUploadNft.ts"],"names":[],"mappings":"AAIA,OAAO,EASL,KAAK,YAAY,EAGlB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,YAAY,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,IAAI,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAMF,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,UAAU,CAAC,qBAAqB,CAAC;IAC5E,OAAO,CAAC,MAAM,CAAC,CAAgB;IAE/B,qBAAqB;IAIrB,IAAI;YAkCU,kBAAkB;YAalB,qBAAqB;YAgBrB,SAAS;IAcjB,GAAG,IAAI,OAAO,CAAC,uBAAuB,CAAC;CA0D9C"}

package/dist/core/uiPromiseRegistry.d.ts

@@ -1,4 +0,0 @@
-import type { UiPromise, UiPromiseResponse } from '../events/ui-promise';
-import type { UiResponseEvent } from '../events/ui-response';
-export declare const findUiPromiseForResponse: (uiPromises: UiPromise<UiPromiseResponse['type']>[], response: UiResponseEvent) => UiPromise<"ui-receive_pin" | "ui-receive_passphrase" | "ui-receive_select-device-in-bootloader-for-web-device" | "ui-receive_select-device-for-switch-firmware-web-device" | "device-disconnect"> | undefined;
-//# sourceMappingURL=uiPromiseRegistry.d.ts.map

package/dist/core/uiPromiseRegistry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uiPromiseRegistry.d.ts","sourceRoot":"","sources":["../../src/core/uiPromiseRegistry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAS7D,eAAO,MAAM,wBAAwB,eACvB,UAAU,iBAAiB,CAAC,MAAM,CAAC,CAAC,EAAE,YACxC,eAAe,kNA0B1B,CAAC"}

package/dist/protocols/protocol-v2/resources.d.ts

@@ -1,30 +0,0 @@
-import type { IProtocolV2Resource, IProtocolV2ResourceType, IProtocolV2Resources } from '../../types';
-import type { DeviceCommands } from '../../device/DeviceCommands';
-export declare const PROTOCOL_V2_RESOURCE_TYPES: readonly ["images", "animation", "wallpaper", "translations", "roobert", "noto"];
-export declare const PROTOCOL_V2_RESOURCE_DEVICE_PATHS: Readonly<Record<IProtocolV2ResourceType, string>>;
-export declare const PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS: number;
-export type ProtocolV2ResourceInventoryItem = {
-    type: IProtocolV2ResourceType;
-    size: number;
-    headerHash: string;
-};
-export type ProtocolV2ResourceUpdateMode = 'application' | 'bootloader-recovery';
-export type ProtocolV2ResourceUpdatePlan = {
-    status: 'valid' | 'outdated' | 'unknown';
-    resources: IProtocolV2Resource[];
-};
-export declare function readProtocolV2ResourceInventory({ commands, resources, chunkSize, timeoutMs, }: {
-    commands: Pick<DeviceCommands, 'typedCall'>;
-    resources: readonly IProtocolV2Resource[];
-    chunkSize?: number;
-    timeoutMs?: number;
-}): Promise<ProtocolV2ResourceInventoryItem[]>;
-export declare function parseProtocolV2Resources(value: unknown): IProtocolV2Resources | undefined;
-export declare function buildProtocolV2ResourceUpdatePlan({ resources, inventory, mode, forced, }: {
-    resources: readonly IProtocolV2Resource[];
-    inventory?: readonly ProtocolV2ResourceInventoryItem[];
-    mode: ProtocolV2ResourceUpdateMode;
-    forced?: boolean;
-}): ProtocolV2ResourceUpdatePlan;
-export declare function isProtocolV2ResourceFileValid(binary: ArrayBuffer, resource: Pick<IProtocolV2Resource, 'size' | 'fileHash'>): boolean;
-//# sourceMappingURL=resources.d.ts.map

package/dist/protocols/protocol-v2/resources.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/protocols/protocol-v2/resources.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE,eAAO,MAAM,0BAA0B,kFAOgB,CAAC;AAExD,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,MAAM,CAAC,uBAAuB,EAAE,MAAM,CAAC,CAQ7F,CAAC;AAaJ,eAAO,MAAM,yCAAyC,QAAW,CAAC;AAElE,MAAM,MAAM,+BAA+B,GAAG;IAC5C,IAAI,EAAE,uBAAuB,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,aAAa,GAAG,qBAAqB,CAAC;AAEjF,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;IACzC,SAAS,EAAE,mBAAmB,EAAE,CAAC;CAClC,CAAC;AAwHF,wBAAsB,+BAA+B,CAAC,EACpD,QAAQ,EACR,SAAS,EACT,SAAgD,EAChD,SAAqD,GACtD,EAAE;IACD,QAAQ,EAAE,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;IAC5C,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,+BAA+B,EAAE,CAAC,CAmB7C;AAmED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,GAAG,SAAS,CAgCzF;AAGD,wBAAgB,iCAAiC,CAAC,EAChD,SAAS,EACT,SAAS,EACT,IAAI,EACJ,MAAc,GACf,EAAE;IACD,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC1C,SAAS,CAAC,EAAE,SAAS,+BAA+B,EAAE,CAAC;IACvD,IAAI,EAAE,4BAA4B,CAAC;IACnC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,GAAG,4BAA4B,CA8B/B;AAOD,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,IAAI,CAAC,mBAAmB,EAAE,MAAM,GAAG,UAAU,CAAC,GACvD,OAAO,CAGT"}

package/dist/protocols/protocol-v2/unlockPolicyRunner.d.ts

@@ -1,22 +0,0 @@
-import type { BaseMethod } from '../../api/BaseMethod';
-import type { Device } from '../../device/Device';
-import type { ProtocolV2UiInteractionCoordinator } from './uiInteraction';
-export type ProtocolV2UnlockContext = {
-    preflightCompleted: boolean;
-};
-export declare const createProtocolV2UnlockContext: () => ProtocolV2UnlockContext;
-type RunnableMethod = Pick<BaseMethod, 'run' | 'unlockPolicy' | 'useDevicePassphraseState' | 'protocolV2UiInteraction' | 'protocolV2UiMode' | 'params' | 'payload'> & {
-    name?: string;
-    protocolV2UnlockContext?: ProtocolV2UnlockContext;
-};
-type UiInteractionCoordinator = Pick<ProtocolV2UiInteractionCoordinator, 'enterMethodInteraction' | 'enterUnlockInteraction'>;
-type RunMethodWithUnlockPolicyOptions<T> = {
-    context?: ProtocolV2UnlockContext;
-    uiCoordinator?: UiInteractionCoordinator;
-    afterStatusBeforeUnlock?: () => void | Promise<void>;
-    prepare?: () => Promise<void>;
-    run?: () => Promise<T>;
-};
-export declare function runMethodWithUnlockPolicy<T = unknown>(method: RunnableMethod, device: Device, options?: RunMethodWithUnlockPolicyOptions<T>): Promise<T>;
-export {};
-//# sourceMappingURL=unlockPolicyRunner.d.ts.map

package/dist/protocols/protocol-v2/unlockPolicyRunner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unlockPolicyRunner.d.ts","sourceRoot":"","sources":["../../../src/protocols/protocol-v2/unlockPolicyRunner.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,iBAAiB,CAAC;AAI1E,MAAM,MAAM,uBAAuB,GAAG;IACpC,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,eAAO,MAAM,6BAA6B,QAAO,uBAE/C,CAAC;AAEH,KAAK,cAAc,GAAG,IAAI,CACxB,UAAU,EACR,KAAK,GACL,cAAc,GACd,0BAA0B,GAC1B,yBAAyB,GACzB,kBAAkB,GAClB,QAAQ,GACR,SAAS,CACZ,GAAG;IACF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uBAAuB,CAAC,EAAE,uBAAuB,CAAC;CACnD,CAAC;AAEF,KAAK,wBAAwB,GAAG,IAAI,CAClC,kCAAkC,EAClC,wBAAwB,GAAG,wBAAwB,CACpD,CAAC;AAEF,KAAK,gCAAgC,CAAC,CAAC,IAAI;IACzC,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAClC,aAAa,CAAC,EAAE,wBAAwB,CAAC;IACzC,uBAAuB,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;CACxB,CAAC;AAEF,wBAAsB,yBAAyB,CAAC,CAAC,GAAG,OAAO,EACzD,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,gCAAgC,CAAC,CAAC,CAAM,GAChD,OAAO,CAAC,CAAC,CAAC,CAuEZ"}

package/dist/types/api/detectDeviceConnectProtocol.d.ts

@@ -1,4 +0,0 @@
-import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
-import type { Response } from '../params';
-export declare function detectDeviceConnectProtocol(connectId: string): Response<HardwareConnectProtocol>;
-//# sourceMappingURL=detectDeviceConnectProtocol.d.ts.map

package/dist/types/api/detectDeviceConnectProtocol.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"detectDeviceConnectProtocol.d.ts","sourceRoot":"","sources":["../../../src/types/api/detectDeviceConnectProtocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1C,MAAM,CAAC,OAAO,UAAU,2BAA2B,CACjD,SAAS,EAAE,MAAM,GAChB,QAAQ,CAAC,uBAAuB,CAAC,CAAC"}