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

package/src/core/index.ts

@@ -1,6 +1,6 @@
 import semver from 'semver';
 import EventEmitter from 'events';
-import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 import {
   ERRORS,
   ERROR_CODES_REQUIRE_RELEASE,
@@ -55,11 +55,12 @@ import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
 import { registerHardwareUiEventListeners } from './deviceEventRegistration';
 import { getSynchronize } from '../utils/getSynchronize';
-import { runMethodWithUnlockRetry } from '../protocols/protocol-v2/unlockRetry';
+import { runMethodWithUnlockPolicy } from '../protocols/protocol-v2/unlockPolicyRunner';
 import {
   ProtocolV2UiInteractionCoordinator,
   isProtocolV2UiEnabled,
 } from '../protocols/protocol-v2/uiInteraction';
+import { createUiProgressMessageFilter } from '../utils/uiProgressThrottle';
 
 import type { ConnectSettings, Features, KnownDevice } from '../types';
 import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
@@ -154,7 +155,12 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   try {
     method = findMethod(message as IFrameCallMessage);
     method.connector = _connector;
-    method.postMessage = postMessage;
+    const shouldPostMessage = createUiProgressMessageFilter();
+    method.postMessage = event => {
+      if (shouldPostMessage(event)) {
+        postMessage(event);
+      }
+    };
     method.setContext?.(context);
 
     method.requestContext = createRequestContext(method.responseID, method.name, {
@@ -406,6 +412,8 @@ const onCallDevice = async (
 
   registerHardwareUiEventListeners(device, {
     pin: onDevicePinHandler,
+    pinOnDevice: onEnterPinOnDeviceHandler,
+    pinOnDeviceComplete: onPinOnDeviceCompleteHandler,
     button: onDeviceButtonHandler,
     passphrase: message.payload.useEmptyPassphrase
       ? onEmptyPassphraseHandler
@@ -421,6 +429,7 @@ const onCallDevice = async (
   );
 
   const protocolV2UiCoordinator = new ProtocolV2UiInteractionCoordinator(device, postMessage);
+  device.beginProtocolV2UiInteraction();
   device.on(
     DEVICE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE,
     onSelectDeviceForSwitchFirmwareWebDeviceHandler
@@ -547,89 +556,92 @@ const onCallDevice = async (
         );
       }
 
-      if (method.deviceId && method.checkDeviceId) {
-        const isSameDeviceID = await checkLiveDeviceId(device, method.deviceId);
-        if (!isSameDeviceID) {
-          return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError));
-        }
-      }
+      try {
+        let deviceIdCheckedDuringUnlockPreflight = false;
+        const response = await runMethodWithUnlockPolicy<object>(method, device, {
+          uiCoordinator: protocolV2UiCoordinator,
+          afterStatusBeforeUnlock: () => {
+            if (method.deviceId && method.checkDeviceId) {
+              if (!device.checkDeviceId(method.deviceId)) {
+                throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+              }
+              deviceIdCheckedDuringUnlockPreflight = true;
+            }
+          },
+          prepare: async () => {
+            if (method.deviceId && method.checkDeviceId && !deviceIdCheckedDuringUnlockPreflight) {
+              const isSameDeviceID = await checkLiveDeviceId(device, method.deviceId);
+              if (!isSameDeviceID) {
+                throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+              }
+            }
 
-      /**
-       * check firmware release info
-       */
-      method.checkFirmwareRelease();
+            /**
+             * check firmware release info
+             */
+            method.checkFirmwareRelease();
 
-      /**
-       * check additional supported feature
-       */
-      method.checkDeviceSupportFeature();
+            /**
+             * check additional supported feature
+             */
+            method.checkDeviceSupportFeature();
 
-      // reconfigure messages
-      if (_deviceList && device.features && !device.isProtocolV2()) {
-        await TransportManager.reconfigure(device.features);
-      }
-
-      // Check to see if it is safe to use Passphrase
-      checkPassphraseEnableState(method, device.features);
+            // reconfigure messages
+            if (_deviceList && device.features && !device.isProtocolV2()) {
+              await TransportManager.reconfigure(device.features);
+            }
 
-      if (shouldCheckPassphraseState(method, device)) {
-        // check version
-        const support = device.supportNewPassphrase();
-        if (!support.support) {
-          return Promise.reject(
-            ERRORS.TypedError(
-              HardwareErrorCode.DeviceNotSupportPassphrase,
-              `Device not support passphrase, please update to ${support.require}`,
-              {
-                require: support.require,
+            // Check to see if it is safe to use Passphrase
+            checkPassphraseEnableState(method, device.features);
+
+            if (shouldCheckPassphraseState(method, device)) {
+              // check version
+              const support = device.supportNewPassphrase();
+              if (!support.support) {
+                throw ERRORS.TypedError(
+                  HardwareErrorCode.DeviceNotSupportPassphrase,
+                  `Device not support passphrase, please update to ${support.require}`,
+                  {
+                    require: support.require,
+                  }
+                );
               }
-            )
-          );
-        }
 
-        // Check Device passphrase State
-        const passphraseStateSafety = await device.checkPassphraseStateSafety(
-          method.payload?.passphraseState,
-          method.payload?.useEmptyPassphrase,
-          method.payload?.skipPassphraseCheck
-        );
-
-        // Double check, handles the special case of Touch/Pro
-        checkPassphraseEnableState(method, device.features);
+              // Check Device passphrase State after the Protocol V2 pre-unlock gate.
+              const passphraseStateSafety = await device.checkPassphraseStateSafety(
+                method.payload?.passphraseState,
+                method.payload?.useEmptyPassphrase,
+                method.payload?.skipPassphraseCheck,
+                hasDeriveCardano(method)
+              );
 
-        if (!passphraseStateSafety) {
-          DevicePool.clearDeviceCache(method.payload.connectId);
-          return Promise.reject(
-            ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError)
-          );
-        }
+              // Double check, handles the special case of Touch/Pro
+              checkPassphraseEnableState(method, device.features);
 
-        // close pin popup window
-        postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
-      }
+              if (!passphraseStateSafety) {
+                DevicePool.clearDeviceCache(method.payload.connectId);
+                throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+              }
 
-      // Automatic check safety_check level for Kovan, Ropsten, Rinkeby, Goerli test networks.
-      try {
-        await method.checkSafetyLevelOnTestNet();
-      } catch (e) {
-        const error =
-          e instanceof HardwareError
-            ? e
-            : ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'open safety check failed.');
-        // messageResponse = createResponseMessage(method.responseID, false, { error });
-        // requestQueue.resolveRequest(method.responseID, messageResponse);
-        // return;
-        throw error;
-      }
+              // Protocol V2 emits the PIN phase completion from DeviceSessionAskPin.
+              // Keep the legacy compatibility close for Protocol V1 only.
+              if (!device.isProtocolV2()) {
+                postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+              }
+            }
 
-      method.device?.commands?.checkDisposed();
+            // Automatic check safety_check level for Kovan, Ropsten, Rinkeby, Goerli test networks.
+            try {
+              await method.checkSafetyLevelOnTestNet();
+            } catch (e) {
+              throw e instanceof HardwareError
+                ? e
+                : ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'open safety check failed.');
+            }
 
-      try {
-        const response: object = await runMethodWithUnlockRetry(
-          method,
-          device,
-          protocolV2UiCoordinator
-        );
+            method.device?.commands?.checkDisposed();
+          },
+        });
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
@@ -1279,6 +1291,7 @@ const onDevicePassphraseHandler = async (
       source: requestPayload.source,
       reason: requestPayload.reason,
       expectedPassphraseState: requestPayload.expectedPassphraseState,
+      ...(requestPayload.interaction ? { interaction: requestPayload.interaction } : {}),
     })
   );
   // wait for passphrase
@@ -1308,6 +1321,7 @@ const onEnterPassphraseOnDeviceHandler = (
       passphraseState: device.passphraseState,
       source: requestPayload?.source,
       reason: requestPayload?.reason,
+      ...(requestPayload?.interaction ? { interaction: requestPayload.interaction } : {}),
     })
   );
 };
