@onekeyfe/hd-core 1.2.0-alpha.96 → 1.2.0-alpha.97

package/__tests__/firmware-update/firmware-prepared-host-digest.test.ts

@@ -1,469 +0,0 @@
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
-
-import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
-import FirmwareUpdateV3 from '../../src/api/FirmwareUpdateV3';
-import FirmwareUpdateV4 from '../../src/api/FirmwareUpdateV4';
-import DeviceUpdateBootloader from '../../src/api/device/DeviceUpdateBootloader';
-import {
-  registerFirmwareUpdateHostBinding,
-  unregisterFirmwareUpdateHostBinding,
-} from '../../src/api/firmware/FirmwareHostBinding';
-import { prepareFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePreparedPlan';
-import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
-
-import type { FirmwareArtifactReference } from '../../src/types/api/firmwareUpdate';
-import type { Features } from '../../src/types';
-
-jest.mock('../../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-const noUpdate = {
-  status: 'valid' as const,
-  release: undefined,
-};
-
-const createPreparedPlan = ({
-  executor,
-  target,
-}: {
-  executor: 'v2' | 'v3';
-  target: 'firmware' | 'bootloader';
-}) => {
-  const sha256 = target === 'firmware' ? 'a'.repeat(64) : 'b'.repeat(64);
-  const artifact: FirmwareArtifactReference = {
-    artifactRef: `fw:${sha256}`,
-    size: 4,
-    sha256,
-  };
-  const isV3 = executor === 'v3';
-  const plan = buildFirmwareUpdatePlan({
-    features: {
-      deviceType: isV3 ? EDeviceType.Pro : EDeviceType.Classic1s,
-      serialNo: isV3 ? 'pro-device-id' : 'classic-device-id',
-      firmwareVersion: '1.0.0',
-      bootloaderVersion: isV3 ? '2.8.0' : '1.0.0',
-    } as Features,
-    firmwareType: EFirmwareType.Universal,
-    platform: 'desktop',
-    firmware:
-      target === 'firmware'
-        ? {
-            status: 'outdated',
-            release: {
-              url: 'https://firmware.onekey.so/firmware.bin',
-              expectedSize: artifact.size,
-              fingerprint: artifact.sha256,
-              version: [3, 0, 0],
-            },
-          }
-        : noUpdate,
-    ble: noUpdate,
-    bootloader:
-      target === 'bootloader'
-        ? {
-            status: 'outdated',
-            shouldUpdate: true,
-            release: {
-              bootloaderResource: 'https://firmware.onekey.so/bootloader.bin',
-              bootloaderExpectedSize: artifact.size,
-              bootloaderFingerprint: artifact.sha256,
-              bootloaderVersion: [2, 0, 0],
-            },
-          }
-        : noUpdate,
-  });
-  expect(plan.executor).toBe(executor);
-  const preparedPlan = prepareFirmwareUpdatePlan({
-    plan,
-    leaseRef: `fwlease:${executor}:${target}`,
-    artifacts: [{ artifactId: target, artifact }],
-  });
-  return { artifact, preparedPlan };
-};
-
-const registerMismatchedHost = () => {
-  const artifactReader = {
-    open: jest.fn(),
-    read: jest.fn(),
-    close: jest.fn(),
-  };
-  const hostBindingGeneration = registerFirmwareUpdateHostBinding({
-    preparedPlanDigest: 'f'.repeat(64),
-    artifactReader,
-  });
-  return { artifactReader, hostBindingGeneration };
-};
-
-const createPreparedV4Plan = () => {
-  const sha256 = 'c'.repeat(64);
-  const artifact: FirmwareArtifactReference = {
-    artifactRef: `fw:${sha256}`,
-    size: 4,
-    sha256,
-  };
-  const plan = buildFirmwareUpdatePlan({
-    features: {
-      deviceType: EDeviceType.Pro2,
-      serialNo: 'pro2-device-id',
-      firmwareVersion: '1.0.0',
-      bootloaderVersion: '1.0.0',
-    } as Features,
-    firmwareType: EFirmwareType.Universal,
-    platform: 'desktop',
-    firmware: {
-      status: 'outdated',
-      release: {
-        components: {
-          applicationP1: {
-            target: 'APPLICATION_P1',
-            url: 'https://firmware.onekey.so/pro2/application-p1.bin',
-            expectedSize: artifact.size,
-            fingerprint: artifact.sha256,
-          },
-        },
-      },
-    },
-    ble: noUpdate,
-    bootloader: noUpdate,
-  });
-  expect(plan.executor).toBe('v4');
-  const preparedPlan = prepareFirmwareUpdatePlan({
-    plan,
-    leaseRef: 'fwlease:v4:app_v1',
-    artifacts: [{ artifactId: 'component:app_v1', artifact }],
-  });
-  return { artifact, preparedPlan };
-};
-
-describe('prepared firmware host digest binding', () => {
-  afterEach(() => {
-    unregisterFirmwareUpdateHostBinding();
-    jest.restoreAllMocks();
-  });
-
-  test('FirmwareUpdateV2 rejects a host registered for another prepared plan', () => {
-    const { artifact, preparedPlan } = createPreparedPlan({
-      executor: 'v2',
-      target: 'firmware',
-    });
-    const { artifactReader, hostBindingGeneration } = registerMismatchedHost();
-    const method = new FirmwareUpdateV2({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV2',
-        platform: 'desktop',
-        updateType: 'firmware',
-        artifact,
-        preparedPlan,
-        hostBindingGeneration,
-      },
-    });
-
-    expect(() => method.init()).toThrow('does not match the prepared plan');
-    expect(artifactReader.open).not.toHaveBeenCalled();
-  });
-
-  test('FirmwareUpdateV2 rejects a direct reader when the prepared host generation is missing', () => {
-    const { artifact, preparedPlan } = createPreparedPlan({
-      executor: 'v2',
-      target: 'firmware',
-    });
-    const directArtifactReader = {
-      open: jest.fn(),
-      read: jest.fn(),
-      close: jest.fn(),
-    };
-    const method = new FirmwareUpdateV2({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV2',
-        platform: 'desktop',
-        updateType: 'firmware',
-        artifact,
-        preparedPlan,
-        artifactReader: directArtifactReader,
-      },
-    });
-
-    expect(() => method.init()).toThrow('host binding generation NaN is stale');
-    expect(directArtifactReader.open).not.toHaveBeenCalled();
-  });
-
-  test('FirmwareUpdateV2 does not treat a binary call carrying a prepared plan as legacy', () => {
-    const { preparedPlan } = createPreparedPlan({
-      executor: 'v2',
-      target: 'firmware',
-    });
-    const method = new FirmwareUpdateV2({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV2',
-        platform: 'desktop',
-        updateType: 'firmware',
-        binary: new ArrayBuffer(4),
-        preparedPlan,
-      },
-    });
-
-    expect(() => method.init()).toThrow('Prepared firmware plans require a prepared artifact');
-  });
-
-  test('FirmwareUpdateV3 rejects a host registered for another prepared plan', () => {
-    const { artifact, preparedPlan } = createPreparedPlan({
-      executor: 'v3',
-      target: 'firmware',
-    });
-    const { artifactReader, hostBindingGeneration } = registerMismatchedHost();
-    const method = new FirmwareUpdateV3({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV3',
-        platform: 'desktop',
-        artifacts: { firmware: artifact },
-        preparedPlan,
-        hostBindingGeneration,
-      },
-    });
-
-    expect(() => method.init()).toThrow('does not match the prepared plan');
-    expect(artifactReader.open).not.toHaveBeenCalled();
-  });
-
-  test('FirmwareUpdateV3 rejects a direct reader when the prepared host generation is missing', () => {
-    const { artifact, preparedPlan } = createPreparedPlan({
-      executor: 'v3',
-      target: 'firmware',
-    });
-    const directArtifactReader = {
-      open: jest.fn(),
-      read: jest.fn(),
-      close: jest.fn(),
-    };
-    const method = new FirmwareUpdateV3({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV3',
-        platform: 'desktop',
-        artifacts: { firmware: artifact },
-        preparedPlan,
-        artifactReader: directArtifactReader,
-      },
-    });
-
-    expect(() => method.init()).toThrow('host binding generation NaN is stale');
-    expect(directArtifactReader.open).not.toHaveBeenCalled();
-  });
-
-  test('FirmwareUpdateV3 does not execute legacy inputs outside the prepared plan', () => {
-    const { artifact, preparedPlan } = createPreparedPlan({
-      executor: 'v3',
-      target: 'firmware',
-    });
-    const method = new FirmwareUpdateV3({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV3',
-        platform: 'desktop',
-        artifacts: { firmware: artifact },
-        preparedPlan,
-        bleBinary: new ArrayBuffer(4),
-      },
-    });
-
-    expect(() => method.init()).toThrow(
-      'Prepared firmware plans cannot be combined with legacy firmware inputs'
-    );
-  });
-
-  test('DeviceUpdateBootloader rejects a host registered for another prepared plan', async () => {
-    const { artifact, preparedPlan } = createPreparedPlan({
-      executor: 'v2',
-      target: 'bootloader',
-    });
-    const { artifactReader, hostBindingGeneration } = registerMismatchedHost();
-    const method = new DeviceUpdateBootloader({
-      id: 1,
-      payload: {
-        method: 'deviceUpdateBootloader',
-        artifact,
-        preparedPlan,
-        hostBindingGeneration,
-      },
-    });
-    method.device = {
-      features: {
-        deviceType: EDeviceType.Classic1s,
-        serialNo: 'classic-device-id',
-      },
-    } as any;
-
-    await expect(method.run()).rejects.toThrow('does not match the prepared plan');
-    expect(artifactReader.open).not.toHaveBeenCalled();
-  });
-
-  test('DeviceUpdateBootloader rejects a direct reader when the prepared host generation is missing', async () => {
-    const { artifact, preparedPlan } = createPreparedPlan({
-      executor: 'v2',
-      target: 'bootloader',
-    });
-    const directArtifactReader = {
-      open: jest.fn(),
-      read: jest.fn(),
-      close: jest.fn(),
-    };
-    const method = new DeviceUpdateBootloader({
-      id: 1,
-      payload: {
-        method: 'deviceUpdateBootloader',
-        artifact,
-        preparedPlan,
-        artifactReader: directArtifactReader,
-      },
-    });
-    method.device = {
-      features: {
-        deviceType: EDeviceType.Classic1s,
-        serialNo: 'classic-device-id',
-      },
-    } as any;
-
-    await expect(method.run()).rejects.toThrow('host binding generation NaN is stale');
-    expect(directArtifactReader.open).not.toHaveBeenCalled();
-  });
-
-  test('DeviceUpdateBootloader does not treat a binary call carrying a prepared plan as legacy', async () => {
-    const { preparedPlan } = createPreparedPlan({
-      executor: 'v2',
-      target: 'bootloader',
-    });
-    const method = new DeviceUpdateBootloader({
-      id: 1,
-      payload: {
-        method: 'deviceUpdateBootloader',
-        binary: new ArrayBuffer(4),
-        preparedPlan,
-      },
-    });
-    method.device = { features: undefined } as any;
-
-    await expect(method.run()).rejects.toThrow(
-      'Prepared bootloader plans require exactly one prepared artifact'
-    );
-  });
-
-  test('FirmwareUpdateV4 rejects a prepared plan without a host binding generation', () => {
-    const { preparedPlan } = createPreparedV4Plan();
-    const directArtifactReader = {
-      open: jest.fn(),
-      read: jest.fn(),
-      close: jest.fn(),
-    };
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'desktop',
-        preparedPlan,
-        artifactReader: directArtifactReader,
-      },
-    });
-
-    expect(() => method.init()).toThrow('host binding generation NaN is stale');
-    expect(directArtifactReader.open).not.toHaveBeenCalled();
-  });
-
-  test('FirmwareUpdateV4 rejects a host registered for another prepared plan', () => {
-    const { preparedPlan } = createPreparedV4Plan();
-    const { artifactReader, hostBindingGeneration } = registerMismatchedHost();
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'desktop',
-        preparedPlan,
-        hostBindingGeneration,
-      },
-    });
-
-    expect(() => method.init()).toThrow('does not match the prepared plan');
-    expect(artifactReader.open).not.toHaveBeenCalled();
-  });
-
-  test('FirmwareUpdateV4 obtains the prepared reader only from the digest-bound host', async () => {
-    const { artifact, preparedPlan } = createPreparedV4Plan();
-    const directArtifactReader = {
-      open: jest.fn(),
-      read: jest.fn(),
-      close: jest.fn(),
-    };
-    const boundArtifactReader = {
-      open: jest.fn().mockResolvedValue({ readerId: 'bound-reader', size: artifact.size }),
-      read: jest.fn(),
-      close: jest.fn(),
-    };
-    const hostBindingGeneration = registerFirmwareUpdateHostBinding({
-      preparedPlanDigest: preparedPlan.preparedPlanDigest,
-      artifactReader: boundArtifactReader,
-    });
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'desktop',
-        preparedPlan,
-        hostBindingGeneration,
-        artifactReader: directArtifactReader,
-      },
-    });
-
-    method.init();
-    const executionReader = (
-      method as unknown as {
-        params: { artifactReader: typeof boundArtifactReader };
-      }
-    ).params.artifactReader;
-    await executionReader.open({ artifactRef: artifact.artifactRef });
-
-    expect(boundArtifactReader.open).toHaveBeenCalledWith({ artifactRef: artifact.artifactRef });
-    expect(directArtifactReader.open).not.toHaveBeenCalled();
-  });
-
-  test('keeps non-prepared direct binary calls on the legacy paths', async () => {
-    const v2 = new FirmwareUpdateV2({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV2',
-        platform: 'desktop',
-        updateType: 'firmware',
-        binary: new ArrayBuffer(4),
-      },
-    });
-    const v3 = new FirmwareUpdateV3({
-      id: 2,
-      payload: {
-        method: 'firmwareUpdateV3',
-        platform: 'desktop',
-        firmwareBinary: new ArrayBuffer(4),
-      },
-    });
-    const bootloader = new DeviceUpdateBootloader({
-      id: 3,
-      payload: {
-        method: 'deviceUpdateBootloader',
-        binary: new ArrayBuffer(4),
-      },
-    });
-    bootloader.device = {
-      features: {},
-      getCurrentDeviceType: () => EDeviceType.Touch,
-      getCurrentFirmwareType: () => EFirmwareType.Universal,
-    } as any;
-    jest.spyOn(bootloader, 'updateTouchBootloader').mockResolvedValue(true);
-
-    expect(() => v2.init()).not.toThrow();
-    expect(() => v3.init()).not.toThrow();
-    await expect(bootloader.run()).resolves.toBe(true);
-  });
-});

