@onekeyfe/hd-core 1.2.0-alpha.36 → 1.2.0-alpha.39

package/src/core/index.ts

@@ -55,12 +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 { ensureProtocolV2WalletSessionUnlocked } from '../protocols/protocol-v2/walletSession';
+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';
@@ -155,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, {
@@ -551,96 +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));
-        }
-      }
-
-      /**
-       * check firmware release info
-       */
-      method.checkFirmwareRelease();
+      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 additional supported feature
-       */
-      method.checkDeviceSupportFeature();
+            /**
+             * check firmware release info
+             */
+            method.checkFirmwareRelease();
 
-      // reconfigure messages
-      if (_deviceList && device.features && !device.isProtocolV2()) {
-        await TransportManager.reconfigure(device.features);
-      }
+            /**
+             * check additional supported feature
+             */
+            method.checkDeviceSupportFeature();
 
-      // 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,
+                  }
+                );
               }
-            )
-          );
-        }
 
-        // Wallet-session recovery is part of the protected business call, not onboarding.
-        await ensureProtocolV2WalletSessionUnlocked(device);
+              // 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)
+              );
 
-        // Check Device passphrase State
-        const passphraseStateSafety = await device.checkPassphraseStateSafety(
-          method.payload?.passphraseState,
-          method.payload?.useEmptyPassphrase,
-          method.payload?.skipPassphraseCheck,
-          hasDeriveCardano(method)
-        );
+              // Double check, handles the special case of Touch/Pro
+              checkPassphraseEnableState(method, device.features);
 
-        // Double check, handles the special case of Touch/Pro
-        checkPassphraseEnableState(method, device.features);
-
-        if (!passphraseStateSafety) {
-          DevicePool.clearDeviceCache(method.payload.connectId);
-          return Promise.reject(
-            ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError)
-          );
-        }
-
-        // 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));
-        }
-      }
+              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);

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

@@ -470,6 +470,7 @@
         "MessageType_DeviceSessionAskPin": 61202,
         "MessageType_DeviceSessionAskPassphrase": 61203,
         "MessageType_PortfolioUpdate": 61400,
+        "MessageType_NftUpdate": 61500,
         "MessageType_OnboardingStatusGet": 61600,
         "MessageType_OnboardingStatus": 61601
       },
@@ -12200,26 +12201,11 @@
         "DeviceSessionError_Busy": 5
       }
     },
-    "DeviceSessionSeedDomain": {
-      "values": {
-        "SeedDomain_Standard": 1,
-        "SeedDomain_Cardano": 2
-      }
-    },
     "DeviceSessionGet": {
       "fields": {
         "session_id": {
           "type": "bytes",
           "id": 1
-        },
-        "btc_test_address": {
-          "type": "string",
-          "id": 2
-        },
-        "seed_domains": {
-          "rule": "repeated",
-          "type": "DeviceSessionSeedDomain",
-          "id": 3
         }
       }
     },
@@ -12553,6 +12539,15 @@
         }
       }
     },