@@ -1321,10 +1335,39 @@ const onEnterAttachPinOnDeviceHandler = (
       type: 'ButtonRequest_AttachPin',
       source: requestPayload?.source,
       reason: requestPayload?.reason,
+      ...(requestPayload?.interaction ? { interaction: requestPayload.interaction } : {}),
     })
   );
 };
 
+const onEnterPinOnDeviceHandler = (
+  ...[device, pinType, metadata]: [...DeviceEvents['pin_on_device']]
+) => {
+  postMessage(
+    createUiMessage(UI_REQUEST.REQUEST_PIN, {
+      device: device.toMessageObject() as KnownDevice,
+      type:
+        pinType === DeviceSessionPinType.AttachToPin
+          ? 'ButtonRequest_AttachPin'
+          : 'ButtonRequest_PinEntry',
+      source: metadata?.source,
+      reason: metadata?.reason,
+      deviceOnly: metadata?.deviceOnly ?? true,
+      completion: metadata?.completion,
+      method: metadata?.method,
+      page: metadata?.page,
+      operation: metadata?.operation,
+      ...(metadata?.interaction ? { interaction: metadata.interaction } : {}),
+    })
+  );
+};
+
+const onPinOnDeviceCompleteHandler = (
+  ...[_, metadata]: [...DeviceEvents['pin_on_device_complete']]
+) => {
+  postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW, metadata));
+};
+
 const onSelectDeviceInBootloaderForWebDeviceHandler = async (
   ...[device, callback]: [...DeviceEvents['select_device_in_bootloader_for_web_device']]
 ) => {

package/src/data/messages/messages-protocol-v2.json

@@ -450,6 +450,8 @@
         "MessageType_DeviceInfo": 60601,
         "MessageType_DeviceStatusGet": 60602,
         "MessageType_DeviceStatus": 60603,
+        "MessageType_ResourceInventoryGet": 60604,
+        "MessageType_ResourceInventory": 60605,
         "MessageType_FilesystemPermissionFix": 60800,
         "MessageType_FilesystemPathInfo": 60801,
         "MessageType_FilesystemPathInfoQuery": 60802,
@@ -470,6 +472,7 @@
         "MessageType_DeviceSessionAskPin": 61202,
         "MessageType_DeviceSessionAskPassphrase": 61203,
         "MessageType_PortfolioUpdate": 61400,
+        "MessageType_NftUpdate": 61500,
         "MessageType_OnboardingStatusGet": 61600,
         "MessageType_OnboardingStatus": 61601
       },
