@onekeyfe/hd-core 1.2.0-alpha.33 → 1.2.0-alpha.35

package/src/api/FirmwareUpdateV4.ts

@@ -1,4 +1,4 @@
-import { ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
+import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
 import {
   DeviceRebootType,
   PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
@@ -767,10 +767,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const targetsToUpdate = new Set(this.params.targetsToUpdate ?? []);
 
     for (const [key, component] of entries) {
-      const target = this.getRemoteComponentTarget(key, component);
-      const updateTarget = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId);
-      const shouldInstall = updateTarget ? targetsToUpdate.has(updateTarget) : false;
-      if (shouldInstall) {
+      const targetName = component.target?.toUpperCase();
+      const target = PROTOCOL_V2_REMOTE_COMPONENT_TARGETS[targetName];
+      const updateTarget = target
+        ? PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId)
+        : undefined;
+      if (updateTarget && targetsToUpdate.has(updateTarget)) {
         const remoteBinary = await this.downloadRemoteProtocolV2Component(key, component);
         if (remoteBinary.kind === 'bootloader') {
           bootloaderBinary = remoteBinary.binary;
@@ -992,14 +994,31 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     if (typeof this.device.isBootloader === 'function') {
       return this.device.isBootloader();
     }
-    return !!this.device.features?.bootloaderMode;
+    return (
+      this.device.features?.mode === 'bootloader' ||
+      (this.device.features?.mode == null && !!this.device.features?.bootloaderMode)
+    );
+  }
+
+  private isProtocolV2RomloaderMode() {
+    if (!this.device.isProtocolV2() || this.device.getCurrentDeviceType() !== EDeviceType.Pro2) {
+      return false;
+    }
+    if (typeof this.device.isRomloader === 'function') {
+      return this.device.isRomloader();
+    }
+    return this.device.features?.mode === 'romloader';
   }
 
   async enterProtocolV2BootloaderMode() {
     // romloader is the first update environment and forwards targets to bootloader.
     // It rejects DeviceRebootType.Bootloader, so reuse the current connection.
-    if (this.isProtocolV2BootloaderMode() || this.device.features?.mode === 'romloader') {
-      Log.debug('Protocol V2 device is already in loader mode, skip reboot to bootloader');
+    if (this.isProtocolV2RomloaderMode()) {
+      Log.debug('Protocol V2 device is in romloader mode; start firmware update directly');
+      return false;
+    }
+    if (this.isProtocolV2BootloaderMode()) {
+      Log.debug('Protocol V2 device is already in bootloader mode, skip reboot');
       return false;
     }
 
@@ -1034,10 +1053,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
         });
         this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
-        // This is a reconnect probe after a Bootloader reboot. Bootloader does not
-        // support DeviceStatusGet, so the generic runtime-mode probe is invalid here.
-        const features = this.device.updateProtocolV2Features(deviceInfo, null, 'bootloader');
-        if (features?.bootloaderMode) {
+        const features = await this.device.probeProtocolV2RuntimeState(
+          deviceInfo,
+          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+        );
+        if (features?.mode === 'bootloader') {
           return features;
         }
         lastError = new Error('Protocol V2 device is reachable but is not in bootloader mode');
@@ -1289,7 +1309,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
       try {
         await this.reconnectProtocolV2Device();
-        await this.verifyProtocolV2ReconnectIdentity();
+        const deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
         try {
           const statusResponse = await this.device.getCommands().typedCall(
             'DeviceFirmwareUpdateStatusGet',
@@ -1319,20 +1339,25 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           ) {
             throw error;
           }
-          // App firmware does not register DeviceFirmwareUpdateStatusGet. If the
-          // device already rebooted into App, this endpoint error signals that the
-          // install phase ended; the later phase performs the final readiness check.
+          // App firmware does not register DeviceFirmwareUpdateStatusGet. Treat the
+          // missing endpoint as completion only after the runtime probe confirms App mode.
           if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
+            if (await this.probeProtocolV2NormalMode(deviceInfo)) {
+              Log.log(
+                '[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot'
+              );
+              return;
+            }
+            lastError = new Error(
+              'Protocol V2 firmware status endpoint is unavailable while the device remains in loader mode'
+            );
+          } else {
+            lastError = error;
             Log.log(
-              '[FirmwareUpdateV4] firmware status endpoint unavailable after reboot; continue with normal-mode verification'
+              '[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ',
+              error
             );
-            return;
           }
-          lastError = error;
-          Log.log(
-            '[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ',
-            error
-          );
         }
       } catch (error) {
         lastError = error;
@@ -1361,6 +1386,14 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     await this.protocolV2Reboot(DeviceRebootType.Normal);
   }
 
+  private async probeProtocolV2NormalMode(deviceInfo: ProtocolV2DeviceInfo) {
+    const features = await this.device.probeProtocolV2RuntimeState(
+      deviceInfo,
+      PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+    );
+    return features.mode === 'normal' && !features.bootloaderMode;
+  }
+
   private async waitForProtocolV2FinalFeatures() {
     const features = await this.waitForProtocolV2ReconnectAndFeatures(
       PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT
@@ -1613,9 +1646,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const env = DataManager.getSettings('env');
     if (DataManager.isBleConnect(env)) {
       await wait(3000);
-      await this.acquireProtocolV2BleDevice();
-      await this.device.initialize();
     }
+    await this.reconnectProtocolV2Device();
+    await this.verifyProtocolV2ReconnectIdentity();
+    await this.device.initialize();
     await wait(2000);
   }
 

package/src/api/GetPassphraseState.ts

@@ -1,6 +1,7 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
+import { refreshProtocolV2DeviceStatus } from '../protocols/protocol-v2/walletSession';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
 import { BaseMethod } from './BaseMethod';
 
@@ -20,6 +21,12 @@ export default class GetPassphraseState extends BaseMethod {
     }
 
     const isProtocolV2 = this.device.isProtocolV2();
+    if (isProtocolV2 && this.payload.useEmptyPassphrase !== true) {
+      const features = await refreshProtocolV2DeviceStatus(this.device);
+      if (features.unlocked === false) {
+        await this.device.unlockDevice();
+      }
+    }
     const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(
       this.device,
       isProtocolV2
@@ -30,8 +37,10 @@ export default class GetPassphraseState extends BaseMethod {
         : undefined
     );
 
-    const passphraseProtection = this.device.getCurrentPassphraseProtection();
+    if (!isProtocolV2 && this.device.getCurrentPassphraseProtection() !== true) {
+      return undefined;
+    }
 
-    return Promise.resolve(passphraseProtection === true ? passphraseState : undefined);
+    return passphraseState;
   }
 }

package/src/api/OpenWalletSession.ts

@@ -103,6 +103,11 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       currentDeviceId = refreshedState.identity.deviceId;
       return requireDeviceId();
     };
+    const unlockProtocolV2IfLocked = async () => {
+      if (isProtocolV2 && state.status.unlocked === false) {
+        await this.device.unlockDevice();
+      }
+    };
 
     const protocol = isProtocolV2 ? 'V2' : 'V1';
 
@@ -135,9 +140,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
     if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
       if (isProtocolV2) {
-        if (this.device.features?.unlocked === false) {
-          await this.device.unlockDevice();
-        }
+        await unlockProtocolV2IfLocked();
         const refreshedDeviceId = await refreshProtocolV2DeviceId();
         if (refreshedDeviceId !== this.params.deviceId) {
           deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
@@ -151,7 +154,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
         this.params.deviceId,
         this.params.passphraseState
       );
-      if (!cachedSessionId) {
+      if (!cachedSessionId && !isProtocolV2) {
         throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
       }
       if (!isProtocolV2) {
@@ -168,7 +171,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
             expectPassphraseState: this.params.passphraseState,
           });
       const deviceId = requireDeviceId();
-      if (!session.passphraseState) {
+      if (session.passphraseState !== this.params.passphraseState) {
         this.device.clearInternalState();
         throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
       }
@@ -177,21 +180,26 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
         walletType: 'hidden',
         deviceId,
         ...requireHiddenWalletResponse(session),
-        resumed: wasResumed(session) || session.newSession === cachedSessionId,
+        resumed: wasResumed(session) || (!isProtocolV2 && session.newSession === cachedSessionId),
       };
     }
 
     this.device.passphraseState = undefined;
+    await unlockProtocolV2IfLocked();
     const session = isProtocolV2
-      ? await getProtocolV2WalletSession(this.device, { initSession: true })
+      ? await getProtocolV2WalletSession(this.device, { forceWalletSelection: true })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
     const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
+    if (isProtocolV2 && this.device.getCurrentPassphraseProtection() !== true) {
+      this.device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
+    }
     const responseBase = {
       protocol,
       deviceId,
       resumed: wasResumed(session),
     } as const;
-    return this.device.getCurrentPassphraseProtection() === false
+    return !isProtocolV2 && this.device.getCurrentPassphraseProtection() === false
       ? {
           ...responseBase,
           walletType: 'standard',

package/src/api/device/DeviceSettings.ts

@@ -195,7 +195,14 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
             page: DeviceSettingsPage.DevicePassphrase,
           });
           const updated = await this.device.getDeviceState({ refreshSections: ['status'] });
-          if (updated.status.passphraseProtection !== requestedPassphrase) {
+          const lockedAfterDisabling =
+            requestedPassphrase === false &&
+            current.status.unlocked === true &&
+            updated.status.unlocked === false;
+          if (
+            updated.status.passphraseProtection !== requestedPassphrase &&
+            !lockedAfterDisabling
+          ) {
             throw TypedError(
               HardwareErrorCode.RuntimeError,
               'Protocol V2 passphrase setting did not reach the requested value.'

package/src/api/evm/EVMGetAddress.ts

@@ -2,9 +2,9 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import TransportManager from '../../data-manager/TransportManager';
 import getAddressLegacyV1 from './legacyV1/getAddress';
 import getAddress from './latest/getAddress';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 
 import type { EVMAddress, EVMGetAddressParams } from '../../types';
 import type { EthereumGetAddressOneKey } from '@onekeyfe/hd-transport';
@@ -48,7 +48,7 @@ export default class EvmGetAddress extends BaseMethod<EthereumGetAddressOneKey[]
   }
 
   async getEvmAddress(param: EthereumGetAddressOneKey) {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
       return getAddressLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         param,

package/src/api/evm/EVMGetPublicKey.ts

@@ -2,9 +2,9 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import TransportManager from '../../data-manager/TransportManager';
 import getPublicKey from './latest/getPublicKey';
 import getPublicKeyLegacyV1 from './legacyV1/getPublicKey';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 import { batchGetPublickeys, supportBatchPublicKeyByDevice } from '../helpers/batchGetPublickeys';
 
 import type { EVMGetPublicKeyParams, EVMPublicKey } from '../../types';
@@ -60,7 +60,7 @@ export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneK
   }
 
   getEvmPublicKey(param: EthereumGetPublicKey) {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
       return getPublicKeyLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         param,

package/src/api/evm/EVMSignMessage.ts

@@ -3,9 +3,9 @@ import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
-import TransportManager from '../../data-manager/TransportManager';
 import signMessage from './latest/signMessage';
 import signMessageLegacyV1 from './legacyV1/signMessage';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 
 import type { EthereumSignMessageOneKey } from '@onekeyfe/hd-transport';
 
@@ -40,7 +40,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumSignMessageOneKey
   }
 
   async run() {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
       return signMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

package/src/api/evm/EVMSignTransaction.ts

@@ -5,9 +5,9 @@ import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
-import TransportManager from '../../data-manager/TransportManager';
 import { signTransaction } from './latest/signTransaction';
 import { signTransaction as signTransactionLegacyV1 } from './legacyV1/signTransaction';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 
 import type {
   EVMSignTransactionParams,
@@ -126,7 +126,7 @@ export default class EVMSignTransaction extends BaseMethod {
 
     if (formattedTx == null) throw ERRORS.TypedError('Runtime', 'formattedTx is not set');
 
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
       return signTransactionLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         addressN,

package/src/api/evm/EVMSignTypedData.ts

@@ -15,8 +15,8 @@ import {
   type EthereumSignTypedDataMessage,
   type EthereumSignTypedDataTypes,
 } from '../../types';
-import TransportManager from '../../data-manager/TransportManager';
 import { signTypedHash as signTypedHashLegacyV1 } from './legacyV1/signTypedHash';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 import { signTypedHash } from './latest/signTypedHash';
 import { signTypedData as signTypedDataLegacyV1 } from './legacyV1/signTypedData';
 import { signTypedData } from './latest/signTypedData';
@@ -278,29 +278,23 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     let supportTrezor = false;
     let response: MessageResponse<MessageKey>;
-    switch (TransportManager.getProtocolV1MessageSchema()) {
-      case 'v1LegacySchema':
-        supportTrezor = true;
-        response = await signTypedDataLegacyV1({
-          typedCall: this.device.commands.typedCall.bind(this.device.commands),
-          addressN,
-          data,
-          metamaskV4Compat,
-          chainId,
-        });
-        break;
-
-      case 'v1CurrentSchema':
-      default:
-        supportTrezor = false;
-        response = await signTypedData({
-          typedCall: this.device.commands.typedCall.bind(this.device.commands),
-          addressN,
-          data,
-          metamaskV4Compat,
-          chainId,
-        });
-        break;
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
+      supportTrezor = true;
+      response = await signTypedDataLegacyV1({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        addressN,
+        data,
+        metamaskV4Compat,
+        chainId,
+      });
+    } else {
+      response = await signTypedData({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        addressN,
+        data,
+        metamaskV4Compat,
+        chainId,
+      });
     }
 
     return this.handleSignTypedData({
@@ -326,28 +320,24 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
   }) {
     if (!domainHash) throw ERRORS.TypedError('Runtime', 'domainHash is required');
 
-    switch (TransportManager.getProtocolV1MessageSchema()) {
-      case 'v1LegacySchema':
-        return signTypedHashLegacyV1({
-          typedCall,
-          addressN,
-          domainHash,
-          messageHash,
-          chainId,
-          device: this.device,
-        });
-
-      case 'v1CurrentSchema':
-      default:
-        return signTypedHash({
-          typedCall,
-          addressN,
-          domainHash,
-          messageHash,
-          chainId,
-          device: this.device,
-        });
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
+      return signTypedHashLegacyV1({
+        typedCall,
+        addressN,
+        domainHash,
+        messageHash,
+        chainId,
+        device: this.device,
+      });
     }
+    return signTypedHash({
+      typedCall,
+      addressN,
+      domainHash,
+      messageHash,
+      chainId,
+      device: this.device,
+    });
   }
 
   getVersionRange() {

package/src/api/evm/EVMVerifyMessage.ts

@@ -2,9 +2,9 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
-import TransportManager from '../../data-manager/TransportManager';
 import verifyMessageLegacyV1 from './legacyV1/verifyMessage';
 import verifyMessage from './latest/verifyMessage';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 
 import type { EthereumVerifyMessageOneKey } from '@onekeyfe/hd-transport';
 
@@ -35,7 +35,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessageOneK
   }
 
   async run() {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
       return verifyMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

package/src/api/evm/protocol.ts

@@ -0,0 +1,6 @@
+import TransportManager from '../../data-manager/TransportManager';
+
+import type { Device } from '../../device/Device';
+
+export const shouldUseLegacyV1EvmMessages = (device: Pick<Device, 'isProtocolV2'>): boolean =>
+  !device.isProtocolV2() && TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema';

package/src/api/kaspa/KaspaSignTransaction.ts

@@ -104,7 +104,14 @@ export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactio
     });
 
     const outputs: KaspaSignTransactionParams['outputs'] = payload.outputs.map(output => {
+      const address = getOutputAddress(output);
       const addressN = getOutputAddressN(output);
+      if (address !== undefined && addressN !== undefined) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.CallMethodInvalidParameter,
+          'KaspaSignTransaction: outputs must not contain both address and addressN'
+        );
+      }
       validateParams(output, [
         { name: 'satoshis', required: true },
         { name: 'address', type: 'string' },

package/src/api/protocol-v2/DeviceGetOnboardingStatus.ts

@@ -12,8 +12,8 @@ export default class DeviceGetOnboardingStatus extends BaseMethod {
 
   async run() {
     const { message } = await this.device.commands.typedCall(
-      'DevGetOnboardingStatus',
-      'DevOnboardingStatus',
+      'OnboardingStatusGet',
+      'OnboardingStatus',
       {}
     );
     return message;

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -74,7 +74,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     this.encoded = encodePro2Wallpaper({ width, height, rgba: rgbaBytes });
     this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
     this.params = { width, height, rgba: rgbaBytes, fileName, chunkSize };
-    this.unlockPolicy = 'unlock-before-run';
+    this.unlockPolicy = 'none';
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
   }

package/src/core/index.ts

@@ -46,7 +46,9 @@ import {
   createDeviceMessage,
   createResponseMessage,
   createUiMessage,
+  formatLogMethodLabel,
   getLogBlockLabel,
+  getSafeLogPayload,
 } from '../events';
 import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
@@ -1451,14 +1453,14 @@ export default class Core extends EventEmitter {
       case IFRAME.CALL: {
         const logBlockLabel = getLogBlockLabel(message);
         Log.log(
-          `[${Date.now()}][CALL_API]`,
-          logBlockLabel ? { method: logBlockLabel, payload: '[REDACTED]' } : message
+          formatLogMethodLabel(`[${Date.now()}][CALL_API]`, logBlockLabel),
+          getSafeLogPayload(message, logBlockLabel)
         );
         const response = await callAPI(this.getCoreContext(), message);
         const { success, payload } = response;
         Log.log(
-          `[${Date.now()}][CALL_API_RESPONSE]`,
-          logBlockLabel ? { method: logBlockLabel, payload: '[REDACTED]' } : response
+          formatLogMethodLabel(`[${Date.now()}][CALL_API_RESPONSE]`, logBlockLabel),
+          getSafeLogPayload(response, logBlockLabel)
         );
         if (success) {
           return response;
@@ -1516,7 +1518,7 @@ export default class Core extends EventEmitter {
     // Preserve synchronous dispose semantics for in-memory state and listeners.
     _deviceList = undefined;
     _connector = undefined;
-    DevicePool.resetState();
+    DevicePool.dispose();
     deviceCacheMap.clear();
     preWarmInflight.clear();
     preWarmDoneAt.clear();