@onekeyfe/hd-core 1.2.8-alpha.9 → 1.2.9

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 => {
@@ -363,11 +459,11 @@ describe('public device lifecycle events', () => {
 
   test('clears the cleanup barrier when its deadline expires', async () => {
     const realSetTimeout = setTimeout;
-    jest
-      .spyOn(global, 'setTimeout')
-      .mockImplementation((callback, delay, ...args) =>
-        realSetTimeout(callback, delay === 5_000 ? 0 : delay, ...args)
-      );
+    const cleanupDeadline = createDeferred<() => void>();
+    jest.spyOn(global, 'setTimeout').mockImplementation((callback, delay, ...args) => {
+      if (delay === 5_000) cleanupDeadline.resolve(() => callback(...args));
+      return realSetTimeout(callback, delay, ...args);
+    });
     {
       jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
       const acquire = jest.spyOn(Device.prototype, 'acquire').mockResolvedValue(undefined);
@@ -381,13 +477,15 @@ describe('public device lifecycle events', () => {
         type: IFRAME.CALL,
         payload: { method: 'getDeviceState', connectId: 'draining-device', connectProtocol: 'V2' },
       } as CoreMessage);
-      setImmediate(() => cancel(context, 'draining-device'));
+      const expireCleanupDeadline = await cleanupDeadline.promise;
+      cancel(context, 'draining-device');
+      expireCleanupDeadline();
       await expect(result).resolves.toBeDefined();
-      gate.resolve();
       await new Promise(resolve => {
         setImmediate(resolve);
       });
       expect(context.getPrePendingCallPromise('draining-device')).toBeUndefined();
+      gate.resolve();
     }
   });
 
@@ -608,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',
@@ -616,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);
@@ -627,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) => {
@@ -639,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();
   });
 

package/__tests__/logBlockEvent.test.ts

@@ -4,7 +4,18 @@ import {
   formatLogMethodLabel,
   getLogBlockLabel,
   getSafeLogPayload,
+  getSafeLogTask,
 } from '../src/events';
