@onekeyfe/hd-core 1.2.8-alpha.13 → 1.2.8-alpha.131

package/__tests__/allNetworkGetAddress-privacy-networks.test.ts

@@ -0,0 +1,78 @@
+import AllNetworkGetAddress from '../src/api/allnetwork/AllNetworkGetAddress';
+
+import type { AllNetworkAddressParams } from '../src/types/api/allNetworkGetAddress';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+// Breaks the api index import cycle, as the all-network tests do.
+jest.mock('../src/api/utils', () => ({
+  findMethod: jest.fn(),
+}));
+
+function mapItem(payload: AllNetworkAddressParams) {
+  const method = new AllNetworkGetAddress({
+    id: 1,
+    payload: { method: 'allNetworkGetAddress', bundle: [payload] },
+  });
+  return method.generateMethodName({ network: payload.network, payload, originalIndex: 0 });
+}
+
+describe('allNetworkGetAddress privacy networks', () => {
+  test.each([
+    [undefined, 0],
+    ['mainnet', 0],
+    ['testnet', 1],
+    ['stagenet', 2],
+  ])('asks moneroGetAddress on the %s network type', (chainName, networkType) => {
+    const payload = {
+      network: 'xmr' as const,
+      path: "m/44'/128'/0'",
+      chainName,
+      showOnOneKey: false,
+    };
+
+    expect(mapItem(payload)).toEqual(
+      expect.objectContaining({
+        methodName: 'moneroGetAddress',
+        params: {
+          path: "m/44'/128'/0'",
+          networkType,
+          showOnOneKey: false,
+          originPayload: payload,
+        },
+      })
+    );
+  });
+
+  test.each(['fakechain', 'constructor'])(
+    'rejects the unknown Monero chainName %s instead of using mainnet',
+    chainName => {
+      expect(() =>
+        mapItem({ network: 'xmr', path: "m/44'/128'/0'", chainName, showOnOneKey: false })
+      ).toThrow(`Unsupported Monero chainName: ${chainName}`);
+    }
+  );
+
+  test('asks zcashGetAddress for the Orchard address with its viewing key', () => {
+    const payload = { network: 'zcash' as const, path: "m/32'/133'/0'", showOnOneKey: false };
+
+    expect(mapItem(payload)).toEqual(
+      expect.objectContaining({
+        methodName: 'zcashGetAddress',
+        params: {
+          path: "m/32'/133'/0'",
+          showOnOneKey: false,
+          addressType: 2,
+          scope: 0,
+          diversifierIndex: 0,
+          includeUfvk: true,
+          includeSeedFingerprint: true,
+          originPayload: payload,
+        },
+      })
+    );
+  });
+});

package/__tests__/core-dispose.test.ts

@@ -1,4 +1,7 @@
-import Core, { initConnector } from '../src/core';
+import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
+
+import Core, { init, initConnector, initCore, switchTransport } from '../src/core';
+import DataManager from '../src/data-manager/DataManager';
 import TransportManager from '../src/data-manager/TransportManager';
 import { DevicePool } from '../src/device/DevicePool';
 
@@ -31,4 +34,114 @@ describe('Core.dispose', () => {
     expect(transportStop).toHaveBeenCalledTimes(1);
     expect(disposeDevicePool).toHaveBeenCalledTimes(1);
   });