package/dist/api/firmware/FirmwareMemoryHost.d.ts

@@ -1,22 +0,0 @@
-import type { CoreApi } from '../../types/api';
-import type { FirmwareUpdatePlan } from '../../types/api/firmwareUpdatePlan';
-export type FirmwareMemoryArtifactEntry = {
-    entryName: string;
-    binary: ArrayBuffer;
-};
-export type FirmwareMemoryArtifact = {
-    artifactId: string;
-    binary: ArrayBuffer;
-    materializedEntries?: FirmwareMemoryArtifactEntry[];
-};
-export type FirmwareUpdateV4MemoryHost = {
-    preparedPlan: ReturnType<CoreApi['prepareFirmwareUpdatePlan']>;
-    hostBindingGeneration: number;
-    release: () => void;
-};
-export declare function prepareFirmwareUpdateV4MemoryHost({ sdk, plan, artifacts, }: {
-    sdk: Pick<CoreApi, 'prepareFirmwareUpdatePlan' | 'registerFirmwareUpdateHostBinding' | 'unregisterFirmwareUpdateHostBinding'>;
-    plan: FirmwareUpdatePlan;
-    artifacts: FirmwareMemoryArtifact[];
-}): FirmwareUpdateV4MemoryHost;
-//# sourceMappingURL=FirmwareMemoryHost.d.ts.map