+    "NftUpdate": {
+      "fields": {
+        "file_name_no_ext": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
     "OnboardingStep": {
       "values": {
         "ONBOARDING_STEP_UNKNOWN": 0,

package/src/events/logBlockEvent.ts

@@ -10,6 +10,7 @@ export const LogBlockEvent: Set<string> = new Set([
 
 const LogLabelMethod: Set<string> = new Set([
   'openWalletSession',
+  'deviceUploadNft',
   'deviceUploadWallpaper',
   'uploadPortfolio',
   'fileWrite',

package/src/inject.ts

@@ -162,6 +162,7 @@ export const createCoreApi = (
     call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
   deviceUploadWallpaper: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceUploadWallpaper' }),
+  deviceUploadNft: (connectId, params) => call({ ...params, connectId, method: 'deviceUploadNft' }),
   uploadPortfolio: (connectId, params) => call({ ...params, connectId, method: 'uploadPortfolio' }),
   deviceRecovery: (connectId, params) => call({ ...params, connectId, method: 'deviceRecovery' }),
   deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),

package/src/protocols/protocol-v2/unlockPolicy.ts

@@ -1,105 +1 @@
-export type UnlockPolicy = 'none' | 'unlock-before-run' | 'retry-on-locked';
-
-/**
- * Protocol V2 methods that are safe to replay after a locked response.
- *
- * Keep this as an exact allowlist. Name-pattern matching can silently make a new
- * state-changing method replayable when it happens to share a suffix.
- */
-export const PROTOCOL_V2_RETRY_ON_LOCKED_METHODS = [
-  'cipherKeyValue',
-  'allNetworkGetAddress',
-  'allNetworkGetAddressByLoop',
-  'btcGetAddress',
-  'btcGetPublicKey',
-  'btcSignMessage',
-  'btcSignPsbt',
-  'btcSignTransaction',
-  'btcVerifyMessage',
-  'confluxGetAddress',
-  'confluxSignMessage',
-  'confluxSignTransaction',
-  'evmGetAddress',
-  'evmGetPublicKey',
-  'evmSignMessage',
-  'evmSignTransaction',
-  'evmSignTypedData',
-  'evmVerifyMessage',
-  'starcoinGetAddress',
-  'starcoinGetPublicKey',
-  'starcoinSignMessage',
-  'starcoinSignTransaction',
-  'starcoinVerifyMessage',
-  'nemGetAddress',
-  'nemSignTransaction',
-  'solGetAddress',
-  'solSignTransaction',
-  'solSignOffchainMessage',
-  'solSignMessage',
-  'stellarGetAddress',
-  'stellarSignTransaction',
-  'tronGetAddress',
-  'tronSignMessage',
-  'tronSignTransaction',
-  'nearGetAddress',
-  'nearSignTransaction',
-  'aptosGetAddress',
-  'aptosGetPublicKey',
-  'aptosSignTransaction',
-  'aptosSignMessage',
-  'aptosSignInMessage',
-  'algoGetAddress',
-  'algoSignTransaction',
-  'cosmosGetAddress',
-  'cosmosGetPublicKey',
-  'cosmosSignTransaction',
-  'xrpGetAddress',
-  'xrpSignTransaction',
-  'suiGetAddress',
-  'suiGetPublicKey',
-  'suiSignMessage',
-  'suiSignTransaction',
-  'cardanoGetAddress',
-  'cardanoGetPublicKey',
-  'cardanoSignTransaction',
-  'cardanoSignMessage',
-  'filecoinGetAddress',
-  'filecoinSignTransaction',
-  'polkadotGetAddress',
-  'polkadotSignTransaction',
-  'kaspaGetAddress',
-  'kaspaSignTransaction',
-  'nexaGetAddress',
-  'nexaSignTransaction',
-  'nostrGetPublicKey',
-  'nostrSignEvent',
-  'nostrEncryptMessage',
-  'nostrDecryptMessage',
-  'nostrSignSchnorr',
-  'lnurlAuth',
-  'nervosGetAddress',
-  'nervosSignTransaction',
-  'dnxGetAddress',
-  'dnxSignTransaction',
-  'tonGetAddress',
-  'tonSignMessage',
-  'tonSignProof',
-  'tonSignData',
-  'scdoGetAddress',
-  'scdoSignTransaction',
-  'scdoSignMessage',
-  'alephiumGetAddress',
-  'alephiumSignTransaction',
-  'alephiumSignMessage',
-  'benfenGetAddress',
-  'benfenGetPublicKey',
-  'benfenSignMessage',
-  'benfenSignTransaction',
-  'neoGetAddress',
-  'neoSignTransaction',
-] as const;
-
-const retryOnLockedMethods = new Set<string>(PROTOCOL_V2_RETRY_ON_LOCKED_METHODS);
-
-export const getProtocolV2UnlockPolicy = (methodName: string): UnlockPolicy =>
-  retryOnLockedMethods.has(methodName) ? 'retry-on-locked' : 'none';
+export type UnlockPolicy = 'none' | 'unlock-before-run';

package/src/protocols/protocol-v2/unlockPolicyRunner.ts

@@ -0,0 +1,117 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { LoggerNames, getLogger } from '../../utils';
+import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
+import { refreshProtocolV2DeviceStatus } from './walletSession';
+
+import type { BaseMethod } from '../../api/BaseMethod';
+import type { Device } from '../../device/Device';
+import type { HardwareUiInteractionMeta } from '../../events';
+import type { ProtocolV2UiInteractionCoordinator } from './uiInteraction';
+
+const Log = getLogger(LoggerNames.Core);
+
+export type ProtocolV2UnlockContext = {
+  preflightCompleted: boolean;
+};
+
+export const createProtocolV2UnlockContext = (): ProtocolV2UnlockContext => ({
+  preflightCompleted: false,
+});
+
+type RunnableMethod = Pick<
+  BaseMethod,
+  | 'run'
+  | 'unlockPolicy'
+  | 'useDevicePassphraseState'
+  | 'protocolV2UiInteraction'
+  | 'protocolV2UiMode'
+  | 'params'
+  | 'payload'
+> & {
+  name?: string;
+  protocolV2UnlockContext?: ProtocolV2UnlockContext;
+};
+
+type UiInteractionCoordinator = Pick<
+  ProtocolV2UiInteractionCoordinator,
+  'enterMethodInteraction' | 'enterUnlockInteraction'
+>;
+
+type RunMethodWithUnlockPolicyOptions<T> = {
+  context?: ProtocolV2UnlockContext;
+  uiCoordinator?: UiInteractionCoordinator;
+  afterStatusBeforeUnlock?: () => void | Promise<void>;
+  prepare?: () => Promise<void>;
+  run?: () => Promise<T>;
+};
+
+export async function runMethodWithUnlockPolicy<T = unknown>(
+  method: RunnableMethod,
+  device: Device,
+  options: RunMethodWithUnlockPolicyOptions<T> = {}
+): Promise<T> {
+  const {
+    context = createProtocolV2UnlockContext(),
+    uiCoordinator,
+    afterStatusBeforeUnlock,
+    prepare,
+    run: configuredRun,
+  } = options;
+  const run = configuredRun ?? (() => method.run() as Promise<T>);
+  method.protocolV2UnlockContext = context;
+
+  const shouldEmitUi = isProtocolV2UiEnabled(method);
+  const shouldCoordinateUi = shouldEmitUi && uiCoordinator !== undefined;
+  const requiresPreUnlock =
+    device.isProtocolV2() &&
+    (method.useDevicePassphraseState || method.unlockPolicy === 'unlock-before-run') &&
+    !device.isBootloader?.() &&
+    !device.isRomloader?.();
+
+  if (requiresPreUnlock && !context.preflightCompleted) {
+    const status = await refreshProtocolV2DeviceStatus(device);
+    if (typeof status?.unlocked !== 'boolean') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 DeviceStatus did not report an explicit unlock state.'
+      );
+    }
+
+    await afterStatusBeforeUnlock?.();
+
+    if (!status.unlocked) {
+      const unlockInteraction: HardwareUiInteractionMeta | undefined = shouldCoordinateUi
+        ? uiCoordinator.enterUnlockInteraction(method.name)
+        : undefined;
+      const unlockedStatus = await device.unlockDevice(
+        undefined,
+        shouldCoordinateUi
+          ? { emitUiEvent: false, interaction: unlockInteraction }
+          : {
+              source: 'unlock-coordinator',
+              reason: 'device-locked',
+              deviceOnly: true,
+              method: method.name,
+            }
+      );
+      if (unlockedStatus?.unlocked !== true) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Protocol V2 device remained locked after the unlock flow.'
+        );
+      }
+      Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
+    }
+
+    context.preflightCompleted = true;
+  }
+
+  await prepare?.();
+
+  if (shouldCoordinateUi) {
+    uiCoordinator.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
+  }
+
+  return run();
+}

package/src/protocols/protocol-v2/walletSession.ts

@@ -1,5 +1,5 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType, DeviceSessionSeedDomain } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { DEVICE } from '../../events';
 import { assertCompleteDeviceSession } from './deviceSession';
@@ -60,34 +60,15 @@ const negotiateEventlessWalletSession = async (device: Device) => {
   await device.ensureProtocolV2RuntimeContext();
 };
 
-const getDeviceSession = async (
-  device: Device,
-  request: DeviceSessionGet,
-  deriveCardano?: boolean
-) => {
-  const payload =
-    deriveCardano === undefined
-      ? request
-      : {
-          ...request,
-          seed_domains: [
-            DeviceSessionSeedDomain.SeedDomain_Standard,
-            ...(deriveCardano ? [DeviceSessionSeedDomain.SeedDomain_Cardano] : []),
-          ],
-        };
-  return device.commands.typedCall('DeviceSessionGet', 'DeviceSession', payload);
-};
+const getDeviceSession = async (device: Device, request: DeviceSessionGet) =>
+  device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
 
 const askDevicePassphrase = async (device: Device, requestPayload: DeviceSessionAskPassphrase) => {
   await device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', requestPayload);
   await refreshProtocolV2DeviceStatus(device);
 };
 
-const selectDeviceSession = async (
-  device: Device,
-  expectedPassphraseState?: string,
-  deriveCardano?: boolean
-) => {
+const selectDeviceSession = async (device: Device, expectedPassphraseState?: string) => {
   const existsAttachPinUser = device.features?.attachToPinEnabled === true;
   const metadata = {
     source: 'wallet-session-coordinator' as const,
@@ -148,7 +129,7 @@ const selectDeviceSession = async (
       emitUiEvent: false,
       interaction: attachPinInteraction,
     });
-    return getDeviceSession(device, {}, deriveCardano);
+    return getDeviceSession(device, {});
   }
 
   if (hasHostPassphrase) {
@@ -156,7 +137,7 @@ const selectDeviceSession = async (
       passphrase: hostPassphrase,
       on_device: false,
     });
-    return getDeviceSession(device, {}, deriveCardano);
+    return getDeviceSession(device, {});
   }
 
   device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, {
@@ -164,7 +145,7 @@ const selectDeviceSession = async (
     ...(passphraseInteraction ? { interaction: passphraseInteraction } : {}),
   });
   await askDevicePassphrase(device, { on_device: true });
-  return getDeviceSession(device, {}, deriveCardano);
+  return getDeviceSession(device, {});
 };
 
 export async function getProtocolV2WalletSession(
@@ -253,14 +234,9 @@ export async function getProtocolV2WalletSession(
         if (options?.selectMainWalletBeforeRestore) {
           await selectMainWallet();
         }
-        response = await getDeviceSession(
-          device,
-          {
-            session_id: cachedStandardSession.sessionId,
-            btc_test_address: cachedStandardSession.passphraseState,
-          },
-          options?.deriveCardano
-        );
+        response = await getDeviceSession(device, {
+          session_id: cachedStandardSession.sessionId,
+        });
         resumed = true;
       } catch (error) {
         device.clearStandardInternalState?.();
@@ -273,18 +249,13 @@ export async function getProtocolV2WalletSession(
 
     if (!response) {
       await selectMainWallet();
-      response = await getDeviceSession(device, {}, options?.deriveCardano);
+      response = await getDeviceSession(device, {});
     }
   } else if (cachedSessionId && expectedPassphraseState) {
     try {
-      response = await getDeviceSession(
-        device,
-        {
-          session_id: cachedSessionId,
-          btc_test_address: expectedPassphraseState,
-        },
-        options?.deriveCardano
-      );
+      response = await getDeviceSession(device, {
+        session_id: cachedSessionId,
+      });
       resumed = true;
     } catch (error) {
       device.clearInternalState();
@@ -295,11 +266,7 @@ export async function getProtocolV2WalletSession(
     }
   } else if (expectedPassphraseState) {
     try {
-      response = await getDeviceSession(
-        device,
-        { btc_test_address: expectedPassphraseState },
-        options?.deriveCardano
-      );
+      response = await getDeviceSession(device, {});
     } catch (error) {
       if (options?.resumeOnly || !isWalletSessionInvalidError(error)) {
         throw error;
@@ -312,7 +279,7 @@ export async function getProtocolV2WalletSession(
       device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
     }
-    response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
+    response = await selectDeviceSession(device, expectedPassphraseState);
   }
 
   let { message } = response;
@@ -336,10 +303,10 @@ export async function getProtocolV2WalletSession(
     if (options?.onlyMainPin) {
       device.clearStandardInternalState?.();
       await selectMainWallet(true);
-      response = await getDeviceSession(device, {}, options?.deriveCardano);
+      response = await getDeviceSession(device, {});
     } else {
       device.clearInternalState();
-      response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
+      response = await selectDeviceSession(device, expectedPassphraseState);
     }
     message = response.message;
     try {

package/src/types/api/index.ts

@@ -1,6 +1,7 @@
 import type {
   deviceGetOnboardingStatus,
   deviceReboot,
+  deviceUploadNft,
   deviceUploadWallpaper,
   testProtocolV2Ping,
   uploadPortfolio,
@@ -234,6 +235,7 @@ export type CoreApi = {
    */
   deviceReboot: typeof deviceReboot;
   deviceGetOnboardingStatus: typeof deviceGetOnboardingStatus;
+  deviceUploadNft: typeof deviceUploadNft;
   deviceUploadWallpaper: typeof deviceUploadWallpaper;
   uploadPortfolio: typeof uploadPortfolio;