@onekeyfe/hd-core 1.2.8 → 1.2.10-alpha.2

package/__tests__/protocolV2FileWrite.test.ts

@@ -1,15 +1,462 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import { writeProtocolV2File } from '../src/api/helpers/protocolV2FileWrite';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+
+import {
+  createProtocolV2AssetFileWriteRecovery,
+  type ProtocolV2FileWriteOptions,
+  writeProtocolV2File,
+} from '../src/api/helpers/protocolV2FileWrite';
 import { DataManager } from '../src/data-manager';
 import { LoggerNames, getLogger } from '../src/utils/logger';
 
+import type { DeviceCommands } from '../src/device/DeviceCommands';
+import type { BaseMethod } from '../src/api/BaseMethod';
+import type { MessageFromOneKey, TransportCallOptions } from '@onekeyfe/hd-transport';
+
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
 describe('writeProtocolV2File', () => {
+  describe('Pro2 / Neo asset pipelines', () => {
+    type Request = {
+      file: { path: string; offset: number; total_size: number; data: Uint8Array };
+      overwrite: boolean;
+      append: boolean;
+      ui_percentage: number;
+    };
+
+    const createCommands = (deviceType = EDeviceType.Pro2) => {
+      const requests: Request[] = [];
+      const device = {
+        isProtocolV2: () => true,
+        getCurrentDeviceType: () => deviceType,
+        state: { status: { mode: 'normal' }, versions: { firmware: '1.0.3', bootloader: '1.0.0' } },
+      };
+      const typedCall = jest.fn(
+        async (
+          _name: string,
+          _response: string,
+          first: Request,
+          options?: TransportCallOptions
+        ) => {
+          let request: Request | undefined = first;
+          let response: MessageFromOneKey = { type: 'FilesystemFile', message: {} };
+          while (request) {
+            requests.push(request);
+            response = {
+              type: 'FilesystemFile',
+              message: {
+                ...request.file,
+                processed_byte: request.file.offset + request.file.data.byteLength,
+              },
+            };
+            options?.fileWritePipeline?.onResponse(response);
+            request = (await options?.fileWritePipeline?.next()) as Request | undefined;
+          }
+          return response;
+        }
+      );
+      const commands = { device, typedCall } as unknown as DeviceCommands;
+      return { commands, device, typedCall, requests };
+    };
+
+    beforeEach(() => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native');
+      jest.spyOn(DataManager, 'isBleConnect').mockReturnValue(true);
+    });
+
+    afterEach(() => jest.restoreAllMocks());
+
+    test.each(
+      [EDeviceType.Pro2, EDeviceType.Neo].flatMap(deviceType =>
+        ['react-native', 'desktop-web-ble'].flatMap(env =>
+          [
+            'vol1:/wallpapers/wallpaper.okpkg',
+            'vol1:/nft/nft-deadbeef-1760000000000.okpkg',
+            'vol1:/portfolio/portfolio.okpkg.pending',
+          ].map(path => ({ deviceType, env, path }))
+        )
+      )
+    )(
+      'pipelines $deviceType $path on $env using application version',
+      async ({ deviceType, env, path }) => {
+        jest.spyOn(DataManager, 'getSettings').mockReturnValue(env);
+        const { commands, typedCall, requests } = createCommands(deviceType);
+        const onProgress = jest.fn();
+
+        await expect(
+          writeProtocolV2File({
+            commands,
+            path,
+            data: new Uint8Array(3601),
+            overwrite: true,
+            bleChunkSizeLimit: 1960,
+            chunkSizeLimit: 4000,
+            onProgress,
+          })
+        ).resolves.toMatchObject({ processed_byte: 3601, chunks: 3 });
+
+        expect(typedCall).toHaveBeenCalledTimes(1);
+        expect(typedCall.mock.calls[0][3]).toMatchObject({
+          writeWithResponse: false,
+          fileWritePipeline: { next: expect.any(Function), onResponse: expect.any(Function) },
+        });
+        expect(requests.map(request => request.file.offset)).toEqual([0, 1800, 3600]);
+        expect(requests.map(request => request.file.data.byteLength)).toEqual([1800, 1800, 1]);
+        expect(requests.map(request => request.overwrite)).toEqual([true, false, false]);
+        expect(onProgress.mock.calls.map(([progress]) => progress.transferredBytes)).toEqual([
+          1800, 3600, 3601,
+        ]);
+      }
+    );
+
+    test('does not replay a failed pipeline on the invalidated link', async () => {
+      const { commands, typedCall } = createCommands();
+      const timeout = new Error('BLE response timeout');
+      typedCall.mockRejectedValueOnce(timeout);
+
+      await expect(
+        writeProtocolV2File({
+          commands,
+          overwrite: true,
+          path: 'vol1:/wallpapers/wallpaper.okpkg',
+          data: new Uint8Array(3601),
+          maxChunkRetries: 3,
+        })
+      ).rejects.toBe(timeout);
+      expect(typedCall).toHaveBeenCalledTimes(1);
+    });
+
+    test.each(
+      [EDeviceType.Pro2, EDeviceType.Neo].flatMap(deviceType =>
+        ['react-native', 'desktop-web-ble'].flatMap(env =>
+          [
+            'vol1:/wallpapers/wallpaper.okpkg',
+            'vol1:/nft/nft-deadbeef-1760000000000.okpkg',
+            'vol1:/portfolio/portfolio.okpkg.pending',
+          ].map(path => ({ deviceType, env, path }))
+        )
+      )
+    )(
+      'reconnects and restarts the dual-frame $deviceType $path upload on $env',
+      async ({ deviceType, env, path }) => {
+        jest.spyOn(DataManager, 'getSettings').mockReturnValue(env);
+        const { commands, typedCall } = createCommands(deviceType);
+        const fresh = createCommands(deviceType);
+        const timeout = Object.assign(new Error('BLE response timeout'), {
+          errorCode: HardwareErrorCode.BleTimeoutError,
+        });
+        typedCall.mockImplementationOnce((_name, _response, first, options) => {
+          options?.fileWritePipeline?.onResponse({
+            type: 'FilesystemFile',
+            message: { ...first.file, processed_byte: 1800 },
+          });
+          return Promise.reject(timeout);
+        });
+        const recoverConnection = jest.fn().mockResolvedValue(fresh.commands);
+        const onProgress = jest.fn();
+        const metrics = jest.spyOn(getLogger(LoggerNames.Core), 'log');
+
+        await expect(
+          writeProtocolV2File({
+            commands,
+            overwrite: true,
+            path,
+            data: new Uint8Array(3601),
+            maxChunkRetries: 3,
+            recoverConnection,
+            onProgress,
+          })
+        ).resolves.toMatchObject({ processed_byte: 3601, chunks: 3 });
+
+        expect(typedCall).toHaveBeenCalledTimes(1);
+        expect(recoverConnection).toHaveBeenCalledTimes(1);
+        expect(metrics).toHaveBeenCalledWith(
+          expect.stringContaining(`status=failed path=${path} bytes=1800/3601`)
+        );
+        expect(metrics).toHaveBeenLastCalledWith(
+          expect.stringContaining('window=2 chunk=1800 retry=1 averageSpeed=')
+        );
+        expect(fresh.requests.map(request => request.file.offset)).toEqual([0, 1800, 3600]);
+        expect(fresh.requests.map(request => request.overwrite)).toEqual([true, false, false]);
+        expect(fresh.typedCall).toHaveBeenCalledTimes(1);
+        expect(fresh.typedCall.mock.calls[0][3]?.fileWritePipeline).toBeDefined();
+        expect(fresh.typedCall.mock.calls[0][3]?.timeoutMs).toBe(10_000);
+        expect(onProgress.mock.calls.map(([progress]) => progress.transferredBytes)).toEqual([
+          1800, 0, 1800, 3600, 3601,
+        ]);
+        expect(onProgress.mock.calls[onProgress.mock.calls.length - 1][0]).toMatchObject({
+          retryCount: 1,
+          progress: 100,
+        });
+      }
+    );
+
+    test('bounds dual-frame whole-file recovery to three extra attempts', async () => {
+      const { commands, typedCall } = createCommands();
+      const timeout = Object.assign(new Error('BLE response timeout'), {
+        errorCode: HardwareErrorCode.BleTimeoutError,
+      });
+      typedCall.mockRejectedValue(timeout);
+      const recoverConnection = jest.fn().mockResolvedValue(commands);
+      await expect(
+        writeProtocolV2File({
+          commands,
+          overwrite: true,
+          path: 'vol1:/wallpapers/wallpaper.okpkg',
+          data: new Uint8Array(3601),
+          maxChunkRetries: 3,
+          recoverConnection,
+        })
+      ).rejects.toBe(timeout);
+      expect(typedCall).toHaveBeenCalledTimes(4);
+      expect(recoverConnection).toHaveBeenCalledTimes(3);
+      expect(typedCall.mock.calls.every(call => !!call[3]?.fileWritePipeline)).toBe(true);
+    });
+
+    test('does not start a retry when cancelled during reconnect', async () => {
+      const { commands, typedCall } = createCommands();
+      const aborted = new Error('cancelled');
+      let cancelled = false;
+      typedCall.mockRejectedValueOnce(new Error('BLE response timeout'));
+      const recoverConnection = jest.fn(() => {
+        cancelled = true;
+        return Promise.resolve(commands);
+      });
+      await expect(
+        writeProtocolV2File({
+          commands,
+          overwrite: true,
+          path: 'vol1:/wallpapers/wallpaper.okpkg',
+          data: new Uint8Array(3601),
+          maxChunkRetries: 3,
+          recoverConnection,
+          throwIfAborted: () => {
+            if (cancelled) throw aborted;
+          },
+        })
+      ).rejects.toBe(aborted);
+      expect(typedCall).toHaveBeenCalledTimes(1);
+    });
+
+    test('does not retry device rejections or callback failures', async () => {
+      const { commands, typedCall } = createCommands();
+      const failure = new Error('device rejected file');
+      typedCall.mockRejectedValueOnce(failure);
+      const recoverConnection = jest.fn();
+      await expect(
+        writeProtocolV2File({
+          commands,
+          overwrite: true,
+          path: 'vol1:/wallpapers/wallpaper.okpkg',
+          data: new Uint8Array(3601),
+          maxChunkRetries: 3,
+          recoverConnection,
+        })
+      ).rejects.toBe(failure);
+      expect(recoverConnection).not.toHaveBeenCalled();
+    });
+
+    test.each(['different-device', ''])(
+      'rejects reconnect identity %s before unlocking or writing',
+      async serialNo => {
+        const { commands, device, typedCall } = createCommands();
+        const state = {
+          ...device.state,
+          identity: { serialNo: 'test-device', deviceType: EDeviceType.Pro2 },
+        };
+        const acquire = jest.fn().mockResolvedValue(undefined);
+        const initialize = jest.fn(() => {
+          state.identity.serialNo = serialNo;
+          return Promise.resolve(undefined);
+        });
+        const method = {
+          device: { ...device, state, commands, acquire, initialize },
+        } as unknown as BaseMethod;
+        const recover = createProtocolV2AssetFileWriteRecovery(method);
+        await expect(recover()).rejects.toMatchObject({
+          errorCode: HardwareErrorCode.DeviceCheckDeviceIdError,
+        });
+        expect(acquire).toHaveBeenCalledWith('V2', { throwOnRunPromiseError: true });
+        expect(typedCall).not.toHaveBeenCalled();
+      }
+    );
+
+    test.each(['react-native', 'desktop-web-ble'])(
+      'disconnects a cached %s link and refreshes unlock status after reconnect',
+      async env => {
+        jest.spyOn(DataManager, 'getSettings').mockReturnValue(env);
+        const { commands, device, typedCall } = createCommands();
+        typedCall.mockResolvedValueOnce({ type: 'DeviceStatus', message: { unlocked: false } });
+        const unlockDevice = jest.fn().mockResolvedValue({ unlocked: true });
+        let nativeConnected = true;
+        const disconnect = jest.fn(() => {
+          nativeConnected = false;
+          return Promise.resolve();
+        });
+        const acquire = jest.fn(() => {
+          if (nativeConnected) {
+            return Promise.reject(new Error('reused the timed-out native connection'));
+          }
+          nativeConnected = true;
+          return Promise.resolve();
+        });
+        const method = {
+          name: 'deviceUploadWallpaper',
+          device: {
+            ...device,
+            state: {
+              ...device.state,
+              identity: { serialNo: 'test-device', deviceType: EDeviceType.Pro2 },
+              status: { mode: 'normal', initialized: true },
+            },
+            commands,
+            originalDescriptor: { id: 'ble-device' },
+            deviceConnector: { disconnect },
+            acquire,
+            initialize: jest.fn().mockResolvedValue(undefined),
+            updateProtocolV2Status: (status: unknown) => status,
+            unlockDevice,
+            toMessageObject: () => ({}),
+          },
+          unlockPolicy: 'unlock-before-run',
+          useDevicePassphraseState: false,
+          protocolV2PreUnlockPinType: DeviceSessionPinType.Any,
+          protocolV2UnlockContext: { preflightCompleted: true },
+          postMessage: jest.fn(),
+          payload: {},
+        } as unknown as BaseMethod;
+        await expect(createProtocolV2AssetFileWriteRecovery(method)()).resolves.toBe(commands);
+        expect(disconnect).toHaveBeenCalledWith('ble-device');
+        expect(acquire).toHaveBeenCalledWith('V2', { throwOnRunPromiseError: true });
+        expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+        expect(unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Any, expect.any(Object));
+      }
+    );
+
+    const serialCases: {
+      name: string;
+      firmware?: string;
+      protocol?: boolean;
+      mode?: string;
+      deviceType?: EDeviceType;
+      env?: string;
+      options?: Partial<ProtocolV2FileWriteOptions>;
+    }[] = [
+      { name: 'old application with a new bootloader', firmware: '1.0.2' },
+      { name: 'unknown application', firmware: '' },
+      { name: 'invalid application version', firmware: 'unknown' },
+      { name: 'application prerelease', firmware: '1.0.3-rc.1' },
+      { name: 'Protocol V1', protocol: false },
+      { name: 'bootloader runtime', mode: 'bootloader' },
+      { name: 'another model', deviceType: EDeviceType.Pro },
+      { name: 'WebUSB', env: 'web' },
+      { name: 'LowLevel transport', env: 'lowlevel' },
+      { name: 'a generic file', options: { path: 'vol1:/other.bin' } },
+      { name: 'a partial file', options: { totalSize: 7200 } },
+      { name: 'non-overwriting writes', options: { overwrite: false } },
+      { name: 'append', options: { append: true } },
+      { name: 'offset writes', options: { offset: 1 } },
+      { name: 'explicit pacing', options: { paceMs: 1 } },
+      { name: 'acknowledged characteristic writes', options: { writeWithResponse: true } },
+    ];
+
+    test.each(serialCases)('keeps $name serial', async testCase => {
+      const { commands, device, typedCall } = createCommands(testCase.deviceType);
+      device.isProtocolV2 = () => testCase.protocol ?? true;
+      device.state.versions.firmware = testCase.firmware ?? '1.0.3';
+      device.state.versions.bootloader = '9.0.0';
+      device.state.status.mode = testCase.mode ?? 'normal';
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(testCase.env ?? 'react-native');
+
+      await writeProtocolV2File({
+        commands,
+        overwrite: true,
+        path: 'vol1:/wallpapers/wallpaper.okpkg',
+        data: new Uint8Array(3601),
+        ...testCase.options,
+      });
+
+      expect(typedCall.mock.calls.every(call => !call[3]?.fileWritePipeline)).toBe(true);
+    });
+
+    test('drains an in-flight response on cancellation before rejecting', async () => {
+      const { commands, typedCall } = createCommands();
+      const aborted = new Error('upload cancelled');
+      let cancelled = false;
+      const drained = jest.fn();
+      const onProgress = jest.fn();
+      typedCall.mockImplementationOnce(async (_name, _response, first, options) => {
+        const pipeline = options?.fileWritePipeline;
+        if (!pipeline) throw new Error('Expected a file write pipeline');
+        const second = (await pipeline.next()) as Request;
+        cancelled = true;
+        expect(() =>
+          pipeline.onResponse({ type: 'FilesystemFile', message: { processed_byte: 1800 } })
+        ).not.toThrow();
+        await expect(pipeline.next()).resolves.toBeUndefined();
+        const response = { type: 'FilesystemFile', message: { processed_byte: 3600 } };
+        pipeline.onResponse(response);
+        drained(first, second);
+        return response;
+      });
+
+      await expect(
+        writeProtocolV2File({
+          commands,
+          overwrite: true,
+          path: 'vol1:/wallpapers/wallpaper.okpkg',
+          data: new Uint8Array(5401),
+          throwIfAborted: () => {
+            if (cancelled) throw aborted;
+          },
+          onProgress,
+        })
+      ).rejects.toBe(aborted);
+      expect(drained).toHaveBeenCalledTimes(1);
+      expect(onProgress).not.toHaveBeenCalled();
+      expect(typedCall).toHaveBeenCalledTimes(1);
+    });
+
+    test('raises a progress callback error after stopping further chunks', async () => {
+      const { commands, typedCall, requests } = createCommands();
+      const callbackError = new Error('progress callback failed');
+
+      await expect(
+        writeProtocolV2File({
+          commands,
+          overwrite: true,
+          path: 'vol1:/portfolio/portfolio.okpkg.pending',
+          data: new Uint8Array(3601),
+          onProgress: () => {
+            throw callbackError;
+          },
+        })
+      ).rejects.toBe(callbackError);
+      expect(requests).toHaveLength(1);
+      expect(typedCall).toHaveBeenCalledTimes(1);
+    });
+
+    test('rejects a pipeline that returns without confirming every chunk', async () => {
+      const { commands, typedCall } = createCommands();
+      typedCall.mockResolvedValueOnce({
+        type: 'FilesystemFile',
+        message: { processed_byte: 3601 },
+      });
+      await expect(
+        writeProtocolV2File({
+          commands,
+          overwrite: true,
+          path: 'vol1:/wallpapers/wallpaper.okpkg',
+          data: new Uint8Array(3601),
+        })
+      ).rejects.toThrow('before the complete file was confirmed');
+      expect(typedCall).toHaveBeenCalledTimes(1);
+    });
+  });
+
   test('allows a verified caller-specific BLE chunk limit', async () => {
     const getSettingsSpy = jest
       .spyOn(DataManager, 'getSettings')
@@ -200,7 +647,7 @@ describe('writeProtocolV2File', () => {
       });
 
       expect(logSpy).toHaveBeenLastCalledWith(
-        '[FileWrite] metrics transport=unknown status=completed path=vol0:/firmware.bin bytes=3/3 elapsed=0.05s speed=0.06 KiB/s hostWriteTotal=0.03s responseWaitTotal=0.03s measuredAttempts=1'
+        '[FileWrite] metrics transport=unknown status=completed path=vol0:/firmware.bin bytes=3/3 elapsed=0.05s speed=0.06 KiB/s hostWriteTotal=0.03s responseWaitTotal=0.03s measuredAttempts=1 window=1 chunk=4000 retry=0 averageSpeed=0.06 KiB/s'
       );
     } finally {
       dateNowSpy.mockRestore();
@@ -277,11 +724,11 @@ describe('writeProtocolV2File', () => {
       );
       expect(logSpy).toHaveBeenNthCalledWith(
         2,
-        '[FileWrite] metrics transport=BLE status=progress path=vol1:/wallpapers/test.bin bytes=3600/5400 elapsed=10.00s speed=0.35 KiB/s'
+        '[FileWrite] metrics transport=BLE status=progress path=vol1:/wallpapers/test.bin bytes=3600/5400 elapsed=10.00s speed=0.35 KiB/s window=1 chunk=1800 retry=0 averageSpeed=0.35 KiB/s'
       );
       expect(logSpy).toHaveBeenNthCalledWith(
         3,
-        '[FileWrite] metrics transport=BLE status=completed path=vol1:/wallpapers/test.bin bytes=5400/5400 elapsed=14.00s speed=0.44 KiB/s'
+        '[FileWrite] metrics transport=BLE status=completed path=vol1:/wallpapers/test.bin bytes=5400/5400 elapsed=14.00s speed=0.44 KiB/s window=1 chunk=1800 retry=0 averageSpeed=0.38 KiB/s'
       );
     } finally {
       dateNowSpy.mockRestore();
@@ -315,7 +762,7 @@ describe('writeProtocolV2File', () => {
       );
       expect(logSpy).toHaveBeenNthCalledWith(
         2,
-        '[FileWrite] metrics transport=unknown status=failed path=vol1:/wallpapers/test.bin bytes=0/4000 elapsed=1.00s speed=0.00 KiB/s'
+        '[FileWrite] metrics transport=unknown status=failed path=vol1:/wallpapers/test.bin bytes=0/4000 elapsed=1.00s speed=0.00 KiB/s window=1 chunk=4000 retry=0 averageSpeed=0.00 KiB/s'
       );
     } finally {
       dateNowSpy.mockRestore();

package/__tests__/refresh-device-state.test.ts

@@ -73,24 +73,26 @@ describe('live device state reads', () => {
     }
   );
 
-  test('rejects settings scope in loader mode after minimal mode detection', async () => {
-    const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'bootloader' } });
-    const method = new GetDeviceState({
-      id: 1,
-      payload: { method: 'getDeviceState', scope: 'settings' },
-    });
-    method.init();
-    (method as any).device = {
-      isProtocolV2: () => true,
-      getCurrentFirmwareType: () => 'universal',
-      getDeviceState,
-    };
+  test.each(['bootloader', 'romloader'] as const)(
+    'reports %s mode for settings scope after minimal mode detection',
+    async mode => {
+      const getDeviceState = jest.fn().mockResolvedValue({ status: { mode } });
+      const method = new GetDeviceState({
+        id: 1,
+        payload: { method: 'getDeviceState', scope: 'settings' },
+      });
+      method.init();
+      (method as any).device = {
+        isProtocolV2: () => true,
+        getDeviceState,
+      };
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-    });
-    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status', 'settings'] });
-  });
+      await expect(method.run()).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.NotAllowInBootloaderMode,
+      });
+      expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status', 'settings'] });
+    }
+  );
 
   test('rejects an unknown scope', () => {
     const method = new GetDeviceState({

package/__tests__/search-devices.test.ts

@@ -338,6 +338,42 @@ describe('SearchDevices', () => {
     }
   );
 
+  test('BLE discovery returns the advertised color letter without a device identity', async () => {
+    mockIsBleConnect.mockReturnValue(true);
+
+    const descriptor = {
+      id: 'ble-peripheral-id',
+      path: 'ble-peripheral-id',
+      name: 'Neo A1B2',
+      commType: 'ble',
+      bleColorCode: 'E',
+    };
+    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: 'neo',
+        bleColorCode: 'E',
+      },
+    ]);
+  });
+
   test.each([
     ['Pro2 A1B2 - Find My', undefined, 'Pro 2 A1B2'],
     ['Pro2 5E9D - Finde My', undefined, 'Pro 2 5E9D'],

package/__tests__/sol-sign-offchain-message.test.ts

@@ -54,6 +54,14 @@ describe('SolSignOffchainMessage', () => {
     });
   });
 
+  test('maps omitted required signers to an empty repeated field', () => {
+    const method = createMethod({ requiredSigners: undefined });
+
+    method.init();
+
+    expect(method.params.required_signers).toEqual([]);
+  });
+
   test.each([
     { requiredSigners: ['11'], error: '32-byte hex public key' },
     { requiredSigners: [signerB, signerA], error: 'strictly sorted and unique' },