@onekeyfe/hd-core 1.2.0-alpha.8 → 1.2.0-alpha.80

package/__tests__/logBlockEvent.test.ts

@@ -1,4 +1,10 @@
-import { UI_RESPONSE, getLogBlockLabel } from '../src/events';
+import {
+  UI_REQUEST,
+  UI_RESPONSE,
+  formatLogMethodLabel,
+  getLogBlockLabel,
+  getSafeLogPayload,
+} from '../src/events';
 
 describe('getLogBlockLabel', () => {
   it('blocks evmSignTypedData params before logging large typed data', () => {
@@ -34,4 +40,125 @@ describe('getLogBlockLabel', () => {
   it('keeps existing sensitive UI response blocking', () => {
     expect(getLogBlockLabel({ type: UI_RESPONSE.RECEIVE_PIN })).toBe(UI_RESPONSE.RECEIVE_PIN);
   });
+
+  it.each([UI_REQUEST.REQUEST_PASSPHRASE, UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE])(
+    'blocks wallet identifiers in %s event logging',
+    type => {
+      expect(
+        getLogBlockLabel({
+          type,
+          payload: {
+            passphraseState: 'wallet-identifier',
+            expectedPassphraseState: 'expected-wallet-identifier',
+          },
+        })
+      ).toBe(type);
+    }
+  );
+
+  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({
+        event: 'iframe-call',
+        type: 'iframe-call',
+        payload,
+      })
+    ).toBe('openWalletSession');
+  });
+
+  it('keeps openWalletSession metadata while redacting wallet session identifiers', () => {
+    const safeResponse = getSafeLogPayload(
+      {
+        success: true,
+        payload: {
+          protocol: 'V2',
+          walletType: 'hidden',
+          deviceId: 'device-id',
+          passphraseState: 'wallet-identifier',
+          sessionId: 'wallet-session-id',
+          resumed: false,
+        },
+      },
+      'openWalletSession'
+    );
+
+    expect(safeResponse).toEqual({
+      method: 'openWalletSession',
+      success: true,
+      payload: {
+        protocol: 'V2',
+        walletType: 'hidden',
+        deviceId: 'device-id',
+        passphraseState: '[REDACTED]',
+        sessionId: '[REDACTED]',
+        resumed: false,
+      },
+    });
+  });
+
+  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
+    'keeps metadata and replaces binary payloads with their size for %s',
+    method => {
+      const request = { method, path: 'resource.bin', data: new Uint8Array(1024) };
+      expect(getLogBlockLabel(request)).toBe(method);
+      expect(getSafeLogPayload(request, method)).toEqual({
+        method,
+        path: 'resource.bin',
+        data: '[BINARY:1024]',
+      });
+    }
+  );
+
+  it.each(['evmSignMessage', 'btcSignMessage', 'evmSignTransaction'])(
+    'blocks request and response payload logging for signing method %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('keeps ordinary API requests and responses visible', () => {
+    const request = { method: 'getDeviceState', connectId: 'connect-id', scope: 'runtime' };
+    const response = { success: true, payload: { protocol: 'V2', initialized: true } };
+
+    expect(getLogBlockLabel(request)).toBeUndefined();
+    expect(getSafeLogPayload(request)).toEqual(request);
+    expect(getSafeLogPayload(response)).toEqual(response);
+  });
+
+  it('redacts sensitive keys even for ordinary API payloads', () => {
+    expect(
+      getSafeLogPayload({
+        method: 'ordinaryMethod',
+        payload: { session_id: 'session-secret', nested: { pin: '1234' } },
+      })
+    ).toEqual({
+      method: 'ordinaryMethod',
+      payload: { session_id: '[REDACTED]', nested: { pin: '[REDACTED]' } },
+    });
+  });
+
+  it('puts sensitive API method names in the log label', () => {
+    expect(formatLogMethodLabel('response:', 'openWalletSession')).toBe(
+      'response: [openWalletSession]'
+    );
+    expect(formatLogMethodLabel('response:')).toBe('response:');
+  });
+
+  it('does not classify events without an API method as method calls', () => {
+    expect(getLogBlockLabel({ event: 'DEVICE_EVENT', type: 'device-connect' })).toBeUndefined();
+  });
 });

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

@@ -0,0 +1,144 @@
+import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { BaseMethod } from '../src/api/BaseMethod';
+import { findMethod, getMethodSupportedProtocols } from '../src/api/utils';
+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('creates a protocol detection method that returns only the current protocol', async () => {
+    const method = findMethod({
+      id: 6,
+      payload: {
+        method: 'detectDeviceConnectProtocol',
+        connectId: 'ble-device',
+      },
+    } as never);
+
+    method.init();
+    (method as unknown as { device: unknown }).device = {
+      getProtocol: () => 'V2',
+    };
+
+    expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    await expect(method.run()).resolves.toBe('V2');
+  });
+
+  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();
+  });
+
+  test('exposes the dispatcher protocol contract for callers that need a preflight', () => {
+    expect(getMethodSupportedProtocols('solGetAddress')).toEqual(['V1', 'V2']);
+    expect(getMethodSupportedProtocols('stellarGetAddress')).toEqual(['V1']);
+    expect(
+      getMethodSupportedProtocols('btcGetAddress', {
+        path: "m/44'/1900'/0'/0/0",
+        coin: 'Neurai',
+        showOnOneKey: false,
+      })
+    ).toEqual(['V1']);
+  });
+});

package/__tests__/networkUtils.test.ts

@@ -0,0 +1,406 @@
+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('accepts partial content and forwards byte-range headers', async () => {
+    const packageHeader = new ArrayBuffer(640);
+    const requestSpy = jest.spyOn(axios, 'request').mockResolvedValue({
+      status: 206,
+      data: packageHeader,
+    });
+
+    await expect(
+      httpRequest('https://example.com/application-p1.okpkg', 'binary', {
+        headers: { Range: 'bytes=0-639' },
+      })
+    ).resolves.toBe(packageHeader);
+
+    expect(requestSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headers: { Range: 'bytes=0-639' },
+      })
+    );
+  });
+
+  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);
+    }
+  );
+});