+
+  test('disposal rejects a queued switch without recreating a transport or connector', async () => {
+    const previous = TransportManager.transport;
+    const { settings } = DataManager;
+    const active = { stop: jest.fn().mockResolvedValue(undefined) };
+    const replacement = jest.fn(() => ({ stop: jest.fn().mockResolvedValue(undefined) }));
+    TransportManager.transport = active as never;
+    const core = initCore();
+    initConnector();
+    const switching = switchTransport({ env: 'emulator', Transport: replacement });
+    const rejected = expect(switching).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.NotInitialized,
+    });
+    try {
+      await core.dispose();
+      await rejected;
+      expect(replacement).not.toHaveBeenCalled();
+      expect(TransportManager.transport).toBe(active);
+      expect(DataManager.settings).toBe(settings);
+      expect(DevicePool.emitter.eventNames()).toHaveLength(0);
+    } finally {
+      await Promise.allSettled([switching]);
+      await core.dispose();
+      TransportManager.transport = previous;
+      DataManager.settings = settings;
+    }
+  });
+
+  test.each(['dispose/reinit', 'init', 'initCore'] as const)(
+    '%s invalidates running and queued switches without blocking a new lifecycle',
+    async lifecycle => {
+      const previous = TransportManager.transport;
+      const { settings } = DataManager;
+      const entered = createDeferred<void>();
+      const closing = createDeferred<void>();
+      const loading = createDeferred<void>();
+      const active = {
+        stop: jest.fn(() => {
+          entered.resolve();
+          return closing.promise;
+        }),
+      };
+      const intermediate = jest.fn(() => ({ stop: jest.fn().mockResolvedValue(undefined) }));
+      const stale = jest.fn(() => ({ stop: jest.fn().mockResolvedValue(undefined) }));
+      const fresh = { stop: jest.fn().mockResolvedValue(undefined) };
+      const current = { stop: jest.fn().mockResolvedValue(undefined) };
+      const Fresh = jest.fn(() => fresh);
+      jest.spyOn(DataManager, 'load').mockImplementation(async next => {
+        await loading.promise;
+        DataManager.settings = next;
+      });
+      TransportManager.transport = active as never;
+      let core = initCore();
+      initConnector();
+      const first = switchTransport({ env: 'emulator', Transport: intermediate });
+      await entered.promise;
+      const second = switchTransport({ env: 'webusb', Transport: stale });
+      const rejected = Promise.all([
+        expect(first).rejects.toMatchObject({ errorCode: HardwareErrorCode.NotInitialized }),
+        expect(second).rejects.toMatchObject({ errorCode: HardwareErrorCode.NotInitialized }),
+      ]);
+      rejected.catch(() => undefined);
+      let initializing: ReturnType<typeof init> | undefined;
+      try {
+        if (lifecycle === 'dispose/reinit') {
+          const disposing = core.dispose();
+          closing.resolve();
+          await disposing;
+        }
+        if (lifecycle === 'initCore') {
+          TransportManager.transport = fresh as never;
+          DataManager.settings = { ...settings, env: 'desktop-web-ble' };
+          core = initCore();
+          initConnector();
+        } else {
+          initializing = init({ ...settings, env: 'desktop-web-ble' }, Fresh);
+          if (lifecycle === 'init') {
+            closing.resolve();
+            await rejected;
+          }
+          loading.resolve();
+          const initialized = await initializing;
+          if (!initialized) throw new Error('Core initialization failed');
+          core = initialized;
+        }
+        await switchTransport({
+          env: 'emulator',
+          Transport: function Current() {
+            return current;
+          },
+        });
+        closing.resolve();
+        await rejected;
+        expect(intermediate).not.toHaveBeenCalled();
+        expect(stale).not.toHaveBeenCalled();
+        expect(TransportManager.transport).toBe(current);
+        expect(DataManager.getSettings('env')).toBe('emulator');
+        expect(fresh.stop).toHaveBeenCalledTimes(1);
+        expect(current.stop).not.toHaveBeenCalled();
+      } finally {
+        closing.resolve();
+        loading.resolve();
+        await initializing;
+        await Promise.allSettled([first, second, rejected]);
+        await core.dispose();
+        TransportManager.transport = previous;
+        DataManager.settings = settings;
+      }
+    }
+  );
 });

package/__tests__/core-error-output.test.ts

@@ -45,6 +45,23 @@ describe('Core 错误输出边界', () => {
     });
   });
 