package/dist/api/firmware/FirmwareMemoryHost.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FirmwareMemoryHost.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/FirmwareMemoryHost.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAK/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAE7E,MAAM,MAAM,2BAA2B,GAAG;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,WAAW,CAAC;IACpB,mBAAmB,CAAC,EAAE,2BAA2B,EAAE,CAAC;CACrD,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,YAAY,EAAE,UAAU,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC,CAAC;IAC/D,qBAAqB,EAAE,MAAM,CAAC;IAC9B,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAaF,wBAAgB,iCAAiC,CAAC,EAChD,GAAG,EACH,IAAI,EACJ,SAAS,GACV,EAAE;IACD,GAAG,EAAE,IAAI,CACP,OAAO,EACL,2BAA2B,GAC3B,mCAAmC,GACnC,qCAAqC,CACxC,CAAC;IACF,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,sBAAsB,EAAE,CAAC;CACrC,GAAG,0BAA0B,CAyF7B"}

package/dist/api/firmware/protocolV2Release.d.ts

@@ -1,33 +0,0 @@
-import { EFirmwareType } from '@onekeyfe/hd-shared';
-import type { EDeviceType } from '@onekeyfe/hd-shared';
-import type { Device } from '../../device/Device';
-import type { DeviceState, Features, IFirmwareReleaseInfo, IProtocolV2FirmwareComponentTarget } from '../../types';
-import type { FirmwareReleaseCheckResult, ProtocolV2ComponentReleaseInfo } from '../../types/api/checkAllFirmwareRelease';
-import type { ProtocolV2FirmwareReleasePlan } from '../CheckAllFirmwareRelease';
-export declare const PROTOCOL_V2_MAIN_FIRMWARE_TARGETS: readonly IProtocolV2FirmwareComponentTarget[];
-export declare const PROTOCOL_V2_BLE_TARGETS: readonly IProtocolV2FirmwareComponentTarget[];
-export declare const PROTOCOL_V2_BOOTLOADER_TARGETS: readonly IProtocolV2FirmwareComponentTarget[];
-export type ProtocolV2FirmwareReleaseContext = {
-    state: Omit<DeviceState, 'identity'> & {
-        identity: Omit<DeviceState['identity'], 'deviceType'> & {
-            deviceType: EDeviceType.Pro2 | EDeviceType.Neo;
-        };
-    };
-    features: Features;
-    firmwareType: EFirmwareType;
-    release: IFirmwareReleaseInfo | undefined;
-};
-export declare function loadProtocolV2FirmwareReleaseContext({ device, firmwareType: firmwareTypeParam, checkFirmwareHash, methodName, }: {
-    device: Device;
-    firmwareType?: EFirmwareType;
-    checkFirmwareHash?: boolean;
-    methodName: string;
-}): Promise<ProtocolV2FirmwareReleaseContext>;
-export declare function summarizeProtocolV2FirmwareRelease(plan: ProtocolV2FirmwareReleasePlan, componentTargets: readonly IProtocolV2FirmwareComponentTarget[]): ProtocolV2FirmwareReleasePlan;
-export declare function toProtocolV2FirmwareReleaseInfo({ plan, state, release, }: {
-    plan: ProtocolV2FirmwareReleasePlan;
-    state: DeviceState;
-    release: FirmwareReleaseCheckResult['release'];
-}): FirmwareReleaseCheckResult;
-export declare function getProtocolV2ComponentReleaseInfo(plan: ProtocolV2FirmwareReleasePlan, componentTarget: IProtocolV2FirmwareComponentTarget): ProtocolV2ComponentReleaseInfo | undefined;
-//# sourceMappingURL=protocolV2Release.d.ts.map

