@onekeyfe/hd-core 1.2.0-alpha.20 → 1.2.0-alpha.22

package/src/api/OpenWalletSession.ts

@@ -34,6 +34,25 @@ const wasResumed = (session: unknown) =>
   'resumed' in session &&
   (session as { resumed?: unknown }).resumed === true;
 
+const forwardSessionId = (session: { newSession?: string }) =>
+  session.newSession ? { sessionId: session.newSession } : {};
+
+const requireHiddenWalletResponse = (session: {
+  passphraseState?: string;
+  newSession?: string;
+}) => {
+  if (!session.passphraseState) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.DeviceInitializeFailed,
+      'Hidden wallet response is missing passphraseState'
+    );
+  }
+  return {
+    passphraseState: session.passphraseState,
+    ...forwardSessionId(session),
+  };
+};
+
 type NormalizedOpenWalletSessionParams = OpenWalletSessionParams & {
   legacySessionToClear?: {
     deviceId?: string;
@@ -117,30 +136,47 @@ export default class OpenWalletSession extends BaseMethod<NormalizedOpenWalletSe
   }
 
   async run(): Promise<OpenWalletSessionPayload> {
+    const isProtocolV2 = this.device.isProtocolV2();
     const state = await this.device.getDeviceState({ refreshSections: ['status'] });
-    const currentDeviceId = state.identity.deviceId;
-    if (!currentDeviceId) {
-      throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
-    }
-
+    let currentDeviceId = state.identity.deviceId;
     const { legacySessionToClear } = this.params;
-    if (
-      legacySessionToClear &&
-      (!legacySessionToClear.deviceId || legacySessionToClear.deviceId === currentDeviceId)
-    ) {
-      deviceWalletSessionStore.delete(currentDeviceId, legacySessionToClear.passphraseState);
+    const requireDeviceId = () => {
+      if (!currentDeviceId) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+      }
+      return currentDeviceId;
+    };
+    const clearLegacySession = () => {
+      const deviceId = requireDeviceId();
+      if (
+        legacySessionToClear &&
+        (!legacySessionToClear.deviceId || legacySessionToClear.deviceId === deviceId)
+      ) {
+        deviceWalletSessionStore.delete(deviceId, legacySessionToClear.passphraseState);
+      }
+    };
+    const refreshProtocolV2DeviceId = async () => {
+      const refreshedState = await this.device.getDeviceState({ refreshSections: ['status'] });
+      currentDeviceId = refreshedState.identity.deviceId;
+      clearLegacySession();
+      return requireDeviceId();
+    };
+
+    if (!isProtocolV2) {
+      clearLegacySession();
     }
 
-    const protocol = this.device.isProtocolV2() ? 'V2' : 'V1';
+    const protocol = isProtocolV2 ? 'V2' : 'V1';
 
     if (this.params.mode === 'standard') {
       this.device.passphraseState = undefined;
-      const session = this.device.isProtocolV2()
+      const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, { onlyMainPin: true })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             onlyMainPin: true,
             initSession: this.payload.initSession,
           });
