@onekeyfe/hd-core 1.2.0-alpha.41 → 1.2.0-alpha.43

package/src/api/GetPassphraseState.ts

@@ -1,4 +1,5 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { refreshProtocolV2DeviceStatus } from '../protocols/protocol-v2/walletSession';
@@ -24,7 +25,12 @@ export default class GetPassphraseState extends BaseMethod {
     if (isProtocolV2 && this.payload.useEmptyPassphrase !== true) {
       const features = await refreshProtocolV2DeviceStatus(this.device);
       if (features.unlocked === false) {
-        await this.device.unlockDevice();
+        await this.device.unlockDevice(DeviceSessionPinType.Main, {
+          source: 'unlock-coordinator',
+          reason: 'device-locked',
+          deviceOnly: true,
+          method: 'getPassphraseState',
+        });
       }
     }
     const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(

package/src/api/OpenWalletSession.ts

@@ -1,4 +1,5 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
 import { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSession';
@@ -90,23 +91,40 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
   async run(): Promise<OpenWalletSessionPayload> {
     const isProtocolV2 = this.device.isProtocolV2();
-    const state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    let state = await this.device.getDeviceState({ refreshSections: ['status'] });
     let currentDeviceId = state.identity.deviceId;
+    const hasAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) =>
+      candidate.status.unlocked === true &&
+      typeof candidate.status.passphraseProtection === 'boolean' &&
+      typeof candidate.status.unlockedAttachPin === 'boolean';
+    const requireAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) => {
+      if (!hasAuthoritativeProtocolV2WalletStatus(candidate)) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+      }
+      return candidate;
+    };
     const requireDeviceId = () => {
       if (!currentDeviceId) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
       }
       return currentDeviceId;
     };
