@onekeyfe/hd-core 1.2.0-alpha.66 → 1.2.0-alpha.67

package/src/core/index.ts

@@ -1,6 +1,6 @@
 import semver from 'semver';
 import EventEmitter from 'events';
-import { DeviceSessionPinType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 import {
   ERRORS,
   ERROR_CODES_REQUIRE_RELEASE,
@@ -26,7 +26,6 @@ import {
   createRequestContext,
   createSdkTracingContext,
   formatRequestContext,
-  generateInstanceId,
   getActiveRequestsByDeviceInstance,
   updateRequestContext,
 } from '../utils/tracing';
@@ -54,15 +53,13 @@ import {
 import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
-import { consumeUiPromise, findUiPromiseForResponse, rejectUiPromises } from './uiPromiseRegistry';
 import { registerHardwareUiEventListeners } from './deviceEventRegistration';
 import { getSynchronize } from '../utils/getSynchronize';
-import { runMethodWithUnlockPolicy } from '../protocols/protocol-v2/unlockPolicyRunner';
+import { runMethodWithUnlockRetry } from '../protocols/protocol-v2/unlockRetry';
 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';
@@ -106,7 +103,6 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   deviceId: method?.payload.deviceId,
   deriveCardano: method && hasDeriveCardano(method),
   connectProtocol: method?.payload.connectProtocol,
-  forceProtocolDetection: method?.payload.forceProtocolDetection,
   protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
 });
 
@@ -158,12 +154,7 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   try {
     method = findMethod(message as IFrameCallMessage);
     method.connector = _connector;
-    const shouldPostMessage = createUiProgressMessageFilter();
-    method.postMessage = event => {
-      if (shouldPostMessage(event)) {
-        postMessage(event);
-      }
-    };
+    method.postMessage = postMessage;
     method.setContext?.(context);
 
     method.requestContext = createRequestContext(method.responseID, method.name, {
@@ -415,8 +406,6 @@ const onCallDevice = async (
 
   registerHardwareUiEventListeners(device, {
     pin: onDevicePinHandler,
-    pinOnDevice: onEnterPinOnDeviceHandler,
-    pinOnDeviceComplete: onPinOnDeviceCompleteHandler,
     button: onDeviceButtonHandler,
     passphrase: message.payload.useEmptyPassphrase
       ? onEmptyPassphraseHandler
@@ -432,9 +421,6 @@ const onCallDevice = async (
   );
 
   const protocolV2UiCoordinator = new ProtocolV2UiInteractionCoordinator(device, postMessage);
-  let protocolV2Operation = false;
-  let protocolV2CloseEmitted = false;
-  device.beginProtocolV2UiInteraction();
   device.on(
     DEVICE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE,
     onSelectDeviceForSwitchFirmwareWebDeviceHandler
@@ -452,7 +438,6 @@ const onCallDevice = async (
       // Protocol is established from an active device response during acquire/initialize.
       // Reject unsupported methods before any method-specific device command is sent.
       method.assertProtocolSupported(device.getProtocol(), device.getCurrentFirmwareType());
-      protocolV2Operation = device.isProtocolV2();
 
       // check firmware version
       const versionRange = device.getCurrentMethodVersionRange(
@@ -562,102 +547,93 @@ const onCallDevice = async (
         );
       }
 
-      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);
-              }
-            }
+      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();
+      /**
+       * 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);
-            }
+      // 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);
 
-            // 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,
-                  }
-                );
+      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 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
+        );
 
-              // 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);
-                throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
-              }
+        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));
-              }
-            }
+        // close pin popup window
+        postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+      }
 
-            // 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.');
-            }
+      // 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;
+      }
 
-            method.device?.commands?.checkDisposed();
-          },
-        });
+      method.device?.commands?.checkDisposed();
+
+      try {
+        const response: object = await runMethodWithUnlockRetry(
+          method,
+          device,
+          protocolV2UiCoordinator
+        );
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
       } catch (error) {
-        // Device.run may release the request before transport callbacks finish after a timeout.
-        // Ignore the stale callback because the caller already received the connection error.
-        if (!requestQueue.getTask(method.responseID)) {
-          Log.debug(`Call API - Ignore late inner method result`, error);
-          return;
-        }
         Log.debug(`Call API - Inner Method Run Error`, error);
         messageResponse = createResponseMessage(method.responseID, false, { error });
         requestQueue.resolveRequest(method.responseID, messageResponse);
@@ -671,12 +647,7 @@ const onCallDevice = async (
           throw error;
         }
       } finally {
-        if (isProtocolV2UiEnabled(method)) {
-          protocolV2CloseEmitted = protocolV2UiCoordinator.close({
-            ensureOperationClose: protocolV2Operation,
-            protocolV2Operation,
-          });
-        }
+        protocolV2UiCoordinator.close();
       }
     };
     Log.debug('Call API - Device Run: ', device.mainId);
@@ -731,15 +702,7 @@ const onCallDevice = async (
     requestQueue.releaseTask(method.responseID);
 
     if (isProtocolV2UiEnabled(method)) {
-      if (!protocolV2CloseEmitted && protocolV2Operation) {
-        protocolV2CloseEmitted = protocolV2UiCoordinator.close({
-          ensureOperationClose: true,
-          protocolV2Operation: true,
-        });
-      }
-      if (!protocolV2CloseEmitted) {
-        closePopup();
-      }
+      closePopup();
     }
 
     cleanup();
@@ -902,18 +865,10 @@ function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown)
  */
 async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
-    if (method.payload.forceProtocolDetection && device.hasDeviceAcquire()) {
-      await device.release();
-    }
     const shouldAcquire =
-      method.payload.forceProtocolDetection ||
-      !device.hasDeviceAcquire() ||
-      !device.commands ||
-      device.commands.disposed;
+      !device.hasDeviceAcquire() || !device.commands || device.commands.disposed;
     if (shouldAcquire) {
-      await device.acquire(method.payload.connectProtocol, {
-        forceProtocolDetection: method.payload.forceProtocolDetection,
-      });
+      await device.acquire(method.payload.connectProtocol);
     }
     if (method.payload?.onlyConnectBleDevice) {
       if (shouldAcquire) {
@@ -1226,12 +1181,7 @@ const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
 };
 
 const cleanup = () => {
-  const pendingUiPromises = _uiPromises;
   _uiPromises = [];
-  rejectUiPromises(
-    pendingUiPromises,
-    ERRORS.TypedError(HardwareErrorCode.ActionCancelled, 'UI request was cancelled')
-  );
   Log.debug('Cleanup...');
 };
 
@@ -1273,7 +1223,7 @@ const onTransportDeviceDisconnectHandler = (event: TransportDeviceDisconnectEven
   DevicePool.emitter.emit(DEVICE.DISCONNECT, device);
 };
 
-const onDevicePinHandler = (...[device, type, callback]: DeviceEvents['pin']) => {
+const onDevicePinHandler = async (...[device, type, callback]: DeviceEvents['pin']) => {
   Log.log('request Input PIN');
   // create ui promise
   const uiPromise = createUiPromise(UI_RESPONSE.RECEIVE_PIN, device);
@@ -1282,14 +1232,12 @@ const onDevicePinHandler = (...[device, type, callback]: DeviceEvents['pin']) =>
     createUiMessage(UI_REQUEST.REQUEST_PIN, {
       device: device.toMessageObject() as unknown as KnownDevice,
       type,
-      responseCorrelation: uiPromise.responseCorrelation,
     })
   );
-  consumeUiPromise(
-    uiPromise.promise,
-    uiResp => callback(null, uiResp.payload),
-    error => callback(error, '')
-  );
+  // wait for pin
+  const uiResp = await uiPromise.promise;
+  // callback.apply(null, [null, pin]);
+  callback(null, uiResp.payload);
 };
 
 export const onDeviceButtonHandler = (...[device, request]: [...DeviceEvents['button']]) => {
@@ -1317,7 +1265,7 @@ const onDeviceStateHandler = (...[_, stateEvent]: [...DeviceEvents['state']]) =>
   postMessage(createDeviceMessage(DEVICE.STATE, stateEvent));
 };
 
-const onDevicePassphraseHandler = (
+const onDevicePassphraseHandler = async (
   ...[device, requestPayload, callback]: DeviceEvents['passphrase']
 ) => {
   Log.debug('onDevicePassphraseHandler');
@@ -1331,23 +1279,18 @@ const onDevicePassphraseHandler = (
       source: requestPayload.source,
       reason: requestPayload.reason,
       expectedPassphraseState: requestPayload.expectedPassphraseState,
-      ...(requestPayload.interaction ? { interaction: requestPayload.interaction } : {}),
-      responseCorrelation: uiPromise.responseCorrelation,
     })
   );
-  consumeUiPromise(
-    uiPromise.promise,
-    uiResp => {
-      const { value, passphraseOnDevice, save, attachPinOnDevice } = uiResp.payload;
-      callback({
-        passphrase: value.normalize('NFKD'),
-        passphraseOnDevice,
-        attachPinOnDevice,
-        cache: save,
-      });
-    },
-    error => callback({}, error)
-  );
+  // wait for passphrase
+  const uiResp = await uiPromise.promise;
+  const { value, passphraseOnDevice, save, attachPinOnDevice } = uiResp.payload;
+  // send as PassphrasePromptResponse
+  callback({
+    passphrase: value.normalize('NFKD'),
+    passphraseOnDevice,
+    attachPinOnDevice,
+    cache: save,
+  });
 };
 
 const onEmptyPassphraseHandler = (...[_, , callback]: DeviceEvents['passphrase']) => {
@@ -1365,7 +1308,6 @@ const onEnterPassphraseOnDeviceHandler = (
       passphraseState: device.passphraseState,
       source: requestPayload?.source,
       reason: requestPayload?.reason,
-      ...(requestPayload?.interaction ? { interaction: requestPayload.interaction } : {}),
     })
   );
 };
@@ -1379,40 +1321,11 @@ 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 = (
+const onSelectDeviceInBootloaderForWebDeviceHandler = async (
   ...[device, callback]: [...DeviceEvents['select_device_in_bootloader_for_web_device']]
 ) => {
   Log.debug('onSelectDeviceInBootloaderForWebDeviceHandler');
@@ -1422,14 +1335,11 @@ const onSelectDeviceInBootloaderForWebDeviceHandler = (
       device: device.toMessageObject() as KnownDevice,
     })
   );
-  consumeUiPromise(
-    uiPromise.promise,
-    uiResp => callback(null, uiResp.payload.deviceId),
-    error => callback(error, '')
-  );
+  const uiResp = await uiPromise.promise;
+  callback(null, uiResp.payload.deviceId);
 };
 
-const onSelectDeviceForSwitchFirmwareWebDeviceHandler = (
+const onSelectDeviceForSwitchFirmwareWebDeviceHandler = async (
   ...[device, callback]: [...DeviceEvents['select_device_for_switch_firmware_web_device']]
 ) => {
   Log.debug('onSelectDeviceForSwitchFirmwareWebDeviceHandler');
@@ -1442,11 +1352,8 @@ const onSelectDeviceForSwitchFirmwareWebDeviceHandler = (
       device: device.toMessageObject() as KnownDevice,
     })
   );
-  consumeUiPromise(
-    uiPromise.promise,
-    uiResp => callback(null, uiResp.payload.deviceId),
-    error => callback(error, '')
-  );
+  const uiResp = await uiPromise.promise;
+  callback(null, uiResp.payload.deviceId);
 };
 
 /**
@@ -1465,21 +1372,14 @@ const postMessage = (message: CoreMessage) => {
 
 const createUiPromise = <T extends UiPromiseResponse['type']>(promiseEvent: T, device?: Device) => {
   const uiPromise: UiPromise<T> = createDeferred(promiseEvent, device);
-  if (
-    device &&
-    (promiseEvent === UI_RESPONSE.RECEIVE_PIN || promiseEvent === UI_RESPONSE.RECEIVE_PASSPHRASE)
-  ) {
-    const publicDeviceId = device.toMessageObject()?.deviceId;
-    uiPromise.responseCorrelation = {
-      interactionId: generateInstanceId('UiResponse', device.sdkInstanceId),
-      deviceId: publicDeviceId || device.instanceId,
-    };
-  }
   _uiPromises.push(uiPromise as any);
 
   return uiPromise;
 };
 
+const findUiPromise = <T extends UiPromiseResponse['type']>(promiseEvent: T) =>
+  _uiPromises.find(p => p.id === promiseEvent);
+
 const removeUiPromise = (promise: Deferred<any>) => {
   _uiPromises = _uiPromises.filter(p => p !== promise);
 };
@@ -1531,16 +1431,11 @@ export default class Core extends EventEmitter {
       case UI_RESPONSE.RECEIVE_PASSPHRASE:
       case UI_RESPONSE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE:
       case UI_RESPONSE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE: {
-        const uiPromise = findUiPromiseForResponse(_uiPromises, message);
+        const uiPromise = findUiPromise(message.type);
         if (uiPromise) {
           Log.log('receive UI Response: ', message.type);
           uiPromise.resolve(message);
           removeUiPromise(uiPromise);
-        } else if (
-          message.type === UI_RESPONSE.RECEIVE_PIN ||
-          message.type === UI_RESPONSE.RECEIVE_PASSPHRASE
-        ) {
-          Log.warn('Ignored unmatched or ambiguous sensitive UI response:', message.type);
         }
         break;
       }
@@ -1668,8 +1563,12 @@ export const init = async (
   plugin?: LowlevelTransportSharedPlugin
 ) => {
   try {
-    await DataManager.load(settings);
-    initTransport(Transport, plugin);
+    try {
+      await DataManager.load(settings);
+      initTransport(Transport, plugin);
+    } catch {
+      Log.error('DataManager.load error');
+    }
     enableLog(DataManager.getSettings('debug'));
     if (DataManager.getSettings('env') !== 'react-native') {
       setLoggerPostMessage(postMessage);
@@ -1680,7 +1579,6 @@ export const init = async (
     return _core;
   } catch (error) {
     Log.error('core init', error);
-    throw error;
   }
 };
 

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

@@ -470,7 +470,6 @@
         "MessageType_DeviceSessionAskPin": 61202,
         "MessageType_DeviceSessionAskPassphrase": 61203,
         "MessageType_PortfolioUpdate": 61400,
-        "MessageType_NftUpdate": 61500,
         "MessageType_OnboardingStatusGet": 61600,
         "MessageType_OnboardingStatus": 61601
       },
@@ -12201,26 +12200,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
         }
       }
     },
@@ -12554,15 +12538,6 @@
         }
       }
     },
-    "NftUpdate": {
-      "fields": {
-        "file_name_no_ext": {
-          "rule": "required",
-          "type": "string",
-          "id": 1
-        }
-      }
-    },
     "OnboardingStep": {
       "values": {
         "ONBOARDING_STEP_UNKNOWN": 0,