@onekeyfe/hd-core 1.2.0-alpha.21 → 1.2.0-alpha.23

package/__tests__/firmware-update/firmware-update-v2-download-before-boot.test.ts

@@ -2,7 +2,7 @@ import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shar
 
 import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
 import { getBinary } from '../../src/api/firmware/getBinary';
-import { uploadFirmware } from '../../src/api/firmware/uploadFirmware';
+import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
 import * as utils from '../../src/utils';
 
 jest.mock('../../src/data/config', () => ({
@@ -18,7 +18,8 @@ jest.mock('../../src/api/firmware/getBinary', () => ({
 
 jest.mock('../../src/api/firmware/uploadFirmware', () => ({
   updateResources: jest.fn(),
-  uploadFirmware: jest.fn(),
+  updateResourcesFromSources: jest.fn(),
+  uploadFirmwareFromSource: jest.fn(),
 }));
 
 jest.mock('../../src/device/DevicePool', () => ({
@@ -29,7 +30,9 @@ jest.mock('../../src/device/DevicePool', () => ({
 }));
 
 const mockGetBinary = getBinary as jest.MockedFunction<typeof getBinary>;
-const mockUploadFirmware = uploadFirmware as jest.MockedFunction<typeof uploadFirmware>;
+const mockUploadFirmwareFromSource = uploadFirmwareFromSource as jest.MockedFunction<
+  typeof uploadFirmwareFromSource
+>;
 
 type DeviceType = 'CLASSIC1S' | 'PURE';
 
@@ -175,7 +178,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).toHaveBeenCalledTimes(1);
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmware).not.toHaveBeenCalled();
+    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -216,9 +219,11 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           binary: firmwareBinary,
         } as Awaited<ReturnType<typeof getBinary>>);
       });
-      mockUploadFirmware.mockImplementation(() => {
+      mockUploadFirmwareFromSource.mockImplementation(() => {
         callOrder.push('upload');
-        return Promise.resolve(expectedResponse as Awaited<ReturnType<typeof uploadFirmware>>);
+        return Promise.resolve(
+          expectedResponse as Awaited<ReturnType<typeof uploadFirmwareFromSource>>
+        );
       });
       const { method, typedCall } = createMethod({
         updateType,
@@ -248,15 +253,15 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           },
         })
       );
-      expect(mockUploadFirmware).toHaveBeenCalledWith(
+      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
         updateType,
         expect.any(Function),
         expect.any(Function),
         method.device,
-        {
-          payload: firmwareBinary,
-          rebootOnSuccess: true,
-        },
+        expect.objectContaining({
+          size: firmwareBinary.byteLength,
+        }),
+        true,
         isUpdateBootloader
       );
     }
@@ -271,11 +276,11 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
         binary: firmwareBinary,
       } as Awaited<ReturnType<typeof getBinary>>);
     });
-    mockUploadFirmware.mockImplementation(() => {
+    mockUploadFirmwareFromSource.mockImplementation(() => {
       callOrder.push('upload');
       return Promise.resolve({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmware>>);
+      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
     });
     const { method, typedCall, acquire } = createMethod({
       bootloaderMode: true,
@@ -300,9 +305,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           resolveDownload = resolve;
         })
     );
-    mockUploadFirmware.mockResolvedValue({
+    mockUploadFirmwareFromSource.mockResolvedValue({
       success: true,
-    } as Awaited<ReturnType<typeof uploadFirmware>>);
+    } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
     const { method, typedCall } = createMethod();
 
     const runPromise = method.run();
@@ -333,7 +338,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
 
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmware).not.toHaveBeenCalled();
+    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -342,23 +347,23 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
   ])(
     'keeps the non-empty %s binary overload and never downloads it again',
     async (_kind, binary) => {
-      mockUploadFirmware.mockResolvedValue({
+      mockUploadFirmwareFromSource.mockResolvedValue({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmware>>);
+      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
       const { method } = createMethod({ binary });
 
       await method.run();
 
       expect(mockGetBinary).not.toHaveBeenCalled();
-      expect(mockUploadFirmware).toHaveBeenCalledWith(
+      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
         'firmware',
         expect.any(Function),
         expect.any(Function),
         method.device,
-        {
-          payload: binary,
-          rebootOnSuccess: true,
-        },
+        expect.objectContaining({
+          size: binary.byteLength,
+        }),
+        true,
         undefined
       );
     }
@@ -369,17 +374,21 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     ['DataView', new DataView(new Uint8Array([9, 3, 4, 9]).buffer, 1, 2), [3, 4]],
     ['custom Buffer', createCustomBuffer(4), [1, 2, 3, 4]],
   ])('normalizes a non-empty %s before rebooting', async (_kind, binary, expectedBytes) => {
-    mockUploadFirmware.mockResolvedValue({
-      success: true,
-    } as Awaited<ReturnType<typeof uploadFirmware>>);
+    let uploadedBytes: number[] = [];
+    mockUploadFirmwareFromSource.mockImplementation(
+      async (_updateType, _typedCall, _postMessage, _device, source) => {
+        uploadedBytes = Array.from(new Uint8Array(await source.readAt(0, source.size)));
+        return {
+          success: true,
+        } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>;
+      }
+    );
     const { method } = createMethod({ binary });
 
     await method.run();
 
     expect(mockGetBinary).not.toHaveBeenCalled();
-    const normalizedBinary = mockUploadFirmware.mock.calls[0][4].payload;
-    expect(normalizedBinary).toBeInstanceOf(ArrayBuffer);
-    expect(Array.from(new Uint8Array(normalizedBinary))).toEqual(expectedBytes);
+    expect(uploadedBytes).toEqual(expectedBytes);
   });
 
   it.each([
@@ -397,6 +406,6 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).not.toHaveBeenCalled();
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmware).not.toHaveBeenCalled();
+    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
   });
 });