package/dist/api/firmware/protocolV2Release.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocolV2Release.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/protocolV2Release.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA6B,MAAM,qBAAqB,CAAC;AAI/E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EACV,WAAW,EACX,QAAQ,EACR,oBAAoB,EACpB,kCAAkC,EACnC,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EACV,0BAA0B,EAC1B,8BAA8B,EAE/B,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAEhF,eAAO,MAAM,iCAAiC,EAAE,SAAS,kCAAkC,EAO1F,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,SAAS,kCAAkC,EAEhF,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,SAAS,kCAAkC,EAEvF,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC7C,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,GAAG;QACrC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,GAAG;YACtD,UAAU,EAAE,WAAW,CAAC,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC;SAChD,CAAC;KACH,CAAC;IACF,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,aAAa,CAAC;IAC5B,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,wBAAsB,oCAAoC,CAAC,EACzD,MAAM,EACN,YAAY,EAAE,iBAAiB,EAC/B,iBAAyB,EACzB,UAAU,GACX,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,aAAa,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,gCAAgC,CAAC,CA4B5C;AAED,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,6BAA6B,EACnC,gBAAgB,EAAE,SAAS,kCAAkC,EAAE,GAC9D,6BAA6B,CAiC/B;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,IAAI,EACJ,KAAK,EACL,OAAO,GACR,EAAE;IACD,IAAI,EAAE,6BAA6B,CAAC;IACpC,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,0BAA0B,CAAC,SAAS,CAAC,CAAC;CAChD,GAAG,0BAA0B,CAU7B;AAED,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,6BAA6B,EACnC,eAAe,EAAE,kCAAkC,GAClD,8BAA8B,GAAG,SAAS,CAmB5C"}