+      const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
       if (session.unlockedAttachPin) {
         try {
           await this.device.lockDevice();
@@ -153,14 +189,24 @@ export default class OpenWalletSession extends BaseMethod<NormalizedOpenWalletSe
       return {
         protocol,
         walletType: 'standard',
-        deviceId: currentDeviceId,
+        deviceId,
         passphraseState: null,
+        ...forwardSessionId(session),
         resumed: wasResumed(session),
       };
     }
 
     if (this.params.mode === 'resume-hidden') {
-      if (currentDeviceId !== this.params.deviceId) {
+      if (isProtocolV2) {
+        if (this.device.features?.unlocked === false) {
+          await this.device.unlockDevice();
+        }
+        const refreshedDeviceId = await refreshProtocolV2DeviceId();
+        if (refreshedDeviceId !== this.params.deviceId) {
+          deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
+          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+        }
+      } else if (requireDeviceId() !== this.params.deviceId) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
       }
       this.device.passphraseState = this.params.passphraseState;
@@ -171,19 +217,20 @@ export default class OpenWalletSession extends BaseMethod<NormalizedOpenWalletSe
       if (!cachedSessionId) {
         throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
       }
-      if (!this.device.isProtocolV2()) {
+      if (!isProtocolV2) {
         await this.device.initialize({
           deviceId: this.params.deviceId,
           passphraseState: this.params.passphraseState,
         });
       }
-      const session = this.device.isProtocolV2()
+      const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, {
             expectedPassphraseState: this.params.passphraseState,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             expectPassphraseState: this.params.passphraseState,
           });
+      const deviceId = requireDeviceId();
       if (!session.passphraseState) {
         this.device.clearInternalState();
         throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
@@ -191,31 +238,33 @@ export default class OpenWalletSession extends BaseMethod<NormalizedOpenWalletSe
       return {
         protocol,
         walletType: 'hidden',
-        deviceId: currentDeviceId,
-        passphraseState: session.passphraseState ?? null,
+        deviceId,
+        ...requireHiddenWalletResponse(session),
         resumed: wasResumed(session) || session.newSession === cachedSessionId,
       };
     }
 
     this.device.passphraseState = undefined;
-    const session = this.device.isProtocolV2()
+    const session = isProtocolV2
       ? await getProtocolV2WalletSession(this.device, { initSession: true })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
+    const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
     const responseBase = {
       protocol,
-      deviceId: currentDeviceId,
+      deviceId,
       resumed: wasResumed(session),
     } as const;
-    return session.passphraseState
+    return this.device.getCurrentPassphraseProtection() === false
       ? {
           ...responseBase,
-          walletType: 'hidden',
-          passphraseState: session.passphraseState,
+          walletType: 'standard',
+          passphraseState: null,
+          ...forwardSessionId(session),
         }
       : {
           ...responseBase,
-          walletType: 'standard',
-          passphraseState: null,
+          walletType: 'hidden',
+          ...requireHiddenWalletResponse(session),
         };
   }
 }

package/src/api/UploadPortfolio.ts

@@ -2,22 +2,15 @@ import FileWrite from './FileWrite';
 
 export type UploadPortfolioParams = {
   packageBytes: ArrayBuffer | Uint8Array | Blob;
-  operationId?: string;
   timeoutMs?: number | string;
 };
 
 const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.okpkg.pending';
 const PORTFOLIO_CHUNK_SIZE = 2048;
