@onekeyfe/hd-core 1.2.0-alpha.41 → 1.2.0-alpha.42

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -18,6 +18,83 @@ class TestAllNetworkMethod extends AllNetworkGetAddressBase {
 }
 
 describe('AllNetworkGetAddressBase tracing', () => {
+  test('resumes a Protocol V2 hidden wallet before running a nested chain method', async () => {
+    const calls: string[] = [];
+    const checkPassphraseStateSafety = jest.fn().mockImplementation(() => {
+      calls.push('resume-hidden-session');
+      return Promise.resolve(true);
+    });
+    const innerMethod = {
+      checkSafetyLevelOnTestNet: jest.fn().mockResolvedValue(false),
+      connectId: 'connect-id',
+      deviceId: 'device-id',
+      getVersionRange: jest.fn().mockReturnValue({}),
+      assertProtocolSupported: jest.fn(),
+      init: jest.fn(),
+      name: 'evmGetAddress',
+      responseID: 43,
+      unlockPolicy: 'unlock-before-run',
+      run: jest.fn().mockImplementation(() => {
+        calls.push('run-chain-method');
+        return Promise.resolve([{ address: '0xhidden' }]);
+      }),
+      setDevice: jest.fn(),
+      strictCheckDeviceSupport: false,
+    };
+    (findMethod as jest.Mock).mockReturnValue(innerMethod);
+    const method = new TestAllNetworkMethod({
+      id: 1,
+      payload: {
+        method: 'allNetworkGetAddress',
+        connectId: 'connect-id',
+        deviceId: 'device-id',
+        passphraseState: 'hidden-state',
+        bundle: [],
+      },
+    });
+    method.protocolV2UnlockContext = { preflightCompleted: true };
+    const typedCall = jest.fn();
+    method.device = {
+      checkPassphraseStateSafety,
+      commands: {
+        typedCall,
+      },
+      getCurrentFirmwareType: jest.fn(),
+      getProtocol: jest.fn().mockReturnValue('V2'),
+      getCurrentFirmwareVersionString: jest.fn().mockReturnValue('1.0.0'),
+      getCurrentMethodVersionRange: jest
+        .fn()
+        .mockImplementation((getRange: (type: string) => unknown) => getRange('pro2')),
+      instanceId: 'device-instance',
+      isProtocolV2: jest.fn().mockReturnValue(true),
+      isBootloader: jest.fn().mockReturnValue(false),
+      isRomloader: jest.fn().mockReturnValue(false),
+      off: jest.fn(),
+      on: jest.fn(),
+      state: { status: { unlocked: true } },
+      updateProtocolV2Status: jest.fn(),
+    } as any;
+
+    await method.callMethod(
+      'evmGetAddress',
+      {
+        bundle: [
+          {
+            _originRequestParams: {
+              network: 'evm',
+              path: "m/44'/60'/0'/0/0",
+            },
+          },
+        ],
+      },
+      0
+    );
+
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined);
+    expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
   test('releases the nested request context when an unhandled error escapes', async () => {
     const deviceInstanceId = 'device-instance';
     const innerMethod = {
@@ -51,6 +128,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
       getCurrentMethodVersionRange: jest
         .fn()
         .mockImplementation((getRange: (type: string) => unknown) => getRange('classic')),
+      isProtocolV2: jest.fn().mockReturnValue(false),
       off: jest.fn(),
       on: jest.fn(),
     } as any;

package/__tests__/DeviceEventRegistration.test.ts

@@ -3,6 +3,8 @@ import { registerHardwareUiEventListeners } from '../src/core/deviceEventRegistr
 
 const handlers = {
   pin: jest.fn(),
+  pinOnDevice: jest.fn(),
+  pinOnDeviceComplete: jest.fn(),
   button: jest.fn(),
   passphrase: jest.fn(),
   passphraseOnDevice: jest.fn(),
@@ -21,6 +23,8 @@ describe('hardware UI event registration', () => {
     expect(registerHardwareUiEventListeners(device as any, handlers)).toBe(true);
     expect(device.on.mock.calls.map(([type]) => type)).toEqual([
       DEVICE.PIN,
+      DEVICE.PIN_ON_DEVICE,
+      DEVICE.PIN_ON_DEVICE_COMPLETE,
       DEVICE.BUTTON,
       DEVICE.PASSPHRASE,
       DEVICE.PASSPHRASE_ON_DEVICE,
@@ -34,6 +38,8 @@ describe('hardware UI event registration', () => {
     expect(registerHardwareUiEventListeners(device as any, handlers)).toBe(true);
     expect(device.on.mock.calls.map(([type]) => type)).toEqual([
       DEVICE.PIN,
+      DEVICE.PIN_ON_DEVICE,
+      DEVICE.PIN_ON_DEVICE_COMPLETE,
       DEVICE.BUTTON,
       DEVICE.PASSPHRASE,
       DEVICE.PASSPHRASE_ON_DEVICE,

package/__tests__/check-all-firmware-release-protocol-v2.test.ts

@@ -84,7 +84,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       status: 'required',
       hasUpgrade: true,
       required: true,
-      targetsToUpdate: ['boot', 'app_v1', 'resource'],
+      targetsToUpdate: ['boot', 'app_v1'],
       components: [
         { configKey: 'bootloader', status: 'outdated', updateTarget: 'boot' },
         { configKey: 'applicationP1', status: 'outdated', updateTarget: 'app_v1' },
@@ -247,13 +247,26 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         firmwareVersion: '1.0.0',
       },
       getDeviceState,
+      getCommands: () => ({ typedCall: jest.fn().mockResolvedValue({ message: { items: [] } }) }),
     } as unknown as CheckAllFirmwareRelease['device'];
     jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
+    jest.spyOn(DataManager, 'getProtocolV2Resources').mockReturnValue(
+      ['images', 'animation', 'wallpaper', 'translations', 'roobert', 'noto'].map(
+        (type, index) => ({
+          type,
+          url: `https://example.com/${type}.okpkg`,
+          size: index + 1,
+          fileHash: 'a'.repeat(64),
+          headerHash: index.toString(16).padStart(128, '0'),
+        })
+      ) as any
+    );
 
     await expect(method.run()).resolves.toMatchObject({
       protocol: 'V2',
       deviceType: 'pro2',
       status: 'required',
+      resourceStatus: 'outdated',
       targetsToUpdate: ['boot', 'app_v1', 'resource'],
       firmware: {
         status: 'required',

package/__tests__/connectSettings.test.ts

@@ -1,61 +1,19 @@
-import DataManager from '../src/data-manager/DataManager';
 import { parseConnectSettings } from '../src/data-manager/connectSettings';
 
-import type { RemoteConfigResponse } from '../src/types';
-
-jest.mock('axios', () => ({
-  get: jest.fn(),
-}));
-
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
-const mockAxiosGet: jest.Mock = jest.requireMock('axios').get;
-
 describe('parseConnectSettings', () => {
-  const preloadedConfig = {
-    bridge: {},
-    classic: { firmware: [], ble: [] },
-    classic1s: { firmware: [], ble: [] },
-    classicpure: { firmware: [], ble: [] },
-    mini: { firmware: [], ble: [] },
-    touch: { firmware: [], ble: [] },
-    pro: { firmware: [], ble: [] },
-    pro2: { firmware: [], ble: [] },
-  } as unknown as RemoteConfigResponse;
-
-  it('keeps a serializable preloaded config in parsed settings', () => {
-    const settings = parseConnectSettings({
-      firmwareManifestMode: 'sdk-managed',
-      preloadedConfig,
-    });
-
-    expect(settings.firmwareManifestMode).toBe('sdk-managed');
-    expect(settings.preloadedConfig).toBe(preloadedConfig);
-  });
-
-  it('uses the preloaded config before the SDK network client', async () => {
-    const settings = parseConnectSettings({
-      firmwareManifestMode: 'sdk-managed',
-      preloadedConfig,
-    });
-
-    await DataManager.load(settings);
-
-    expect(mockAxiosGet).not.toHaveBeenCalled();
-    expect(DataManager.deviceMap.classic).toEqual({ firmware: [], ble: [] });
-  });
+  it('keeps custom configFetcher in parsed settings', () => {
+    const configFetcher = jest.fn();
 
-  it('fails closed without a preloaded config in external-only mode', async () => {
     const settings = parseConnectSettings({
-      firmwareManifestMode: 'external-only',
+      fetchConfig: true,
+      configFetcher,
     });
 
-    await expect(DataManager.load(settings)).rejects.toThrow(
-      'External firmware config snapshot is required'
-    );
-    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(settings.configFetcher).toBe(configFetcher);
   });
 });

package/__tests__/deviceUploadNft.test.ts

@@ -0,0 +1,187 @@
+import DeviceUploadNft from '../src/api/protocol-v2/DeviceUploadNft';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+const createRgba = (width: number, height: number) => {
+  const data = new Uint8Array(width * height * 4);
+  for (let index = 3; index < data.length; index += 4) data[index] = 0xff;
+  return data;
+};
+
+const createMethod = ({
+  typedCall,
+  supportedMessages = [60805, 61500],
+  useFullBundle = false,
+}: {
+  typedCall: jest.Mock;
+  supportedMessages?: number[];
+  useFullBundle?: boolean;
+}) => {
+  const method = new DeviceUploadNft({
+    id: 1,
+    payload: {
+      method: 'deviceUploadNft',
+      image: { width: 540, height: 540, rgba: createRgba(540, 540) },
+      thumbnail: { width: 263, height: 263, rgba: createRgba(263, 263) },
+      title: 'CryptoPunk #3100',
+      subtitle: 'CryptoPunks',
+      timestampMs: 1_760_000_000_000,
+      chunkSize: 2048,
+      paceMs: 0,
+    },
+  });
+  (method as any).device = {
+    commands: { typedCall },
+    ensureProtocolV2RuntimeContext: jest.fn(() =>
+      Promise.resolve({
+        version: 2,
+        build_fingerprint: 'application__1.0.0__test__DEV__DEBUG',
+        supported_messages: supportedMessages,
+      })
+    ),
+    getCurrentFirmwareType: jest.fn(),
+  };
+  method.postMessage = jest.fn();
+
+  if (useFullBundle) {
+    method.init();
+  } else {
+    (method as any).params = { chunkSize: 2048, paceMs: 0, timeoutMs: 15_000 };
+    (method as any).bundle = {
+      basename: 'nft-deadbeef-1760000000000',
+      image: new Uint8Array([1]),
+      thumbnail: new Uint8Array([2]),
+      metadata: new TextEncoder().encode('{"title":"NFT","subtitle":""}'),
+    };
+  }
+
+  return method;
+};
+
+const fileWriteSuccess = (params: { file: { offset: number; data: Uint8Array } }) => ({
+  message: {
+    processed_byte: params.file.offset + params.file.data.byteLength,
+  },
+});
+
+describe('DeviceUploadNft', () => {
+  test('uploads the triplet in order without creating the firmware-owned directory', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: { message: 'NFT updated' } };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall, useFullBundle: true });
+
+    const result = await method.run();
+
+    const requests = typedCall.mock.calls.map(call => call[0]);
+    expect(requests[0]).toBe('FilesystemFileWrite');
+    expect(requests).not.toContain('FilesystemDirMake');
+    expect(requests.at(-1)).toBe('NftUpdate');
+    const fileWrites = typedCall.mock.calls.filter(call => call[0] === 'FilesystemFileWrite');
+    const paths = fileWrites.map(call => call[2].file.path as string);
+    const imagePath = paths[0];
+    const thumbnailStart = paths.findIndex(path => path.endsWith('_m.bin'));
+    const metadataStart = paths.findIndex(path => path.endsWith('.json'));
+    expect(imagePath).toMatch(/^vol1:\/nft\/nft-[a-f0-9]{8}-1760000000000\.bin$/);
+    expect(thumbnailStart).toBeGreaterThan(0);
+    expect(metadataStart).toBeGreaterThan(thumbnailStart);
+    expect(new Set(paths.slice(0, thumbnailStart))).toEqual(new Set([imagePath]));
+    expect(new Set(paths.slice(thumbnailStart, metadataStart))).toEqual(
+      new Set([result.thumbnailPath])
+    );
+    expect(typedCall).toHaveBeenLastCalledWith(
+      'NftUpdate',
+      'Success',
+      { file_name_no_ext: result.basename },
+      { timeoutMs: 15_000 }
+    );
+    expect(result).toMatchObject({
+      nftUpdated: true,
+      message: 'NFT updated',
+      totalSize: 583_212 + 138_876 + 53,
+    });
+    expect(method.postMessage).toHaveBeenLastCalledWith({
+      event: 'UI_EVENT',
+      type: 'ui-device_progress',
+      payload: expect.objectContaining({
+        progress: 100,
+        transferredBytes: result.totalSize,
+        totalBytes: result.totalSize,
+      }),
+    });
+  });
+
+  test('retries one timed-out NftUpdate with the same basename', async () => {
+    const timeout = Object.assign(new Error('Protocol V2 response timeout'), {
+      code: 'response-timeout',
+    });
+    let updateCalls = 0;
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') {
+        updateCalls += 1;
+        if (updateCalls === 1) throw timeout;
+        return { message: { message: 'NFT updated' } };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
+
+    const updateRequests = typedCall.mock.calls.filter(call => call[0] === 'NftUpdate');
+    expect(updateRequests).toHaveLength(2);
+    expect(updateRequests[1]).toEqual(updateRequests[0]);
+  });
+
+  test('does not retry a non-timeout NftUpdate failure', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') throw new Error('Invalid NFT metadata');
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).rejects.toThrow('Invalid NFT metadata');
+    expect(typedCall.mock.calls.filter(call => call[0] === 'NftUpdate')).toHaveLength(1);
+  });
+
+  test('propagates a second NftUpdate timeout after one retry', async () => {
+    const timeout = Object.assign(new Error('Protocol V2 response timeout'), {
+      code: 'response-timeout',
+    });
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') throw timeout;
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).rejects.toBe(timeout);
+    expect(typedCall.mock.calls.filter(call => call[0] === 'NftUpdate')).toHaveLength(2);
+  });
+
+  test('does not publish when a file write fails', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'FilesystemFileWrite') throw new Error('Filesystem full');
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).rejects.toThrow('Filesystem full');
+    expect(typedCall.mock.calls.some(call => call[0] === 'NftUpdate')).toBe(false);
+  });
+
+  test('rejects unsupported firmware before writing files', async () => {
+    const typedCall = jest.fn();
+    const method = createMethod({ typedCall, supportedMessages: [60805] });
+
+    await expect(method.run()).rejects.toBeDefined();
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+});

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

@@ -1,8 +1,8 @@
-import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
 import { getBinary } from '../../src/api/firmware/getBinary';
-import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
+import { uploadFirmware } from '../../src/api/firmware/uploadFirmware';
 import * as utils from '../../src/utils';
 
 jest.mock('../../src/data/config', () => ({
@@ -18,8 +18,7 @@ jest.mock('../../src/api/firmware/getBinary', () => ({
 
 jest.mock('../../src/api/firmware/uploadFirmware', () => ({
   updateResources: jest.fn(),
-  updateResourcesFromSources: jest.fn(),
-  uploadFirmwareFromSource: jest.fn(),
+  uploadFirmware: jest.fn(),
 }));
 
 jest.mock('../../src/device/DevicePool', () => ({
@@ -30,9 +29,7 @@ jest.mock('../../src/device/DevicePool', () => ({
 }));
 
 const mockGetBinary = getBinary as jest.MockedFunction<typeof getBinary>;
-const mockUploadFirmwareFromSource = uploadFirmwareFromSource as jest.MockedFunction<
-  typeof uploadFirmwareFromSource
->;
+const mockUploadFirmware = uploadFirmware as jest.MockedFunction<typeof uploadFirmware>;
 
 type DeviceType = 'CLASSIC1S' | 'PURE';
 
@@ -178,26 +175,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).toHaveBeenCalledTimes(1);
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
-  });
-
-  it('preserves structured preparation errors before any firmware mutation', async () => {
-    const preparationError = ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Firmware must be prepared by the external firmware host',
-      {
-        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-        artifactName: 'firmware',
-      }
-    );
-    mockGetBinary.mockRejectedValue(preparationError);
-    const { method, typedCall, acquire } = createMethod();
-
-    await expect(method.run()).rejects.toBe(preparationError);
-
-    expectNoFirmwareMutationCalls(typedCall);
-    expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -238,11 +216,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           binary: firmwareBinary,
         } as Awaited<ReturnType<typeof getBinary>>);
       });
-      mockUploadFirmwareFromSource.mockImplementation(() => {
+      mockUploadFirmware.mockImplementation(() => {
         callOrder.push('upload');
-        return Promise.resolve(
-          expectedResponse as Awaited<ReturnType<typeof uploadFirmwareFromSource>>
-        );
+        return Promise.resolve(expectedResponse as Awaited<ReturnType<typeof uploadFirmware>>);
       });
       const { method, typedCall } = createMethod({
         updateType,
@@ -272,15 +248,15 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           },
         })
       );
-      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
         updateType,
         expect.any(Function),
         expect.any(Function),
         method.device,
-        expect.objectContaining({
-          size: firmwareBinary.byteLength,
-        }),
-        true,
+        {
+          payload: firmwareBinary,
+          rebootOnSuccess: true,
+        },
         isUpdateBootloader
       );
     }
@@ -295,11 +271,11 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
         binary: firmwareBinary,
       } as Awaited<ReturnType<typeof getBinary>>);
     });
-    mockUploadFirmwareFromSource.mockImplementation(() => {
+    mockUploadFirmware.mockImplementation(() => {
       callOrder.push('upload');
       return Promise.resolve({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
     });
     const { method, typedCall, acquire } = createMethod({
       bootloaderMode: true,
@@ -324,9 +300,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           resolveDownload = resolve;
         })
     );
-    mockUploadFirmwareFromSource.mockResolvedValue({
+    mockUploadFirmware.mockResolvedValue({
       success: true,
-    } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
     const { method, typedCall } = createMethod();
 
     const runPromise = method.run();
@@ -357,7 +333,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
 
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -366,23 +342,23 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
   ])(
     'keeps the non-empty %s binary overload and never downloads it again',
     async (_kind, binary) => {
-      mockUploadFirmwareFromSource.mockResolvedValue({
+      mockUploadFirmware.mockResolvedValue({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
       const { method } = createMethod({ binary });
 
       await method.run();
 
       expect(mockGetBinary).not.toHaveBeenCalled();
-      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
         'firmware',
         expect.any(Function),
         expect.any(Function),
         method.device,
-        expect.objectContaining({
-          size: binary.byteLength,
-        }),
-        true,
+        {
+          payload: binary,
+          rebootOnSuccess: true,
+        },
         undefined
       );
     }
@@ -393,21 +369,17 @@ 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) => {
-    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>>;
-      }
-    );
+    mockUploadFirmware.mockResolvedValue({
+      success: true,
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
     const { method } = createMethod({ binary });
 
     await method.run();
 
     expect(mockGetBinary).not.toHaveBeenCalled();
-    expect(uploadedBytes).toEqual(expectedBytes);
+    const normalizedBinary = mockUploadFirmware.mock.calls[0][4].payload;
+    expect(normalizedBinary).toBeInstanceOf(ArrayBuffer);
+    expect(Array.from(new Uint8Array(normalizedBinary))).toEqual(expectedBytes);
   });
 
   it.each([
@@ -425,6 +397,6 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).not.toHaveBeenCalled();
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 });