package/__tests__/firmware-update/firmware-upload-source.test.ts

@@ -0,0 +1,70 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
+
+import type { Device } from '../../src/device/Device';
+import type { FirmwareByteSource } from '../../src/api/firmware/FirmwareArtifactSource';
+
+jest.mock('../../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('uploadFirmwareFromSource', () => {
+  it('serves legacy Touch firmware requests without materializing the complete artifact', async () => {
+    const size = 700 * 1024;
+    const requestedRanges: Array<{ offset: number; length: number }> = [];
+    const source: FirmwareByteSource = {
+      size,
+      readAt: jest.fn((offset: number, length: number) => {
+        requestedRanges.push({ offset, length });
+        return Promise.resolve(new ArrayBuffer(length));
+      }),
+      close: jest.fn(() => Promise.resolve()),
+    };
+    let nextOffset = 0;
+    const requestedLength = 128 * 1024;
+    const typedCall = jest.fn((type: string) => {
+      if (type === 'FirmwareErase') {
+        return Promise.resolve({
+          type: 'FirmwareRequest',
+          message: {
+            offset: nextOffset,
+            length: Math.min(requestedLength, size - nextOffset),
+          },
+        });
+      }
+      if (type === 'FirmwareUpload') {
+        nextOffset += Math.min(requestedLength, size - nextOffset);
+        if (nextOffset < size) {
+          return Promise.resolve({
+            type: 'FirmwareRequest',
+            message: {
+              offset: nextOffset,
+              length: Math.min(requestedLength, size - nextOffset),
+            },
+          });
+        }
+        return Promise.resolve({
+          type: 'Success',
+          message: { message: 'installed' },
+        });
+      }
+      return Promise.reject(new Error(`Unexpected command: ${type}`));
+    });
+    const device = {
+      features: undefined,
+      emit: jest.fn(),
+      getCurrentDeviceType: () => EDeviceType.Touch,
+      toMessageObject: () => ({}),
+    } as unknown as Device;
+
+    await expect(
+      uploadFirmwareFromSource('firmware', typedCall as never, jest.fn(), device, source)
+    ).resolves.toEqual({ message: 'installed' });
+
+    expect(requestedRanges).toHaveLength(Math.ceil(size / requestedLength));
+    expect(requestedRanges.every(({ length }) => length <= 256 * 1024)).toBe(true);
+    expect(requestedRanges.some(({ length }) => length === size)).toBe(false);
+  });
+});

package/__tests__/logBlockEvent.test.ts

@@ -60,4 +60,21 @@ describe('getLogBlockLabel', () => {
       expect(getLogBlockLabel({ payload: { method, data: new Uint8Array(1024) } })).toBe(method);
     }
   );
+
+  it.each(['evmSignMessage', 'btcSignMessage', 'evmSignTransaction'])(
+    'blocks request and response payload logging for every API method including %s',
+    method => {
+      expect(getLogBlockLabel({ method, message: 'sensitive signing payload' })).toBe(method);
+      expect(
+        getLogBlockLabel({
+          event: 'iframe-call',
+          payload: { method, message: 'sensitive signing payload' },
+        })
+      ).toBe(method);
+    }
+  );
+
+  it('does not classify events without an API method as method calls', () => {
+    expect(getLogBlockLabel({ event: 'DEVICE_EVENT', type: 'device-connect' })).toBeUndefined();
+  });
 });