@onekeyfe/hd-core 1.2.0-alpha.19 → 1.2.0-alpha.20

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

@@ -30,58 +30,55 @@ const createV1Device = (typedCall: jest.Mock) => {
 describe('getDeviceState', () => {
   test('does not expose the internal wallet session', async () => {
     const device = createV2Device(jest.fn());
-    device.updateState(
-      {
-        protocol: 'V2',
-        session: { sessionId: 'private-session', passphraseState: 'private-state' },
-      },
-      'initialize'
-    );
+    device.updateState({ protocol: 'V2' }, 'initialize');
 
     const state = await device.getDeviceState();
 
     expect(state).not.toHaveProperty('session');
   });
 
-  test('hydrates Protocol V2 without status target or DeviceStatusGet by default', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        protocol_version: 2,
-        hw: { serial_no: 'SERIAL-1' },
-        fw: { application: { version: '5.0.0' } },
-      },
-    });
+  test('hydrates Protocol V2 with separate DeviceInfoGet and DeviceStatusGet', async () => {
+    const typedCall = jest.fn().mockImplementation((requestType: string) => ({
+      message:
+        requestType === 'DeviceInfoGet'
+          ? {
+              protocol_version: 2,
+              hw: { serial_no: 'SERIAL-1' },
+              fw: { application: { version: '5.0.0' } },
+            }
+          : { init_states: true, unlocked: true },
+    }));
     const device = createV2Device(typedCall);
 
     const state = await device.getDeviceState();
 
     expect(state.identity.serialNo).toBe('SERIAL-1');
-    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall.mock.calls[0][0]).toBe('DeviceInfoGet');
     expect(typedCall.mock.calls[0][2]?.targets?.status).not.toBe(true);
-    expect(typedCall).not.toHaveBeenCalledWith(
-      'DeviceStatusGet',
-      expect.anything(),
-      expect.anything()
-    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
   });
 
-  test('uses a single full DeviceInfoGet when firmware refresh initializes the state', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        protocol_version: 2,
-        hw: { serial_no: 'SERIAL-1' },
-        fw: { application: { version: '5.0.0', hash: 'HASH-1' } },
-      },
-    });
+  test('uses one full DeviceInfoGet plus DeviceStatusGet when firmware refresh initializes state', async () => {
+    const typedCall = jest.fn().mockImplementation((requestType: string) => ({
+      message:
+        requestType === 'DeviceInfoGet'
+          ? {
+              protocol_version: 2,
+              hw: { serial_no: 'SERIAL-1' },
+              fw: { application: { version: '5.0.0', hash: 'HASH-1' } },
+            }
+          : { init_states: true, unlocked: true },
+    }));
     const device = createV2Device(typedCall);
 
     await device.getDeviceState({
       refreshSections: ['identity', 'versions', 'verification'],
     });
 
-    expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith(
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
       'DeviceInfoGet',
       'DeviceInfo',
       expect.objectContaining({
@@ -117,16 +114,32 @@ describe('getDeviceState', () => {
   });
 
   test.each(['bootloader', 'romloader'] as const)(
-    'does not call DeviceStatusGet in %s mode',
+    'temporarily treats failed DeviceStatusGet with %s metadata as bootloader',
     async mode => {
-      const typedCall = jest.fn();
+      const typedCall = jest.fn().mockImplementation((requestType: string) => {
+        if (requestType === 'DeviceInfoGet') {
+          return {
+            message: {
+              hw: { serial_no: 'SERIAL-1' },
+              fw:
+                mode === 'romloader'
+                  ? { romloader: { version: '1.0.0' } }
+                  : { bootloader: { version: '1.0.0' } },
+            },
+          };
+        }
+        throw new Error('DeviceStatusGet unavailable');
+      });
       const device = createV2Device(typedCall);
       device.updateState({ protocol: 'V2', status: { mode } }, 'initialize');
 
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
-      expect(state.status.mode).toBe(mode);
-      expect(typedCall).not.toHaveBeenCalled();
+      expect(state.status.mode).toBe('bootloader');
+      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+        'DeviceInfoGet',
+        'DeviceStatusGet',
+      ]);
     }
   );
 
@@ -170,6 +183,14 @@ describe('getDeviceState', () => {
 
   test('refreshes Protocol V2 status before settings in a combined read', async () => {
     const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            hw: { serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0' } },
+          },
+        };
+      }
       if (requestType === 'DeviceStatusGet') {
         return {
           message: { init_states: true, unlocked: false, device_id: 'device-1' },
@@ -186,6 +207,7 @@ describe('getDeviceState', () => {
     const state = await device.getDeviceState({ refreshSections: ['status', 'settings'] });
 
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceInfoGet',
       'DeviceStatusGet',
       'DeviceSettingsGet',
     ]);
@@ -195,6 +217,14 @@ describe('getDeviceState', () => {
 
   test('keeps the refreshed status when a following settings read fails', async () => {
     const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            hw: { serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0' } },
+          },
+        };
+      }
       if (requestType === 'DeviceStatusGet') {
         return {
           message: { init_states: true, unlocked: false, device_id: 'device-1' },
@@ -335,12 +365,18 @@ describe('getDeviceState', () => {
   });
 
   test('reloads Protocol V2 DeviceInfo after a physical reconnect', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        protocol_version: 1,
-        hw: { serial_no: 'SERIAL-1' },
-        fw: { bootloader: { version: '1.0.0' } },
-      },
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            protocol_version: 1,
+            hw: { serial_no: 'SERIAL-1' },
+            fw: { bootloader: { version: '1.0.0' } },
+            se1: {},
+          },
+        };
+      }
+      throw new Error('DeviceStatusGet unavailable in bootloader');
     });
     const device = createV2Device(typedCall);
     device.updateState(

package/__tests__/logBlockEvent.test.ts

@@ -31,20 +31,33 @@ describe('getLogBlockLabel', () => {
     ).toBe('evmSignTypedData');
   });
 
-  it('blocks deviceSessionOpen params before logging a host passphrase', () => {
+  it('keeps existing sensitive UI response blocking', () => {
+    expect(getLogBlockLabel({ type: UI_RESPONSE.RECEIVE_PIN })).toBe(UI_RESPONSE.RECEIVE_PIN);
+  });
+
+  it('blocks openWalletSession wallet identifiers in direct and iframe call logging', () => {
+    const payload = {
+      method: 'openWalletSession',
+      mode: 'resume-hidden',
+      deviceId: 'device-id',
+      passphraseState: 'wallet-identifier',
+    };
+
+    expect(getLogBlockLabel(payload)).toBe('openWalletSession');
     expect(
       getLogBlockLabel({
-        method: 'deviceSessionOpen',
-        select: {
-          host_passphrase: {
-            passphrase: 'do-not-log-this',
-          },
-        },
+        event: 'iframe-call',
+        type: 'iframe-call',
+        payload,
       })
-    ).toBe('deviceSessionOpen');
+    ).toBe('openWalletSession');
   });
 
-  it('keeps existing sensitive UI response blocking', () => {
-    expect(getLogBlockLabel({ type: UI_RESPONSE.RECEIVE_PIN })).toBe(UI_RESPONSE.RECEIVE_PIN);
-  });
+  it.each(['deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
+    'blocks binary payload logging for %s',
+    method => {
+      expect(getLogBlockLabel({ method, data: new Uint8Array(1024) })).toBe(method);
+      expect(getLogBlockLabel({ payload: { method, data: new Uint8Array(1024) } })).toBe(method);
+    }
+  );
 });

package/__tests__/networkUtils.test.ts

@@ -0,0 +1,386 @@
+import axios from 'axios';
+
+import { httpRequest } from '../src/utils/networkUtils';
+
+describe('networkUtils httpRequest retry bounds', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+    jest.useRealTimers();
+  });
+
+  it('keeps timeout, retries, and cancellation opt-in for existing callers', async () => {
+    const requestSpy = jest.spyOn(axios, 'request').mockResolvedValue({
+      status: 200,
+      data: {
+        ok: true,
+      },
+    });
+
+    await expect(httpRequest('https://example.com/data.json', 'json')).resolves.toEqual({
+      ok: true,
+    });
+
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(requestSpy.mock.calls[0][0]).not.toHaveProperty('timeout');
+    expect(requestSpy.mock.calls[0][0]).not.toHaveProperty('signal');
+    expect(requestSpy.mock.calls[0][0]).not.toHaveProperty('adapter');
+    expect(requestSpy.mock.calls[0][0]).not.toHaveProperty('onDownloadProgress');
+  });
+
+  it('passes the per-attempt timeout and stops after the configured retry count', async () => {
+    const timeoutError = Object.assign(new Error('timeout'), {
+      code: 'ECONNABORTED',
+      isAxiosError: true,
+    });
+    const requestSpy = jest.spyOn(axios, 'request').mockRejectedValue(timeoutError);
+
+    await expect(
+      httpRequest('https://example.com/firmware.bin', 'binary', {
+        timeoutMs: 1234,
+        maxRetries: 2,
+        retryDelayMs: 0,
+      })
+    ).rejects.toBe(timeoutError);
+
+    expect(requestSpy).toHaveBeenCalledTimes(3);
+    expect(requestSpy).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        timeout: 1234,
+      })
+    );
+  });
+
+  it('retries a connection deadline and stops at the configured attempt bound', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    const requestSpy = jest.spyOn(axios, 'request').mockImplementation(
+      config =>
+        new Promise((_resolve, reject) => {
+          config.signal?.addEventListener(
+            'abort',
+            () => {
+              reject(
+                Object.assign(new Error('canceled'), {
+                  __CANCEL__: true,
+                  code: 'ERR_CANCELED',
+                  isAxiosError: true,
+                })
+              );
+            },
+            { once: true }
+          );
+        })
+    );
+    const requestPromise = httpRequest('https://example.com/firmware.bin', 'binary', {
+      connectTimeoutMs: 1_000,
+      maxRetries: 1,
+      retryDelayMs: 0,
+    });
+    const rejection = expect(requestPromise).rejects.toMatchObject({
+      name: 'HttpRequestPhaseTimeoutError',
+      code: 'ECONNECTTIMEDOUT',
+      message: expect.stringContaining('connect timeout'),
+    });
+
+    await Promise.resolve();
+    jest.advanceTimersByTime(1_000);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(requestSpy).toHaveBeenCalledTimes(2);
+
+    jest.advanceTimersByTime(1_000);
+
+    await rejection;
+    expect(requestSpy).toHaveBeenCalledTimes(2);
+    expect(requestSpy.mock.calls[0][0].adapter).toEqual(['xhr', 'http']);
+  });
+
+  it('restarts the read-idle deadline only when loaded bytes increase', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    let requestConfig: Parameters<typeof axios.request>[0] | undefined;
+    const requestSpy = jest.spyOn(axios, 'request').mockImplementation(
+      config =>
+        new Promise((_resolve, reject) => {
+          requestConfig = config;
+          config.signal?.addEventListener(
+            'abort',
+            () => {
+              reject(
+                Object.assign(new Error('canceled'), {
+                  __CANCEL__: true,
+                  code: 'ERR_CANCELED',
+                  isAxiosError: true,
+                })
+              );
+            },
+            { once: true }
+          );
+        })
+    );
+    const requestPromise = httpRequest('https://example.com/firmware.bin', 'binary', {
+      connectTimeoutMs: 1_000,
+      readTimeoutMs: 2_000,
+    });
+    const rejection = expect(requestPromise).rejects.toMatchObject({
+      name: 'HttpRequestPhaseTimeoutError',
+      code: 'EREADTIMEDOUT',
+      message: expect.stringContaining('read timeout'),
+    });
+
+    await Promise.resolve();
+    jest.advanceTimersByTime(500);
+    requestConfig?.onDownloadProgress?.({
+      bytes: 0,
+      lengthComputable: false,
+      loaded: 0,
+    });
+    jest.advanceTimersByTime(400);
+    requestConfig?.onDownloadProgress?.({
+      bytes: 1,
+      lengthComputable: false,
+      loaded: 1,
+    });
+    jest.advanceTimersByTime(900);
+    requestConfig?.onDownloadProgress?.({
+      bytes: 1,
+      lengthComputable: false,
+      loaded: 2,
+    });
+    jest.advanceTimersByTime(1_900);
+    expect(requestConfig?.signal?.aborted).toBe(false);
+
+    requestConfig?.onDownloadProgress?.({
+      bytes: 0,
+      lengthComputable: false,
+      loaded: 2,
+    });
+    jest.advanceTimersByTime(99);
+    expect(requestConfig?.signal?.aborted).toBe(false);
+
+    jest.advanceTimersByTime(1);
+
+    await rejection;
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(requestConfig?.signal?.aborted).toBe(true);
+  });
+
+  it('ignores progress callbacks after the attempt has settled', async () => {
+    let requestConfig: Parameters<typeof axios.request>[0] | undefined;
+    jest.spyOn(axios, 'request').mockImplementation(config => {
+      requestConfig = config;
+      return Promise.resolve({
+        status: 200,
+        data: new ArrayBuffer(4),
+      });
+    });
+
+    await httpRequest('https://example.com/firmware.bin', 'binary', {
+      connectTimeoutMs: 1_000,
+      readTimeoutMs: 2_000,
+    });
+
+    const timeoutSpy = jest.spyOn(global, 'setTimeout');
+    requestConfig?.onDownloadProgress?.({
+      bytes: 1,
+      lengthComputable: false,
+      loaded: 1,
+    });
+
+    expect(timeoutSpy).not.toHaveBeenCalled();
+  });
+
+  it.each(['ECONNRESET', 'ENOTFOUND', 'ERR_NETWORK', 'ETIMEDOUT'])(
+    'retries transient network error %s',
+    async code => {
+      const networkError = Object.assign(new Error('temporarily unreachable'), {
+        code,
+        isAxiosError: true,
+      });
+      const firmwareBinary = new ArrayBuffer(4);
+      const requestSpy = jest
+        .spyOn(axios, 'request')
+        .mockRejectedValueOnce(networkError)
+        .mockResolvedValueOnce({
+          status: 200,
+          data: firmwareBinary,
+        });
+
+      await expect(
+        httpRequest('https://example.com/firmware.bin', 'binary', {
+          maxRetries: 1,
+          retryDelayMs: 0,
+        })
+      ).resolves.toBe(firmwareBinary);
+
+      expect(requestSpy).toHaveBeenCalledTimes(2);
+    }
+  );
+
+  it('does not retry a canceled request', async () => {
+    const canceledError = Object.assign(new Error('canceled'), {
+      __CANCEL__: true,
+      code: 'ERR_CANCELED',
+      isAxiosError: true,
+    });
+    const requestSpy = jest.spyOn(axios, 'request').mockRejectedValue(canceledError);
+
+    await expect(
+      httpRequest('https://example.com/firmware.bin', 'binary', {
+        maxRetries: 2,
+        retryDelayMs: 0,
+      })
+    ).rejects.toBe(canceledError);
+
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('enforces an overall deadline independently from per-attempt phase deadlines', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    const requestSpy = jest.spyOn(axios, 'request').mockImplementation(
+      () =>
+        new Promise(() => {
+          // Keep the request pending until the overall deadline aborts it.
+        })
+    );
+    const requestPromise = httpRequest('https://example.com/firmware.bin', 'binary', {
+      connectTimeoutMs: 5_000,
+      readTimeoutMs: 5_000,
+      overallTimeoutMs: 2_500,
+      maxRetries: 2,
+      retryDelayMs: 0,
+    });
+    const rejection = expect(requestPromise).rejects.toMatchObject({
+      name: 'HttpRequestOverallTimeoutError',
+      message: expect.stringContaining('2500ms'),
+    });
+
+    jest.advanceTimersByTime(2_500);
+
+    await rejection;
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(requestSpy.mock.calls[0][0].signal?.aborted).toBe(true);
+  });
+
+  it('includes retry backoff in the overall deadline', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    const networkError = Object.assign(new Error('temporarily unreachable'), {
+      code: 'ECONNRESET',
+      isAxiosError: true,
+    });
+    const requestSpy = jest.spyOn(axios, 'request').mockRejectedValue(networkError);
+    const requestPromise = httpRequest('https://example.com/firmware.bin', 'binary', {
+      overallTimeoutMs: 2_500,
+      maxRetries: 2,
+      retryDelayMs: 5_000,
+    });
+    const rejection = expect(requestPromise).rejects.toMatchObject({
+      name: 'HttpRequestOverallTimeoutError',
+    });
+
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(2);
+    jest.advanceTimersByTime(2_500);
+
+    await rejection;
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('does not start another attempt after an absolute deadline clock jump', async () => {
+    jest
+      .spyOn(Date, 'now')
+      .mockReturnValueOnce(1_000)
+      .mockReturnValueOnce(1_000)
+      .mockReturnValue(4_000);
+    const networkError = Object.assign(new Error('temporarily unreachable'), {
+      code: 'ECONNRESET',
+      isAxiosError: true,
+    });
+    const requestSpy = jest.spyOn(axios, 'request').mockRejectedValue(networkError);
+
+    await expect(
+      httpRequest('https://example.com/firmware.bin', 'binary', {
+        overallTimeoutMs: 2_500,
+        maxRetries: 1,
+        retryDelayMs: 0,
+      })
+    ).rejects.toMatchObject({
+      name: 'HttpRequestOverallTimeoutError',
+      message: expect.stringContaining('2500ms'),
+    });
+
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([500, 502, 503, 504])(
+    'retries transient HTTP %s and returns the next response',
+    async status => {
+      const serverError = Object.assign(new Error('unavailable'), {
+        isAxiosError: true,
+        response: {
+          status,
+        },
+      });
+      const firmwareBinary = new ArrayBuffer(4);
+      const requestSpy = jest
+        .spyOn(axios, 'request')
+        .mockRejectedValueOnce(serverError)
+        .mockResolvedValueOnce({
+          status: 200,
+          data: firmwareBinary,
+        });
+
+      await expect(
+        httpRequest('https://example.com/firmware.bin', 'binary', {
+          maxRetries: 1,
+          retryDelayMs: 0,
+        })
+      ).resolves.toBe(firmwareBinary);
+
+      expect(requestSpy).toHaveBeenCalledTimes(2);
+    }
+  );
+
+  it.each([404, 501, 505])('does not retry HTTP %s', async status => {
+    const responseError = Object.assign(new Error('request failed'), {
+      isAxiosError: true,
+      response: {
+        status,
+      },
+    });
+    const requestSpy = jest.spyOn(axios, 'request').mockRejectedValue(responseError);
+
+    await expect(
+      httpRequest('https://example.com/firmware.bin', 'binary', {
+        maxRetries: 2,
+        retryDelayMs: 0,
+      })
+    ).rejects.toBe(responseError);
+
+    expect(requestSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it.each(['CERT_HAS_EXPIRED', 'DEPTH_ZERO_SELF_SIGNED_CERT', 'ERR_TLS_CERT_ALTNAME_INVALID'])(
+    'does not retry TLS/certificate error %s',
+    async code => {
+      const certificateError = Object.assign(new Error('certificate rejected'), {
+        code,
+        isAxiosError: true,
+      });
+      const requestSpy = jest.spyOn(axios, 'request').mockRejectedValue(certificateError);
+
+      await expect(
+        httpRequest('https://example.com/firmware.bin', 'binary', {
+          maxRetries: 2,
+          retryDelayMs: 0,
+        })
+      ).rejects.toBe(certificateError);
+
+      expect(requestSpy).toHaveBeenCalledTimes(1);
+    }
+  );
+});

package/__tests__/open-wallet-session-error-response.test.ts

@@ -0,0 +1,43 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { initCore } from '../src/core';
+import { IFRAME } from '../src/events';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  __esModule: true,
+  default: {
+    configure: jest.fn().mockResolvedValue(undefined),
+    getTransport: jest.fn(() => undefined),
+  },
+}));
+
+describe('openWalletSession error response', () => {
+  test('returns a structured invalid-parameter response for an incomplete resume request', async () => {
+    const core = initCore();
+
+    const response = await core.handleMessage({
+      id: 1,
+      event: IFRAME.CALL,
+      type: IFRAME.CALL,
+      payload: {
+        method: 'openWalletSession',
+        connectId: 'connect-id',
+        mode: 'resume-hidden',
+      },
+    } as never);
+
+    expect(response).toMatchObject({
+      success: false,
+      payload: {
+        error: 'Missing required parameter: deviceId',
+        code: HardwareErrorCode.CallMethodInvalidParameter,
+      },
+    });
+    await core.dispose();
+  });
+});