+  test.each([
+    [HardwareErrorCode.TransportProtocolProbeFailed, { expectedProtocol: 'V1' }],
+    [
+      HardwareErrorCode.TransportProtocolMismatch,
+      { expectedProtocol: 'V2', detectedProtocol: 'V1' },
+    ],
+  ] as const)(
+    'preserves protocol error %s and structured context across the public boundary',
+    (code, params) => {
+      const error = ERRORS.TypedError(code, undefined, params);
+      expect(JSON.parse(JSON.stringify(createErrorMessage(error)))).toEqual({
+        success: false,
+        payload: { code, error: error.message, params },
+      });
+    }
+  );
+
   test.each([
     ['webusb', false],
     ['desktop-webusb', false],
@@ -129,6 +146,8 @@ describe('Core 错误输出边界', () => {
     HardwareErrorCode.BleUnsupported,
     HardwareErrorCode.BridgeNeedsPermission,
     HardwareErrorCode.WebUsbDeviceAccessError,
+    HardwareErrorCode.TransportProtocolProbeFailed,
+    HardwareErrorCode.TransportProtocolMismatch,
   ])(
     'preserves terminal transport error %s in the public response without polling again',
     async errorCode => {
@@ -138,6 +157,8 @@ describe('Core 错误输出边界', () => {
           [
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.WebUsbDeviceAccessError,
+            HardwareErrorCode.TransportProtocolProbeFailed,
+            HardwareErrorCode.TransportProtocolMismatch,
           ].includes(errorCode)
             ? ('desktop-webusb' as never)
             : ('react-native' as never)

package/__tests__/device-connector-protocol.test.ts

@@ -75,8 +75,11 @@ describe('DeviceConnector protocol validation', () => {
     });
     const connector = new DeviceConnector();
 
-    await expect(connector.acquire('classic-id', undefined, undefined, 'V2')).rejects.toThrow(
-      'Device protocol mismatch: expected V2, detected V1'
+    await expect(connector.acquire('classic-id', undefined, undefined, 'V2')).rejects.toMatchObject(
+      {
+        errorCode: HardwareErrorCode.TransportProtocolMismatch,
+        params: { expectedProtocol: 'V2', detectedProtocol: 'V1' },
+      }
     );
   });
 

package/__tests__/device-lifecycle-events.test.ts

@@ -80,6 +80,102 @@ describe('public device lifecycle events', () => {
     jest.restoreAllMocks();
   });
 
+  test.each([
+    ['react-native', 'V2', EDeviceType.Pro2, true],
+    ['react-native', 'V2', EDeviceType.Neo, true],
+    ['desktop-web-ble', 'V2', EDeviceType.Pro2, true],
+    ['desktop-web-ble', 'V2', EDeviceType.Neo, true],
+    ['react-native', 'V1', EDeviceType.Pro, false],
+    ['desktop-web-ble', 'V1', EDeviceType.Touch, false],
+    ['react-native', 'V1', EDeviceType.Pro2, false],
+    ['react-native', 'V2', EDeviceType.Unknown, false],
+    ['desktop-webusb', 'V2', EDeviceType.Pro2, false],
+    ['lowlevel', 'V2', EDeviceType.Neo, false],
+  ] as const)(
+    'releases the task and keeps only the intended BLE links: %s / %s / %s',
+    async (env, protocol, deviceType, keepConnection) => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      const device = createInitializedDevice(protocol);
+      device.features = { ...device.features, deviceType } as never;
+      device.originalDescriptor.session = device.mainId;
+      (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+      const release = jest.fn().mockResolvedValue(true);
+      const disconnect = jest.fn().mockResolvedValue(undefined);
+      device.deviceConnector = { release, disconnect } as never;
+      const commands = {
+        disposed: false,
+        dispose: jest.fn(() => {
+          commands.disposed = true;
+          return Promise.resolve();
+        }),
+        cancel: jest.fn().mockResolvedValue(undefined),
+      };
+      device.commands = commands as never;
+
+      await device.release();
+
+      expect(release).toHaveBeenCalledWith(device.mainId, false, keepConnection);
+      expect(device.hasDeviceAcquire()).toBe(false);
+      expect(commands.disposed).toBe(true);
+      expect(device.keepSession).toBe(false);
+
+      await device.interruptionFromUser();
+      expect(disconnect).toHaveBeenCalledTimes(keepConnection ? 0 : 1);
+    }
+  );
+
+  test('still disconnects when setup is cancelled after a kept-alive release', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = createInitializedDevice('V2');
+    const pendingAcquire = createDeferred<{ uuid: string; protocolType: 'V2' }>();
+    const release = jest.fn().mockResolvedValue(true);
+    const disconnect = jest.fn().mockResolvedValue(undefined);
+    device.deviceConnector = {
+      release,
+      disconnect,
+      acquire: jest.fn(() => pendingAcquire.promise),
+    } as never;
+    device.commands = {
+      disposed: true,
+      dispose: jest.fn().mockResolvedValue(undefined),
+      cancel: jest.fn().mockResolvedValue(undefined),
+    } as never;
+    await device.release();
+    device.beginConnectionAttempt();
+    const acquiring = device.acquire('V2');
+
+    await device.interruptionFromUser();
+    expect(disconnect).toHaveBeenCalledWith(device.mainId);
+    pendingAcquire.resolve({ uuid: 'late-kept-alive-session', protocolType: 'V2' });
+    await expect(acquiring).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInterruptedFromUser,
+    });
+    expect(disconnect).toHaveBeenLastCalledWith('late-kept-alive-session');
+  });
+
+  test.each(['release failure', 'disconnect event'])(
+    'does not treat %s as a kept-alive connection',
+    async reason => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+      const device = createInitializedDevice('V2');
+      const release = jest.fn().mockResolvedValue(true);
+      if (reason === 'release failure') release.mockRejectedValueOnce(new Error('release failed'));
+      const disconnect = jest.fn().mockResolvedValue(undefined);
+      device.deviceConnector = { release, disconnect } as never;
+      device.commands = {
+        disposed: true,
+        dispose: jest.fn().mockResolvedValue(undefined),
+        cancel: jest.fn().mockResolvedValue(undefined),
+      } as never;
+      await device.release();
+      if (reason === 'disconnect event') device.markTransportDisconnected();
+
+      await device.interruptionFromUser();
+
+      expect(disconnect).toHaveBeenCalledWith(device.mainId);
+    }
+  );
+
   test.each(['V1', 'V2'] as const)(
     'preserves the %s acknowledged result and waits for release before the next acquire',
     async protocol => {
@@ -610,7 +706,9 @@ describe('public device lifecycle events', () => {
   );
 
   test.each([
-    [HardwareErrorCode.RuntimeError, true],
+    [HardwareErrorCode.TransportProtocolProbeFailed, true],
+    [HardwareErrorCode.TransportProtocolMismatch, false],
+    [HardwareErrorCode.RuntimeError, false],
     [HardwareErrorCode.BleDeviceBondError, false],
   ] as const)(
     'retries a Protocol V2 probe mismatch with error code %s: %s',
@@ -618,8 +716,8 @@ describe('public device lifecycle events', () => {
       const method = { payload: { connectProtocol: 'V2' } } as never;
       const error = {
         errorCode,
-        message:
-          'Device protocol mismatch: expected V2, but device did not respond to expected protocol',
+        message: 'diagnostic wording is not used for classification',
+        params: { expectedProtocol: 'V2' },
       };
 
       expect(isRetryableBleProtocolV2ProbeError(method, error)).toBe(expected);
@@ -629,6 +727,8 @@ describe('public device lifecycle events', () => {
   test.each([
     [HardwareErrorCode.BleConnectedError, true],
     [HardwareErrorCode.BleTimeoutError, true],
+    [HardwareErrorCode.TransportProtocolProbeFailed, true],
+    [HardwareErrorCode.TransportProtocolMismatch, false],
     [HardwareErrorCode.PollingTimeout, false],
     [HardwareErrorCode.BleDeviceBondError, false],
   ] as const)('retries a BLE connection error with error code %s: %s', (errorCode, expected) => {
@@ -641,6 +741,21 @@ describe('public device lifecycle events', () => {
     expect(isRetryableBleConnectionError(method, error)).toBe(expected);
   });
 
+  test('does not retry a failed strict V1 probe as a V2 probe or after user cancellation', () => {
+    const error = ERRORS.TypedError(HardwareErrorCode.TransportProtocolProbeFailed, undefined, {
+      expectedProtocol: 'V1',
+    });
+    const method = { payload: { connectProtocol: 'V2' } } as never;
+    expect(isRetryableBleProtocolV2ProbeError(method, error)).toBe(false);
+    expect(isRetryableBleConnectionError(method, error)).toBe(false);
+    expect(
+      isRetryableBleConnectionError(
+        { payload: {}, device: { wasInterruptedByUser: () => true } } as never,
+        ERRORS.TypedError(HardwareErrorCode.TransportProtocolProbeFailed)
+      )
+    ).toBe(false);
+  });
+
   test('does not retry the desktop acquire deadline fallback', () => {
     const method = { payload: { connectProtocol: 'V2' } } as never;
     const error = {

package/__tests__/firmware-update/firmware-artifact-source.test.ts

@@ -31,6 +31,10 @@ const createReader = (bytes = artifactBytes) => {
 };
 
 describe('FirmwareArtifactSource', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
   it('materializes verified bytes before exposing the source', async () => {
     const backingBytes = Uint8Array.from(artifactBytes);
     const { reader, read, close } = createReader(backingBytes);
@@ -86,6 +90,10 @@ describe('FirmwareArtifactSource', () => {
       sha256: bytesToHex(sha256(bytes)),
     };
     const { reader, read } = createReader(bytes);
+    const hasher = sha256.create();
+    const update = jest.spyOn(hasher, 'update');
+    const digest = jest.spyOn(hasher, 'digest');
+    jest.spyOn(sha256, 'create').mockReturnValue(hasher);
 
     const source = await openFirmwareByteSource({ artifact: largeArtifact, reader });
     if (!source) {
@@ -103,6 +111,9 @@ describe('FirmwareArtifactSource', () => {
         length: 3,
       },
     ]);
+    expect(update).toHaveBeenCalledTimes(2);
+    expect(update.mock.invocationCallOrder[0]).toBeLessThan(read.mock.invocationCallOrder[1]);
+    expect(digest.mock.invocationCallOrder[0]).toBeGreaterThan(update.mock.invocationCallOrder[1]);
     await source.close();
   });