-const PORTFOLIO_RESPONSE_TIMEOUT_MS = 5_000;
-const PORTFOLIO_MAX_ABORT_LATENCY_MS = PORTFOLIO_RESPONSE_TIMEOUT_MS * 2 + 2_000;
 
 export default class UploadPortfolio extends FileWrite {
   init() {
     const { packageBytes, timeoutMs } = this.payload as UploadPortfolioParams;
-    const responseTimeoutMs = Math.min(
-      timeoutMs === undefined ? PORTFOLIO_RESPONSE_TIMEOUT_MS : Number(timeoutMs),
-      PORTFOLIO_RESPONSE_TIMEOUT_MS
-    );
     this.payload = {
       ...this.payload,
       path: PORTFOLIO_PENDING_PATH,
@@ -27,12 +20,10 @@ export default class UploadPortfolio extends FileWrite {
       overwrite: true,
       append: false,
       emitProgress: false,
-      timeoutMs: responseTimeoutMs,
+      timeoutMs,
     };
     super.init();
-    this.executionPriority = 'background';
-    this.maxAbortLatencyMs = PORTFOLIO_MAX_ABORT_LATENCY_MS;
-    this.unlockPolicy = 'retry-on-locked';
+    this.unlockPolicy = 'unlock-before-run';
     // Portfolio is a background write/apply flow and never synthesizes UI events.
     this.protocolV2UiMode = 'none';
   }
@@ -40,8 +31,7 @@ export default class UploadPortfolio extends FileWrite {
   async run() {
     const stagedFile = await super.run();
     this.throwIfAborted();
-    const timeoutMs = Number(this.params.timeoutMs);
-    await this.device.commands.typedCall('PortfolioUpdate', 'Success', {}, { timeoutMs });
+    await this.device.commands.typedCall('PortfolioUpdate', 'Success', {});
     return {
       ...stagedFile,
       portfolioUpdated: true,

package/src/api/conflux/ConfluxGetAddress.ts

@@ -7,6 +7,8 @@ import type { ConfluxGetAddress as HardwareConfluxGetAddress } from '@onekeyfe/h
 import type { ConfluxAddress, ConfluxGetAddressParams } from '../../types/api/confluxGetAddress';
 
 export default class ConfluxGetAddress extends BaseMethod<HardwareConfluxGetAddress[]> {
+  checkDeviceId = true;
+
   hasBundle = false;
 
   init() {

package/src/api/conflux/ConfluxSignMessage.ts

@@ -7,6 +7,8 @@ import { formatAnyHex } from '../helpers/hexUtils';
 import type { ConfluxSignMessage as HardwareConfluxSignMessage } from '@onekeyfe/hd-transport';
 
 export default class ConfluxSignMessage extends BaseMethod<HardwareConfluxSignMessage> {
+  checkDeviceId = true;
+
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
     this.allowUsePreInitialize = true;

package/src/api/conflux/ConfluxSignMessageCIP23.ts

@@ -7,6 +7,8 @@ import { formatAnyHex } from '../helpers/hexUtils';
 import type { ConfluxSignMessageCIP23 as HardwareConfluxSignMessageCIP23 } from '@onekeyfe/hd-transport';
 
 export default class ConfluxSignMessageCIP23 extends BaseMethod<HardwareConfluxSignMessageCIP23> {
+  checkDeviceId = true;
+
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
     this.allowUsePreInitialize = true;

package/src/api/conflux/ConfluxSignTransaction.ts

@@ -16,6 +16,8 @@ import type {
 import type { ConfluxSignTx, ConfluxTxRequest } from '@onekeyfe/hd-transport';
 
 export default class ConfluxSignTransaction extends BaseMethod {
+  checkDeviceId = true;
+
   addressN: number[] = [];
 
   formattedTx: ConfluxTransaction | undefined;

package/src/api/device/DeviceChangePin.ts

@@ -8,7 +8,7 @@ import type { ChangePin } from '@onekeyfe/hd-transport';
 
 export default class DeviceChangePin extends BaseMethod<ChangePin> {
   init() {
-    this.unlockPolicy = 'retry-on-locked';
+    this.unlockPolicy = 'unlock-before-run';
     this.useDevicePassphraseState = false;
 
     // check payload

package/src/api/device/DeviceSettings.ts

@@ -10,11 +10,56 @@ import {
   mapDeviceSettingsToState,
 } from '../../device/DeviceStateMapper';
 import { getProtocolV2SettingsBehavior } from '../../protocols/protocol-v2/settingsUnlockPolicy';
-import { LANGUAGE_LABELS } from '../../utils/deviceSettings';
+import {
+  DEVICE_SETTINGS_V1_ONLY_FIELDS,
+  DEVICE_SETTINGS_V2_ONLY_FIELDS,
+  LANGUAGE_LABELS,
+  getDeviceSettingsCapabilities,
+} from '../../utils/deviceSettings';
 
 import type { ApplySettings } from '@onekeyfe/hd-transport';
 import type { DeviceSettingsParams } from '../../types/api/deviceSettings';
 
+const assertSettingsSupported = (
+  payload: DeviceSettingsParams,
+  unsupported: readonly (keyof DeviceSettingsParams)[],
+  protocol: 'Protocol V1' | 'Protocol V2'
+) => {
+  const provided = unsupported.filter(key => payload[key] !== undefined);
+  if (provided.length > 0) {
+    throw invalidParameter(`${protocol} does not support settings: ${provided.join(', ')}.`);
+  }
+};
+
+const assertProtocolV2SettingValues = (
+  payload: DeviceSettingsParams,
+  capabilities: ReturnType<typeof getDeviceSettingsCapabilities>
+) => {
+  const brightnessRange = capabilities.ranges.brightness;
+  if (
+    payload.brightness !== undefined &&
+    brightnessRange &&
+    (payload.brightness < brightnessRange.min || payload.brightness > brightnessRange.max)
+  ) {
+    throw invalidParameter(
+      `Protocol V2 brightness must be between ${brightnessRange.min} and ${brightnessRange.max}.`
+    );
+  }
+
+  const delayFields = [
+    ['autoLockDelayMs', capabilities.autoLockDelayOptions],
+    ['autoShutdownDelayMs', capabilities.autoShutdownDelayOptions],
+  ] as const;
+  delayFields.forEach(([field, options]) => {
+    const value = payload[field];
+    if (value !== undefined && !options.some(option => option.valueMs === value)) {
+      throw invalidParameter(
+        `Protocol V2 ${field} must be one of: ${options.map(option => option.valueMs).join(', ')}.`
+      );
+    }
+  });
+};
+
 const settingsPageForPayload = (
   payload: DeviceSettingsParams
 ): DeviceSettingsPage.DevicePassphrase | DeviceSettingsPage.DeviceAirgap | undefined => {
@@ -70,6 +115,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
       safety_checks: this.payload.safetyChecks,
       experimental_features: this.payload.experimentalFeatures,
       auto_shutdown_delay_ms: this.payload.autoShutdownDelayMs,
+      use_ble: this.payload.bluetoothEnabled,
       ...(this.payload.changeBrightness
         ? { change_brightness: this.payload.changeBrightness }
         : undefined),
@@ -113,6 +159,12 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
   async run() {
     try {
       if (this.device.isProtocolV2()) {
+        assertSettingsSupported(this.payload, DEVICE_SETTINGS_V1_ONLY_FIELDS, 'Protocol V2');
+        const capabilities = getDeviceSettingsCapabilities(
+          this.device.getCurrentDeviceType(),
+          'V2'
+        );
+        assertProtocolV2SettingValues(this.payload, capabilities);
         const settings = mapCommonSettingsToProtocolV2(this.payload);
         const requestedPassphrase = this.payload.usePassphrase;
         const requestedAirgap = this.payload.airgapMode;
@@ -172,18 +224,27 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
         const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
           settings,
         });
-        this.device.updateState(mapDeviceSettingsToState(settings), 'apply-settings');
+        this.device.updateState(mapDeviceSettingsToState(settings), 'settings-write');
         return res.message;
       }
 
-      if (this.payload.airgapMode !== undefined) {
-        throw invalidParameter('Air-gap settings are not supported by Protocol V1.');
+      assertSettingsSupported(this.payload, DEVICE_SETTINGS_V2_ONLY_FIELDS, 'Protocol V1');
+      const capabilities = getDeviceSettingsCapabilities(this.device.getCurrentDeviceType(), 'V1');
+      if (
+        this.payload.safetyChecks !== undefined &&
+        !capabilities.safetyCheckOptions.some(option => option.value === this.payload.safetyChecks)
+      ) {
+        throw invalidParameter(
+          `Protocol V1 safetyChecks must be one of: ${capabilities.safetyCheckOptions
+            .map(option => option.value)
+            .join(', ')}.`
+        );
       }
 
       const res = await this.device.commands.typedCall('ApplySettings', 'Success', {
         ...this.params,
       });
-      this.device.updateState(mapApplySettingsToState(this.params), 'apply-settings');
+      this.device.updateState(mapApplySettingsToState(this.params), 'settings-write');
       return res.message;
     } catch (error) {
       if (error.message?.toLowerCase().includes('no setting provided')) {

package/src/api/device/DeviceUpdateBootloader.ts

@@ -5,15 +5,19 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { FirmwareUpdateTipMessage } from '../../events/ui-request';
 import { FirmwareUpdateBaseMethod } from '../firmware/FirmwareUpdateBaseMethod';
 import { getSysResourceBinary } from '../firmware/getBinary';
-import { updateBootloader } from '../firmware/uploadFirmware';
+import { updateBootloader, updateBootloaderFromSource } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
-import { checkBootloaderLength } from '../firmware/updateBootloader';
+import { checkBootloaderLength, checkBootloaderSourceLength } from '../firmware/updateBootloader';
+import { openFirmwareByteSource } from '../firmware/FirmwareArtifactSource';
+import { resolveFirmwareUpdateHostBinding } from '../firmware/FirmwareHostBinding';
+import { assertFirmwareUpdatePreparedPlanBinding } from '../firmware/FirmwareUpdatePreparedPlan';
 
 import type { DeviceUpdateBootloaderParams } from '../../types/api/deviceUpdateBootloader';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Device } from '../../device/Device';
 import type { Features } from '../../types';
+import type { FirmwareByteSource } from '../firmware/FirmwareArtifactSource';
 
 export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any> {
   init() {
@@ -43,17 +47,68 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     return true;
   }
 
+  async updateBootloaderWithEmmcFileWriteFromSource(_device: Device, source: FirmwareByteSource) {
+    const filePath = '0:boot/bootloader.bin';
+
+    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+    await this.emmcCommonUpdateProcessFromSource({
+      source,
+      filePath,
+    });
+    this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
+    await this.reboot(RebootType.Normal);
+    this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloaderSuccess);
+    return true;
+  }
+
   async updateTouchBootloader({
     device,
     features,
     firmwareType,
+    binary: preparedBinary,
+    source: preparedSource,
   }: {
     device: Device;
     features?: Features;
     firmwareType: EFirmwareType;
+    binary?: ArrayBuffer;
+    source?: FirmwareByteSource;
   }) {
-    let { binary } = this.payload;
+    if (preparedSource) {
+      if (!(await checkBootloaderSourceLength(preparedSource))) {
+        throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
+      }
+      if (features && device.isBootloader()) {
+        this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
+        const result = await this.updateBootloaderWithEmmcFileWriteFromSource(
+          device,
+          preparedSource
+        );
+        return result;
+      }
+      if (features && !device.isBootloader()) {
+        await updateBootloaderFromSource(
+          this.device.getCommands().typedCall.bind(this.device.getCommands()),
+          this.postMessage,
+          device,
+          preparedSource
+        );
+        return true;
+      }
+    }
+
+    let binary = preparedBinary;
     if (!binary) {
+      if (DataManager.getSettings('firmwareManifestMode') === 'external-only') {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Bootloader must be prepared by the external firmware host',
+          {
+            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+            artifactName: 'bootloader',
+          }
+        );
+      }
       this.postTipMessage(FirmwareUpdateTipMessage.CheckLatestUiResource);
       const resourceUrl = features
         ? DataManager.getBootloaderResource(features, firmwareType)
@@ -68,7 +123,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
       }
     }
 
-    if (!checkBootloaderLength(binary)) {
+    if (!binary || !checkBootloaderLength(binary)) {
       throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
     }
 
@@ -76,7 +131,8 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     if (features && device.isBootloader()) {
       // Use emmcFileWrite + reboot logic for bootloader mode
       this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-      return this.updateBootloaderWithEmmcFileWrite(device, binary);
+      const result = await this.updateBootloaderWithEmmcFileWrite(device, binary);
+      return result;
     }
 
     if (features && !device.isBootloader()) {
@@ -96,13 +152,65 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     const { features } = device;
 
     const payload = this.payload as DeviceUpdateBootloaderParams;
+    const hostBinding = payload.artifact
+      ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
+      : undefined;
+    const executionParams = {
+      ...payload,
+      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
+    };
+    if (payload.artifact) {
+      assertFirmwareUpdatePreparedPlanBinding({
+        preparedPlan: payload.preparedPlan,
+        executor: 'v2',
+        scopeTargets: ['bootloader'],
+        bindings: [
+          {
+            target: 'bootloader',
+            artifact: payload.artifact,
+          },
+        ],
+      });
+      const source = await openFirmwareByteSource({
+        artifact: payload.artifact,
+        reader: executionParams.artifactReader,
+      });
+      if (!source) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Bootloader artifact is not prepared'
+        );
+      }
+      try {
+        const deviceType = device.getCurrentDeviceType();
+        const deviceFirmwareType = device.getCurrentFirmwareType();
+        const firmwareType = payload.firmwareType ?? deviceFirmwareType;
+        if (DeviceModelToTypes.model_touch.includes(deviceType)) {
+          return await this.updateTouchBootloader({
+            device,
+            features,
+            firmwareType,
+            source,
+          });
+        }
+        return true;
+      } finally {
+        await source.close();
+      }
+    }
 
+    const { binary } = payload;
     const deviceType = device.getCurrentDeviceType();
     const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-      return this.updateTouchBootloader({ device, features, firmwareType });
+      return this.updateTouchBootloader({
+        device,
+        features,
+        firmwareType,
+        binary,
+      });
     }
 
     return Promise.resolve(true);

package/src/api/device/DeviceWipe.ts

@@ -6,7 +6,7 @@ import type { WipeDevice } from '@onekeyfe/hd-transport';
 
 export default class DeviceWipe extends BaseMethod<WipeDevice> {
   init() {
-    this.unlockPolicy = 'retry-on-locked';
+    this.unlockPolicy = 'unlock-before-run';
     this.useDevicePassphraseState = false;
     this.protocolV2UiInteraction = {
       request: 'button',