-    const refreshProtocolV2DeviceId = async () => {
-      const refreshedState = await this.device.getDeviceState({ refreshSections: ['status'] });
-      currentDeviceId = refreshedState.identity.deviceId;
-      return requireDeviceId();
+    const refreshProtocolV2DeviceState = async () => {
+      state = await this.device.getDeviceState({ refreshSections: ['status'] });
+      currentDeviceId = state.identity.deviceId;
+      return state;
     };
-    const unlockProtocolV2IfLocked = async () => {
-      if (isProtocolV2 && state.status.unlocked === false) {
-        await this.device.unlockDevice();
+    const ensureProtocolV2WalletStatus = async () => {
+      if (isProtocolV2 && !hasAuthoritativeProtocolV2WalletStatus(state)) {
+        await this.device.unlockDevice(DeviceSessionPinType.Main, {
+          source: 'unlock-coordinator',
+          reason: 'device-locked',
+          deviceOnly: true,
+          method: 'openWalletSession',
+        });
+        requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState());
       }
+      return state;
     };
 
     const protocol = isProtocolV2 ? 'V2' : 'V1';
@@ -114,13 +132,25 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     if (this.params.mode === OpenWalletSessionMode.Standard) {
       this.device.passphraseState = undefined;
       const session = isProtocolV2
-        ? await getProtocolV2WalletSession(this.device, { onlyMainPin: true })
+        ? await getProtocolV2WalletSession(this.device, {
+            onlyMainPin: true,
+            deriveCardano: this.payload.deriveCardano,
+            selectMainWalletBeforeRestore:
+              !hasAuthoritativeProtocolV2WalletStatus(state) ||
+              state.status.unlockedAttachPin === true,
+          })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             onlyMainPin: true,
             initSession: this.payload.initSession,
           });
-      const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
-      if (session.unlockedAttachPin) {
+      const refreshedState = isProtocolV2
+        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+        : state;
+      const deviceId = requireDeviceId();
+      if (
+        session.unlockedAttachPin ||
+        (isProtocolV2 && refreshedState.status.unlockedAttachPin === true)
+      ) {
         try {
           await this.device.lockDevice();
         } catch {
@@ -140,8 +170,8 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
     if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
       if (isProtocolV2) {
-        await unlockProtocolV2IfLocked();
-        const refreshedDeviceId = await refreshProtocolV2DeviceId();
+        await ensureProtocolV2WalletStatus();
+        const refreshedDeviceId = requireDeviceId();
         if (refreshedDeviceId !== this.params.deviceId) {
           deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
           throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
@@ -166,6 +196,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, {
             expectedPassphraseState: this.params.passphraseState,
+            deriveCardano: this.payload.deriveCardano,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             expectPassphraseState: this.params.passphraseState,
@@ -185,12 +216,18 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     }
 
     this.device.passphraseState = undefined;
-    await unlockProtocolV2IfLocked();
+    await ensureProtocolV2WalletStatus();
     const session = isProtocolV2
-      ? await getProtocolV2WalletSession(this.device, { forceWalletSelection: true })
+      ? await getProtocolV2WalletSession(this.device, {
+          forceWalletSelection: true,
+          deriveCardano: this.payload.deriveCardano,
+        })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
-    const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
-    if (isProtocolV2 && this.device.getCurrentPassphraseProtection() !== true) {
+    const refreshedState = isProtocolV2
+      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+      : state;
+    const deviceId = requireDeviceId();
+    if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {
       this.device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
     }

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -14,6 +14,7 @@ import { findMethod } from '../utils';
 import { DEVICE, IFRAME, createUiMessage } from '../../events';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { onDeviceButtonHandler } from '../../core';
+import { runMethodWithUnlockPolicy } from '../../protocols/protocol-v2/unlockPolicyRunner';
 import {
   completeRequestContext,
   createRequestContext,
@@ -375,16 +376,34 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       this.device.on(DEVICE.PASSPHRASE, onSignalAbort);
 
       preCheckDeviceSupport(this.device, method);
-      if (this.temporarySafetyCheckPrompted) {
-        method.temporarySafetyCheckPrompted = true;
-      } else {
-        const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
-        if (appliedTemporarySafetyCheck) {
-          this.temporarySafetyCheckPrompted = true;
-        }
-      }
-
-      const response = await method.run();
+      const response = await runMethodWithUnlockPolicy<any[]>(method, this.device, {
+        context: this.protocolV2UnlockContext,
+        prepare: async () => {
+          if (this.temporarySafetyCheckPrompted) {
+            method.temporarySafetyCheckPrompted = true;
+          } else {
+            const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
+            if (appliedTemporarySafetyCheck) {
+              this.temporarySafetyCheckPrompted = true;
+            }
+          }
+
+          // Protocol V2 hands a wallet session to exactly one blockchain request.
+          // The parent all-network call consumes its first handoff while fetching
+          // the root fingerprint, so each nested chain method must resume the
+          // requested hidden wallet before it sends its own device command.
+          if (this.device.isProtocolV2() && this.payload.passphraseState) {
+            const passphraseStateSafety = await this.device.checkPassphraseStateSafety(
+              this.payload.passphraseState,
+              false,
+              this.payload.skipPassphraseCheck
+            );
+            if (!passphraseStateSafety) {
+              throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+            }
+          }
+        },
+      });
 
       if (!Array.isArray(response) || response.length === 0) {
         throw new Error('No response');
@@ -439,7 +458,9 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       show_display: false,
     });
 
-    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+    if (!this.device.isProtocolV2()) {
+      this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+    }
 
     if (res.message.root_fingerprint == null) {
       throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);

package/src/api/device/DeviceUnlock.ts

@@ -21,6 +21,6 @@ export default class DeviceUnlock extends BaseMethod<LockDevice> {
   }
 
   async run() {
-    return this.device.unlockDevice();
+    return this.device.unlockDevice(undefined, { emitUiEvent: false });
   }
 }

package/src/api/device/DeviceUpdateBootloader.ts

@@ -5,23 +5,15 @@ 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, updateBootloaderFromSource } from '../firmware/uploadFirmware';
+import { updateBootloader } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
-import { checkBootloaderLength, checkBootloaderSourceLength } from '../firmware/updateBootloader';
-import { openFirmwareByteSource } from '../firmware/FirmwareArtifactSource';
-import { resolveFirmwareUpdateHostBinding } from '../firmware/FirmwareHostBinding';
-import {
-  assertFirmwareUpdatePreparedPlanBinding,
-  assertFirmwareUpdatePreparedPlanDeviceIdentity,
-} from '../firmware/FirmwareUpdatePreparedPlan';
-import { getDeviceUUID } from '../../utils';
+import { checkBootloaderLength } from '../firmware/updateBootloader';
 
 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() {
@@ -51,68 +43,17 @@ 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;
   }) {
-    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;
+    let { binary } = this.payload;
     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)
@@ -127,7 +68,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
       }
     }
 
-    if (!binary || !checkBootloaderLength(binary)) {
+    if (!checkBootloaderLength(binary)) {
       throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
     }
 
@@ -135,8 +76,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     if (features && device.isBootloader()) {
       // Use emmcFileWrite + reboot logic for bootloader mode
       this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-      const result = await this.updateBootloaderWithEmmcFileWrite(device, binary);
-      return result;
+      return this.updateBootloaderWithEmmcFileWrite(device, binary);
     }
 
     if (features && !device.isBootloader()) {
@@ -156,69 +96,13 @@ 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) {
-      assertFirmwareUpdatePreparedPlanDeviceIdentity({
-        preparedPlan: payload.preparedPlan,
-        deviceIdentity: getDeviceUUID(features) || undefined,
-      });
-      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,
-        binary,
-      });
+      return this.updateTouchBootloader({ device, features, firmwareType });
     }
 
     return Promise.resolve(true);

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -13,8 +13,6 @@ import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
-import { createFirmwareProgressThrottle } from './progressThrottle';
-import { writeFirmwareByteSource } from './FirmwareArtifactSource';
 
 import type {
   IFirmwareUpdateProgressType,
@@ -25,7 +23,6 @@ import type { RebootType } from '@onekeyfe/hd-transport';
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { KnownDevice } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
@@ -43,8 +40,6 @@ const isDeviceDisconnectedError = (error: unknown) => {
 export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   checkPromise: Deferred<any> | null = null;
 
-  private shouldPostFirmwareProgress = createFirmwareProgressThrottle();
-
   init(): void {}
 
   run(): Promise<any> {
@@ -88,10 +83,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
    * @param progress Post the percentage of the progress
    */
   postProgressMessage = (progress: number, progressType: IFirmwareUpdateProgressType) => {
-    if (!this.shouldPostFirmwareProgress(progress, progressType)) {
-      return;
-    }
-
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
         device: this.device.toMessageObject() as KnownDevice,
@@ -389,54 +380,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
   }
 
-  async emmcCommonUpdateProcessFromSource({
-    source,
-    filePath,
-    processedSize,
-    totalSize,
-  }: {
-    source: FirmwareByteSource;
-    filePath: string;
-    processedSize?: number;
-    totalSize?: number;
-  }) {
-    if (!filePath.startsWith('0:')) {
-      throw new Error('filePath must start with 0:');
-    }
-    const env = DataManager.getSettings('env');
-    const chunkSize = 1024 * (DataManager.isBleConnect(env) ? 16 : 128);
-
-    await writeFirmwareByteSource({
-      source,
-      chunkSize,
-      write: async ({ data, sourceOffset, length, first }) => {
-        const progress =
-          totalSize !== undefined && processedSize !== undefined
-            ? Math.min(Math.ceil(((processedSize + sourceOffset + length) / totalSize) * 100), 99)
-            : Math.min(Math.ceil(((sourceOffset + length) / source.size) * 100), 99);
-        const writeRes = await this.emmcFileWriteWithRetry(
-          filePath,
-          length,
-          sourceOffset,
-          data,
-          first,
-          progress
-        );
-        if (!writeRes) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.EmmcFileWriteFirmwareError,
-            'transfer data error'
-          );
-        }
-        const processedBytes = Number(writeRes.message.processed_byte);
-        this.postProgressMessage(progress, 'transferData');
-        return Number.isFinite(processedBytes) ? processedBytes : length;
-      },
-    });
-
-    return totalSize !== undefined ? (processedSize ?? 0) + source.size : 0;
-  }
-
   async emmcFileWriteWithRetry(
     filePath: string,
     chunkLength: number,

package/src/api/firmware/updateBootloader.ts

@@ -8,7 +8,6 @@ import { shouldUpdateBootloaderForClassicAndMini } from './bootloaderHelper';
 
 import type { Features } from '../../types';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 export function checkNeedUpdateBootForTouch(features: Features, firmwareType: EFirmwareType) {
   const deviceType = getDeviceType(features);
@@ -63,7 +62,8 @@ export function checkNeedUpdateBootForClassicAndMini({
 }
 
 const INIT_DATA_CHUNK_SIZE = 16 * 1024;
-const readBootloaderLength = (chunk: Uint8Array) => {
+export function checkBootloaderLength(data: ArrayBuffer) {
+  const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE, data.byteLength)));
   const buffer = ByteBuffer.wrap(chunk, undefined, undefined, true);
   buffer.LE();
   // byte 'O', 'K', 'T', 'B'
@@ -77,21 +77,6 @@ const readBootloaderLength = (chunk: Uint8Array) => {
   buffer.readUint32();
   // codelen
   const codelen = buffer.readUint32();
-  return hdrlen + codelen;
-};
-
-export function checkBootloaderLength(data: ArrayBuffer) {
-  if (data.byteLength < 16) {
-    return false;
-  }
-  const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE, data.byteLength)));
-  return readBootloaderLength(chunk) === data.byteLength;
+  const bootloaderLength = hdrlen + codelen;
+  return bootloaderLength === data.byteLength;
 }
-
-export const checkBootloaderSourceLength = async (source: FirmwareByteSource) => {
-  if (source.size < 16) {
-    return false;
-  }
-  const chunk = new Uint8Array(await source.readAt(0, Math.min(INIT_DATA_CHUNK_SIZE, source.size)));
-  return readBootloaderLength(chunk) === source.size;
-};