package/src/api/firmware/FirmwareMemoryHost.ts

@@ -1,142 +0,0 @@
-import { sha256 } from '@noble/hashes/sha256';
-import { bytesToHex } from '@noble/hashes/utils';
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import type { CoreApi } from '../../types/api';
-import type {
-  FirmwareArtifactReader,
-  FirmwareArtifactReference,
-} from '../../types/api/firmwareUpdate';
-import type { FirmwareUpdatePlan } from '../../types/api/firmwareUpdatePlan';
-
-export type FirmwareMemoryArtifactEntry = {
-  entryName: string;
-  binary: ArrayBuffer;
-};
-
-export type FirmwareMemoryArtifact = {
-  artifactId: string;
-  binary: ArrayBuffer;
-  materializedEntries?: FirmwareMemoryArtifactEntry[];
-};
-
-export type FirmwareUpdateV4MemoryHost = {
-  preparedPlan: ReturnType<CoreApi['prepareFirmwareUpdatePlan']>;
-  hostBindingGeneration: number;
-  release: () => void;
-};
-
-let memoryHostSequence = 0;
-
-const createReference = (binary: ArrayBuffer, prefix: string): FirmwareArtifactReference => {
-  const digest = bytesToHex(sha256(new Uint8Array(binary)));
-  return {
-    artifactRef: `fwmem:${prefix}:${digest.slice(0, 32)}`,
-    size: binary.byteLength,
-    sha256: digest,
-  };
-};
-
-export function prepareFirmwareUpdateV4MemoryHost({
-  sdk,
-  plan,
-  artifacts,
-}: {
-  sdk: Pick<
-    CoreApi,
-    | 'prepareFirmwareUpdatePlan'
-    | 'registerFirmwareUpdateHostBinding'
-    | 'unregisterFirmwareUpdateHostBinding'
-  >;
-  plan: FirmwareUpdatePlan;
-  artifacts: FirmwareMemoryArtifact[];
-}): FirmwareUpdateV4MemoryHost {
-  if (plan.executor !== 'v4') {
-    throw ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Firmware memory host only supports V4 plans'
-    );
-  }
-  memoryHostSequence += 1;
-  const hostId = `${Date.now()}:${memoryHostSequence}`;
-  const binaries = new Map<string, Uint8Array>();
-  const inputs = artifacts.map((input, artifactIndex) => {
-    const artifactBinary = new Uint8Array(input.binary).slice();
-    const artifact = createReference(
-      artifactBinary.buffer as ArrayBuffer,
-      `${hostId}:artifact:${artifactIndex}`
-    );
-    binaries.set(artifact.artifactRef, artifactBinary);
-    const materializedEntries = input.materializedEntries?.map((entry, entryIndex) => {
-      const entryBinary = new Uint8Array(entry.binary).slice();
-      const entryArtifact = createReference(
-        entryBinary.buffer as ArrayBuffer,
-        `${hostId}:entry:${artifactIndex}:${entryIndex}`
-      );
-      binaries.set(entryArtifact.artifactRef, entryBinary);
-      return {
-        entryName: entry.entryName,
-        artifact: entryArtifact,
-      };
-    });
-    return {
-      artifactId: input.artifactId,
-      artifact,
-      ...(materializedEntries?.length ? { materializedEntries } : {}),
-    };
-  });
-  const preparedPlan = sdk.prepareFirmwareUpdatePlan({
-    plan,
-    leaseRef: `fwmemlease:${hostId}`,
-    artifacts: inputs,
-  });
-  const readers = new Map<string, Uint8Array>();
-  let readerSequence = 0;
-  const artifactReader: FirmwareArtifactReader = {
-    open({ artifactRef }) {
-      const binary = binaries.get(artifactRef);
-      if (!binary) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Firmware memory artifact is unavailable'
-        );
-      }
-      readerSequence += 1;
-      const readerId = `fwmemreader:${hostId}:${readerSequence}`;
-      readers.set(readerId, binary);
-      return Promise.resolve({ readerId, size: binary.byteLength });
-    },
-    read({ readerId, offset, length }) {
-      const binary = readers.get(readerId);
-      if (!binary || offset < 0 || length <= 0 || offset + length > binary.byteLength) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Firmware memory artifact read is invalid'
-        );
-      }
-      const data = binary.slice(offset, offset + length).buffer;
-      return Promise.resolve({
-        data,
-        bytesRead: data.byteLength,
-        eof: offset + length === binary.byteLength,
-      });
-    },
-    close({ readerId }) {
-      readers.delete(readerId);
-      return Promise.resolve();
-    },
-  };
-  const hostBindingGeneration = sdk.registerFirmwareUpdateHostBinding({
-    artifactReader,
-    preparedPlanDigest: preparedPlan.preparedPlanDigest,
-  });
-  return {
-    preparedPlan,
-    hostBindingGeneration,
-    release: () => {
-      sdk.unregisterFirmwareUpdateHostBinding(hostBindingGeneration);
-      readers.clear();
-      binaries.clear();
-    },
-  };
-}