@@ -11993,6 +11996,16 @@
         "APP": 85
       }
     },
+    "ResourceBundleType": {
+      "values": {
+        "IMAGES": 0,
+        "ANIMATION": 1,
+        "WALLPAPER": 2,
+        "TRANSLATIONS": 3,
+        "ROOBERT": 4,
+        "NOTO": 5
+      }
+    },
     "DeviceFirmwareImageInfo": {
       "fields": {
         "version": {
@@ -12190,6 +12203,37 @@
         }
       }
     },
+    "ResourceInventoryGet": {
+      "fields": {}
+    },
+    "ResourceInventoryItem": {
+      "fields": {
+        "type": {
+          "rule": "required",
+          "type": "ResourceBundleType",
+          "id": 1
+        },
+        "size": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        },
+        "header_hash": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 3
+        }
+      }
+    },
+    "ResourceInventory": {
+      "fields": {
+        "items": {
+          "rule": "repeated",
+          "type": "ResourceInventoryItem",
+          "id": 1
+        }
+      }
+    },
     "DeviceSessionErrorCode": {
       "values": {
         "DeviceSessionError_None": 0,
@@ -12538,6 +12582,15 @@
         }
       }
     },
+    "NftUpdate": {
+      "fields": {
+        "file_name_no_ext": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
     "OnboardingStep": {
       "values": {
         "ONBOARDING_STEP_UNKNOWN": 0,

package/src/data-manager/DataManager.ts

@@ -17,6 +17,7 @@ import {
 } from '../utils';
 import { DeviceModelToTypes } from '../types';
 import { findLatestRelease, getReleaseChangelog, getReleaseStatus } from '../utils/release';
+import { parseProtocolV2Resources } from '../protocols/protocol-v2/resources';
 
 import type {
   AssetsMap,
@@ -397,20 +398,10 @@ export default class DataManager {
     return enrichedData;
   }
 
-  static async load(settings: ConnectSettings) {
+  static async load(settings: ConnectSettings): Promise<boolean> {
     this.settings = settings;
-    const manifestMode =
-      settings.firmwareManifestMode ?? (settings.fetchConfig ? 'sdk-managed' : undefined);
-    if (settings.preloadedConfig) {
-      this.applyRemoteConfig(settings.preloadedConfig);
-      Log.log('[DataConfig] Preloaded firmware config loaded');
-      return;
-    }
-    if (manifestMode === 'external-only') {
-      throw new Error('External firmware config snapshot is required');
-    }
-    if (manifestMode !== 'sdk-managed') {
-      return;
+    if (!settings.fetchConfig) {
+      return false;
     }
 
     const url = settings.preRelease
@@ -419,48 +410,65 @@ export default class DataManager {
 
     const urlWithCache = `${url}?noCache=${getTimeStamp()}`;
     let data: RemoteConfigResponse | null = null;
+    let fetchMethod: 'configFetcher' | 'axios' | 'none' = 'none';
+
+    // 1. Try custom configFetcher first (client-side IP direct connection support)
     if (settings.configFetcher) {
-      Log.debug('[DataConfig] Trying client configFetcher...');
+      Log.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
       try {
         data = await settings.configFetcher(urlWithCache);
+        if (data) {
+          fetchMethod = 'configFetcher';
+          Log.log('[DataConfig] ConfigFetcher success');
+        } else {
+          Log.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
+        }
       } catch (e) {
-        Log.warn('[DataConfig] Client configFetcher failed:', e);
+        Log.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
       }
     }
+
+    // 2. Fallback to default axios request
     if (!data) {
-      Log.debug('[DataConfig] Trying SDK-managed config request...');
+      Log.debug('[DataConfig] Trying axios (SDK default fetcher)...');
       try {
         const response = await axios.get<RemoteConfigResponse>(urlWithCache, {
           // because of iframe timeout is 10000
           timeout: 7000,
         });
         data = response.data;
-        Log.log('[DataConfig] SDK-managed config request succeeded');
+        fetchMethod = 'axios';
+        Log.log('[DataConfig] Axios fetch success');
       } catch (e) {
-        Log.warn('[DataConfig] SDK-managed config request failed:', e);
+        Log.warn('[DataConfig] Axios fetch error:', e);
       }
     }
 
+    // 3. Apply config if available
     if (data) {
-      this.applyRemoteConfig(data);
-    } else {
-      Log.warn('[DataConfig] SDK-managed config request failed, using built-in default config');
+      const pro2Resources = parseProtocolV2Resources(
+        (data.pro2 as { resources?: unknown } | undefined)?.resources
+      );
+      Log.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
+      this.deviceMap = {
+        [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
+        [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
+        [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
+        [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
+        [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
+        [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
+        [EDeviceType.Pro2]: {
+          ...this.enrichFirmwareReleaseInfo(data.pro2),
+          ...(pro2Resources ? { resources: pro2Resources } : undefined),
+        },
+      };
+      this.assets = {
+        bridge: data.bridge,
+      };
+      return true;
     }
-  }
-
-  private static applyRemoteConfig(data: RemoteConfigResponse) {
-    this.deviceMap = {
-      [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
-      [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
-      [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
-      [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
-      [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
-      [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
-      [EDeviceType.Pro2]: this.enrichFirmwareReleaseInfo(data.pro2),
-    };
-    this.assets = {
-      bridge: data.bridge,
-    };
+    Log.warn('[DataConfig] All fetch methods failed, using built-in default config');
+    return false;
   }
 
   static updateEnv(newEnv: ConnectSettings['env']) {
@@ -478,10 +486,27 @@ export default class DataManager {
 
   static async checkAndReloadData() {
     if (getTimeStamp() - this.lastCheckTimestamp > 1000 * 60 * 60 * 3) {
-      await this.load(this.settings).then(() => {
+      const loaded = await this.load(this.settings);
+      if (loaded) {
         this.lastCheckTimestamp = getTimeStamp();
-      });
+      }
+    }
+  }
+
+  /** Force a fresh remote config before an update is allowed to mutate the device. */
+  static async forceReloadData(): Promise<void> {
+    if (!this.settings) {
+      throw new Error('Remote config settings are not initialized');
+    }
+    const loaded = await this.load(this.settings);
+    if (!loaded) {
+      throw new Error('Unable to refresh the latest remote config');
     }
+    this.lastCheckTimestamp = getTimeStamp();
+  }
+
+  static getProtocolV2Resources() {
+    return this.deviceMap[EDeviceType.Pro2]?.resources?.stable;
   }
 
   static getProtobufMessages(schema: ProtobufMessageSchema = 'v1CurrentSchema'): JSON {

package/src/data-manager/connectSettings.ts

@@ -115,21 +115,10 @@ export const parseConnectSettings = (input: Partial<ConnectSettings> = {}) => {
     settings.fetchConfig = input.fetchConfig;
   }
 
-  if (
-    input.firmwareManifestMode === 'sdk-managed' ||
-    input.firmwareManifestMode === 'external-only'
-  ) {
-    settings.firmwareManifestMode = input.firmwareManifestMode;
-  }
-
   if (input.configFetcher) {
     settings.configFetcher = input.configFetcher;
   }
 
-  if (input.preloadedConfig) {
-    settings.preloadedConfig = input.preloadedConfig;
-  }
-
   return settings;
 };