@onekeyfe/hd-core 1.2.0-alpha.3 → 1.2.0-alpha.30

package/__tests__/method-protocol-support.test.ts

@@ -0,0 +1,113 @@
+import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { BaseMethod } from '../src/api/BaseMethod';
+import BTCGetAddress from '../src/api/btc/BTCGetAddress';
+import DeviceReboot from '../src/api/protocol-v2/DeviceReboot';
+import SolGetAddress from '../src/api/solana/SolGetAddress';
+import StellarGetAddress from '../src/api/stellar/StellarGetAddress';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+class DefaultMethod extends BaseMethod {
+  init() {}
+
+  async run() {
+    return Promise.resolve({});
+  }
+}
+
+describe('method protocol support', () => {
+  test('defaults existing methods to Protocol V1 only', () => {
+    const method = new DefaultMethod({
+      id: 1,
+      payload: { method: 'defaultMethod' },
+    });
+
+    expect(method.getSupportedProtocols()).toEqual(['V1']);
+    expect(method.supportsProtocol('V1')).toBe(true);
+    expect(method.supportsProtocol('V2')).toBe(false);
+  });
+
+  test('returns the canonical unsupported error before method execution', () => {
+    const method = new DefaultMethod({
+      id: 1,
+      payload: { method: 'defaultMethod' },
+    });
+    const run = jest.spyOn(method, 'run');
+
+    expect(() => method.assertProtocolSupported('V2', EFirmwareType.Universal)).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+      })
+    );
+    expect(run).not.toHaveBeenCalled();
+  });
+
+  test('declares Protocol V2-only methods explicitly', () => {
+    const method = new DeviceReboot({
+      id: 1,
+      payload: { method: 'deviceReboot', rebootType: 0 },
+    });
+
+    method.init();
+
+    expect(method.getSupportedProtocols()).toEqual(['V2']);
+  });
+
+  test('distinguishes shared and Protocol V1-only chain methods', () => {
+    const solana = new SolGetAddress({
+      id: 1,
+      payload: {
+        method: 'solGetAddress',
+        path: "m/44'/501'/0'/0'",
+        showOnOneKey: false,
+      },
+    });
+    const stellar = new StellarGetAddress({
+      id: 2,
+      payload: {
+        method: 'stellarGetAddress',
+        path: "m/44'/148'/0'",
+        showOnOneKey: false,
+      },
+    });
+
+    solana.init();
+    stellar.init();
+
+    expect(solana.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(stellar.getSupportedProtocols()).toEqual(['V1']);
+  });
+
+  test('evaluates parameter-dependent Protocol V2 support separately from firmware ranges', () => {
+    const bitcoin = new BTCGetAddress({
+      id: 1,
+      payload: {
+        method: 'btcGetAddress',
+        path: "m/44'/0'/0'/0/0",
+        coin: 'btc',
+        showOnOneKey: false,
+      },
+    });
+    const neurai = new BTCGetAddress({
+      id: 2,
+      payload: {
+        method: 'btcGetAddress',
+        path: "m/44'/1900'/0'/0/0",
+        coin: 'Neurai',
+        showOnOneKey: false,
+      },
+    });
+
+    bitcoin.init();
+    neurai.init();
+
+    expect(bitcoin.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(neurai.getSupportedProtocols()).toEqual(['V1']);
+    expect(bitcoin.getVersionRange().pro2).toBeUndefined();
+    expect(neurai.getVersionRange().pro2).toBeUndefined();
+  });
+});

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();
+  });
+});