+import { getLog, initLog, setLoggerPostMessage } from '../src/utils/logger';
+import MoneroGetAddress from '../src/api/monero/MoneroGetAddress';
+import ZcashGetAddress from '../src/api/zcash/ZcashGetAddress';
+
+import type { Device } from '../src/device/Device';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
 
 describe('getLogBlockLabel', () => {
   it('keeps existing sensitive UI response blocking', () => {
@@ -52,11 +63,17 @@ describe('getLogBlockLabel', () => {
     }
   );
 
-  it('logs signing requests and responses as-is', () => {
+  it.each([false, true])('redacts btcSignMessage logs with debug=%s', enabled => {
+    const method = 'btcSignMessage';
+    const prefix = `sensitive-btc-sign-message-${enabled}`;
+    const logger = initLog(prefix, enabled);
+    const postMessage = jest.fn();
+    setLoggerPostMessage(postMessage);
+    const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => undefined);
     const request = {
-      method: 'btcSignMessage',
+      method,
       path: "m/44'/0'/0'/0/0",
-      messageHex: '68656c6c6f',
+      messageHex: Buffer.from('synthetic-message-marker').toString('hex'),
       coin: 'Bitcoin',
     };
     const iframeRequest = {
@@ -66,15 +83,39 @@ describe('getLogBlockLabel', () => {
     const response = {
       success: true,
       payload: {
-        signature: 'signature-bytes',
-        address: 'bc1qexample',
+        signature: 'synthetic-signature-marker',
+        address: 'synthetic-address-marker',
       },
     };
+    const task = { id: 7, method: { name: method, payload: request } };
+    const originals = JSON.stringify([request, iframeRequest, response, task]);
+    const blockLabel = getLogBlockLabel(iframeRequest);
 
-    expect(getLogBlockLabel(request)).toBeUndefined();
-    expect(getLogBlockLabel(iframeRequest)).toBeUndefined();
-    expect(getSafeLogPayload(request)).toBe(request);
-    expect(getSafeLogPayload(response)).toBe(response);
+    try {
+      expect(getLogBlockLabel(request)).toBe(method);
+      expect(blockLabel).toBe(method);
+      logger.debug('request:', getSafeLogPayload(iframeRequest, blockLabel));
+      logger.debug('response:', getSafeLogPayload(response, blockLabel));
+      logger.debug('Cancel Api connect task: ', getSafeLogTask(task));
+
+      const cached = getLog().filter(entry => entry.prefix === prefix);
+      expect(cached.map(entry => entry.message[1])).toEqual([
+        { method, payload: '[REDACTED]' },
+        { method, payload: '[REDACTED]' },
+        { id: task.id, method, payload: '[REDACTED]' },
+      ]);
+      expect(postMessage).toHaveBeenCalledTimes(3);
+      expect(consoleLog).toHaveBeenCalledTimes(enabled ? 3 : 0);
+      for (const output of [cached, postMessage.mock.calls, consoleLog.mock.calls]) {
+        const serialized = JSON.stringify(output);
+        expect(serialized).not.toContain('synthetic-');
+        expect(serialized).not.toContain(request.messageHex);
+      }
+      expect(JSON.stringify([request, iframeRequest, response, task])).toBe(originals);
+    } finally {
+      consoleLog.mockRestore();
+      setLoggerPostMessage(jest.fn());
+    }
   });
 
   it('keeps ordinary API requests and responses visible', () => {
@@ -96,4 +137,285 @@ describe('getLogBlockLabel', () => {
   it('does not classify events without an API method as method calls', () => {
     expect(getLogBlockLabel({ event: 'DEVICE_EVENT', type: 'device-connect' })).toBeUndefined();
   });
+
+  it.each(['zcashGetAddress', 'zcashGetFullViewingKey', 'zcashSignPczt'])(
+    'keeps %s wallet data out of logger caches and events with debug disabled',
+    method => {
+      const postMessage = jest.fn();
+      const prefix = `sensitive-zcash-${method}`;
+      const logger = initLog(prefix, false);
+      setLoggerPostMessage(postMessage);
+      const request = {
+        event: 'iframe-call',
+        payload: { method, pczt: 'synthetic-pczt-marker', path: 'synthetic-path-marker' },
+      };
+      const response = {
+        success: true,
+        payload: [
+          {
+            ufvk: 'synthetic-viewing-key-marker',
+            seedFingerprint: 'synthetic-fingerprint-marker',
+            pczt: 'synthetic-signed-pczt-marker',
+          },
+        ],
+      };
+      const blockLabel = getLogBlockLabel(request);
+
+      expect(blockLabel).toBe(method);
+      expect(getLogBlockLabel(request.payload)).toBe(method);
+      logger.debug('request:', getSafeLogPayload(request, blockLabel));
+      logger.debug('response:', getSafeLogPayload(response, blockLabel));
+
+      const cached = getLog().filter(entry => entry.prefix === prefix);
+      expect(cached.map(entry => entry.message[1])).toEqual([
+        { method, payload: '[REDACTED]' },
+        { method, payload: '[REDACTED]' },
+      ]);
+      expect(postMessage).toHaveBeenCalledTimes(2);
+      for (const output of [JSON.stringify(cached), JSON.stringify(postMessage.mock.calls)]) {
+        expect(output).not.toContain('synthetic-');
+        expect(output).toContain('[REDACTED]');
+      }
+      expect(response.payload[0].ufvk).toBe('synthetic-viewing-key-marker');
+    }
+  );
+
+  it.each(['moneroGetAddress', 'moneroGetWatchKey'])(
+    'keeps %s addresses and view keys out of logger caches',
+    method => {
+      const prefix = `sensitive-monero-${method}`;
+      const logger = initLog(prefix, false);
+      setLoggerPostMessage(jest.fn());
+      const request = { event: 'iframe-call', payload: { method, path: "m/44'/128'/0'" } };
+      const response = {
+        success: true,
+        payload: { address: 'synthetic-address-marker', watchKey: 'synthetic-view-key-marker' },
+      };
+      const blockLabel = getLogBlockLabel(request);
+
+      expect(blockLabel).toBe(method);
+      logger.debug('response:', getSafeLogPayload(response, blockLabel));
+
+      const cached = getLog().filter(entry => entry.prefix === prefix);
+      expect(cached.map(entry => entry.message[1])).toEqual([{ method, payload: '[REDACTED]' }]);
+      expect(JSON.stringify(cached)).not.toContain('synthetic-');
+    }
+  );
+
+  it('keeps moneroKeyImageSync transfers and key images out of logger caches', () => {
+    const method = 'moneroKeyImageSync';
+    const prefix = 'sensitive-monero-key-image-sync';
+    const logger = initLog(prefix, false);
+    setLoggerPostMessage(jest.fn());
+    const request = {
+      event: 'iframe-call',
+      payload: {
+        method,
+        path: "m/44'/128'/0'",
+        transfers: [{ outKey: 'synthetic-out-key-marker', txPubKey: 'synthetic-tx-key-marker' }],
+      },
+    };
+    const response = {
+      success: true,
+      payload: {
+        encKey: 'synthetic-enc-key-marker',
+        keyImages: [{ iv: 'synthetic-iv-marker', blob: 'synthetic-key-image-marker' }],
+      },
+    };
+    const blockLabel = getLogBlockLabel(request);
+
+    expect(blockLabel).toBe(method);
+    logger.debug('request:', getSafeLogPayload(request, blockLabel));
+    logger.debug('response:', getSafeLogPayload(response, blockLabel));
+
+    const cached = getLog().filter(entry => entry.prefix === prefix);
+    expect(cached.map(entry => entry.message[1])).toEqual([
+      { method, payload: '[REDACTED]' },
+      { method, payload: '[REDACTED]' },
+    ]);
+    expect(JSON.stringify(cached)).not.toContain('synthetic-');
+  });
+
+  // The request reveals the real ring member, masks and amounts; the result
+  // carries the key that opens the signatures.
+  it('keeps moneroSignTransaction inputs and the opening key out of logger caches', () => {
+    const method = 'moneroSignTransaction';
+    const prefix = 'sensitive-monero-sign-transaction';
+    const logger = initLog(prefix, false);
+    setLoggerPostMessage(jest.fn());
+    const payload = {
+      method,
+      path: "m/44'/128'/0'",
+      tsxData: { fee: 'synthetic-fee-marker', outputs: [{ amount: 'synthetic-amount-marker' }] },
+      inputs: [{ real_output: 'synthetic-real-index-marker', mask: 'synthetic-mask-marker' }],
+    };
+    const response = {
+      success: true,
+      payload: {
+        signatures: ['synthetic-sealed-signature-marker'],
+        openingKey: 'synthetic-opening-key-marker',
+      },
+    };
+    const blockLabel = getLogBlockLabel({ event: 'iframe-call', payload });
+
+    expect(blockLabel).toBe(method);
+    logger.debug('request:', getSafeLogPayload(payload, blockLabel));
+    logger.debug('response:', getSafeLogPayload(response, blockLabel));
+    logger.debug('Cancel Api connect task: ', getSafeLogTask({ id: 9, method: { payload } }));
+
+    const cached = getLog().filter(entry => entry.prefix === prefix);
+    expect(cached.map(entry => entry.message[1])).toEqual([
+      { method, payload: '[REDACTED]' },
+      { method, payload: '[REDACTED]' },
+      { id: 9, method, payload: '[REDACTED]' },
+    ]);
+    expect(JSON.stringify(cached)).not.toContain('synthetic-');
+  });
+
+  // Cancel logs the queued task, which holds the method's raw payload.
+  it('redacts a queued Zcash task the same way, keeping its id', () => {
+    const postMessage = jest.fn();
+    const prefix = 'sensitive-zcash-cancel';
+    const logger = initLog(prefix, false);
+    setLoggerPostMessage(postMessage);
+    const task = {
+      id: 7,
+      method: {
+        name: 'zcashSignPczt',
+        payload: { method: 'zcashSignPczt', pczt: 'synthetic-pczt-marker' },
+        pczt: 'synthetic-pczt-marker',
+      },
+    };
+
+    logger.debug('Cancel Api connect task: ', getSafeLogTask(task));
+
+    const cached = getLog().filter(entry => entry.prefix === prefix);
+    expect(cached.map(entry => entry.message[1])).toEqual([
+      { id: 7, method: 'zcashSignPczt', payload: '[REDACTED]' },
+    ]);
+    expect(JSON.stringify([cached, postMessage.mock.calls])).not.toContain('synthetic-');
+  });
+
+  it('keeps Zcash and Monero results of an all-network call out of logs, others intact', () => {
+    const response = {
+      success: true,
+      payload: [
+        {
+          network: 'evm',
+          path: "m/44'/60'/0'/0/0",
+          success: true,
+          payload: { address: '0xabc', rootFingerprint: 1 },
+        },
+        {
+          network: 'zcash',
+          path: "m/32'/133'/0'",
+          success: true,
+          payload: {
+            address: 'u1-marker',
+            ufvk: 'synthetic-viewing-key-marker',
+            rootFingerprint: 1,
+          },
+        },
+        {
+          network: 'xmr',
+          path: "m/44'/128'/0'",
+          success: true,
+          payload: { address: 'synthetic-xmr-address-marker', rootFingerprint: 1 },
+        },
+        {
+          network: 'zcash',
+          path: "m/32'/133'/1'",
+          success: false,
+          payload: { error: 'Device not support', code: 416 },
+        },
+      ],
+    };
+
+    const safe = getSafeLogPayload(response) as typeof response;
+
+    expect(safe.payload[0]).toBe(response.payload[0]);
+    expect(safe.payload[1]).toEqual({ ...response.payload[1], payload: '[REDACTED]' });
+    expect(safe.payload[2]).toEqual({ ...response.payload[2], payload: '[REDACTED]' });
+    expect(safe.payload[3]).toBe(response.payload[3]);
+    expect(JSON.stringify(safe)).not.toContain('marker');
+    expect(response.payload[1].payload).toHaveProperty('ufvk');
+  });
+
+  it('redacts a privacy network result delivered one by one as a callback', () => {
+    const message = {
+      event: 'IFRAME_CALLBACK',
+      payload: {
+        callbackId: 'item',
+        data: {
+          network: 'zcash',
+          success: true,
+          payload: { ufvk: 'synthetic-viewing-key-marker' },
+          index: 0,
+        },
+      },
+    };
+
+    expect(JSON.stringify(getSafeLogPayload(message))).not.toContain('marker');
+  });
+
+  it.each([
+    {
+      method: 'moneroGetAddress',
+      create: () =>
+        new MoneroGetAddress({
+          id: 1,
+          payload: { method: 'moneroGetAddress', path: "m/44'/128'/0'" },
+        }),
+      reply: { address: Buffer.from('synthetic-xmr-address-marker').toString('hex') },
+    },
+    {
+      method: 'zcashGetAddress',
+      create: () =>
+        new ZcashGetAddress({
+          id: 1,
+          payload: { method: 'zcashGetAddress', path: "m/32'/133'/0'" },
+        }),
+      reply: { address: 'synthetic-zcash-address-marker' },
+    },
+  ])('keeps the $method previous-address event out of logs', async ({ method, create, reply }) => {
+    const instance = create();
+    instance.init();
+    const commands = { typedCall: jest.fn().mockResolvedValue({ message: reply }) };
+    instance.device = {
+      commands,
+      getCommands: () => commands,
+      toMessageObject: () => ({}),
+    } as unknown as Device;
+    const postMessage = jest.fn();
+    instance.postMessage = postMessage;
+    await instance.run();
+
+    const [[event]] = postMessage.mock.calls;
+    expect(event).toMatchObject({
+      type: UI_REQUEST.PREVIOUS_ADDRESS_RESULT,
+      payload: { method, data: { address: expect.stringContaining('synthetic-') } },
+    });
+    const blockLabel = getLogBlockLabel(event);
+    expect(blockLabel).toBe(method);
+    expect(JSON.stringify(getSafeLogPayload(event, blockLabel))).not.toContain('synthetic-');
+  });
+
+  it('keeps previous-address events of other methods visible', () => {
+    const event = {
+      event: 'UI_EVENT',
+      type: UI_REQUEST.PREVIOUS_ADDRESS_RESULT,
+      payload: { device: {}, method: 'btcGetAddress', data: { address: 'bc1qexample' } },
+    };
+    expect(getLogBlockLabel(event)).toBeUndefined();
+    expect(getSafeLogPayload(event)).toBe(event);
+  });
+
+  it('logs other queued tasks as before', () => {
+    const task = {
+      id: 8,
+      method: { name: 'getDeviceState', payload: { method: 'getDeviceState' } },
+    };
+    expect(getSafeLogTask(task)).toBe(task);
+    expect(getSafeLogTask(undefined)).toBeUndefined();
+  });
 });

package/__tests__/logger.test.ts

@@ -0,0 +1,18 @@
+import { LoggerNames, enableLog, getLogger } from '../src/utils/logger';
+
+describe('logger', () => {
+  afterEach(() => {
+    enableLog(false);
+    jest.restoreAllMocks();
+  });
+
+  test('enables method logs that share a prefix with common-connect-sdk', () => {
+    const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    enableLog(true);
+
+    expect(getLogger(LoggerNames.Method)).toBe(getLogger(LoggerNames.HdCommonConnectSdk));
+    getLogger(LoggerNames.Method).debug('shared prefix message');
+
+    expect(consoleSpy).toHaveBeenCalledWith(LoggerNames.Method, 'shared prefix message');
+  });
+});