@onekeyfe/hd-core 1.2.8-alpha.5 → 1.2.8-alpha.6

package/src/core/index.ts

@@ -23,6 +23,7 @@ import {
   createNeedUpgradeFirmwareHardwareError,
   createNewFirmwareForceUpdateHardwareError,
   createNewFirmwareUnReleaseHardwareError,
+  isBleStaleBondHardwareError,
 } from '@onekeyfe/hd-shared';
 
 import { LoggerNames, enableLog, getLogger, setLoggerPostMessage, wait } from '../utils';
@@ -1034,6 +1035,10 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
   );
 }
 
+export function isTerminalBleStaleBondError(error: unknown) {
+  return isBleStaleBondHardwareError(error);
+}
+
 export function isDeviceIdentityMismatchError(error: unknown) {
   return (
     (error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.DeviceCheckDeviceIdError
@@ -1272,7 +1277,6 @@ const ensureConnected = async (
             HardwareErrorCode.BridgeNotInstalled,
             HardwareErrorCode.BridgeTimeoutError,
             HardwareErrorCode.BridgeNeedsPermission,
-            HardwareErrorCode.WebUsbDeviceAccessError,
           ].includes(error.errorCode)
         ) {
           _deviceList = undefined;
@@ -1359,7 +1363,6 @@ const ensureConnected = async (
             HardwareErrorCode.DeviceDetectInBootloaderMode,
             HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
             HardwareErrorCode.BridgeNeedsPermission,
-            HardwareErrorCode.WebUsbDeviceAccessError,
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
           ].includes(error.errorCode) ||
@@ -1367,6 +1370,7 @@ const ensureConnected = async (
             [HardwareErrorCode.BleDeviceDisconnected, HardwareErrorCode.PollingTimeout].includes(
               error.errorCode
             )) ||
+          isTerminalBleStaleBondError(error) ||
           isDeviceIdentityMismatchError(error)
         ) {
           reject(error);
@@ -1589,7 +1593,7 @@ const onDeviceConnectHandler = (device: Device) => {
 
 const onDeviceDisconnectHandler = (device: Device) => {
   device.clearPreInitialized();
-  const deviceObject = device.toDisconnectMessageObject();
+  const deviceObject = device.toMessageObject();
   if (!deviceObject) return;
   postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject }));
 };

package/src/data/messages/messages.json

@@ -12485,6 +12485,8 @@
         "(has_bitcoin_only_values)": true
       },
       "values": {
+        "MessageType_BabylonDeriveContextHash": 10054,
+        "MessageType_BabylonDerivedContextHash": 10055,
         "MessageType_Initialize": 0,
         "MessageType_Ping": 1,
         "MessageType_Success": 2,
@@ -12949,6 +12951,55 @@
         "MessageType_UpgradeFileHeader": 10050
       }
     },
+    "CanonicalBitcoinNetwork": {
+      "values": {
+        "BITCOIN_MAINNET": 0,
+        "BITCOIN_TESTNET": 1,
+        "BITCOIN_SIGNET": 2,
+        "BITCOIN_REGTEST": 3
+      }
+    },
+    "BabylonDeriveContextHash": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "script_type": {
+          "rule": "required",
+          "type": "InputScriptType",
+          "id": 2
+        },
+        "app_name": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 3
+        },
+        "context": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 4
+        },
+        "network": {
+          "rule": "required",
+          "type": "CanonicalBitcoinNetwork",
+          "id": 5
+        }
+      }
+    },
+    "BabylonDerivedContextHash": {
+      "fields": {
+        "secret": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
     "google": {
       "nested": {
         "protobuf": {

package/src/device/Device.ts

@@ -248,9 +248,6 @@ export class Device extends EventEmitter {
   /** Canonical device-state cache; legacy Features is a compatibility projection. */
   private stateStore = new DeviceStateStore();
 
-  /** Retain the old public identity only for disconnect notifications after wipe. */
-  private deviceBeforeWipe: DeviceTyped | null = null;
-
   /** Force the next initialization to reload DeviceInfo after reconnect or reboot. */
   private protocolV2StateNeedsReload = false;
 
@@ -354,8 +351,6 @@ export class Device extends EventEmitter {
   toMessageObject(): DeviceTyped | null {
     if (this.isUnacquired() || !this.features) return null;
 
-    this.deviceBeforeWipe = null;
-
     const env = DataManager.getSettings('env');
     const deviceType = this.getCurrentDeviceType();
 
@@ -400,10 +395,6 @@ export class Device extends EventEmitter {
     };
   }
 
-  toDisconnectMessageObject(): DeviceTyped | null {
-    return this.toMessageObject() ?? this.deviceBeforeWipe;
-  }
-
   /**
    * Device connect
    * @returns {Promise<boolean>}
@@ -1373,7 +1364,6 @@ export class Device extends EventEmitter {
   }
 
   invalidateAfterWipe() {
-    this.deviceBeforeWipe = this.toMessageObject() ?? this.deviceBeforeWipe;
     const deviceId = this.getCurrentDeviceId();
     if (deviceId) {
       deviceWalletSessionStore.deleteDevice(deviceId);
@@ -1811,7 +1801,7 @@ export class Device extends EventEmitter {
     // both allow and require cases might generate single unexpected mode
     if (!this.isUnacquired()) {
       // allow cases
-      if ((this.isBootloader() || this.isRomloader()) && !allow.includes(UI_REQUEST.BOOTLOADER)) {
+      if (this.isBootloader() && !this.isProtocolV2() && !allow.includes(UI_REQUEST.BOOTLOADER)) {
         return UI_REQUEST.BOOTLOADER;
       }
       if (!this.isInitialized() && !allow.includes(UI_REQUEST.NOT_INITIALIZE)) {

package/src/device/DeviceCommands.ts

@@ -549,16 +549,6 @@ export class DeviceCommands {
           this.device.isProtocolV2() &&
           DEVICE_CONTROL_CALLS.has(callType) &&
           subcode === DeviceErrorCode.DeviceError_Busy;
-        const isProtocolV2PinCancelledBusyFailure =
-          this.device.isProtocolV2() &&
-          !DEVICE_SESSION_CALLS.has(callType) &&
-          subcode === DeviceSessionErrorCode.DeviceSessionError_UserCancelled &&
-          /^pin cancelled$/i.test(normalizedMessage);
-        const isProtocolV2FirmwareUpdateBusyFailure =
-          this.device.isProtocolV2() &&
-          /^requested command not allowed while a firmware update is in progress$/i.test(
-            normalizedMessage
-          );
         const isLegacyProtocolV2LockedFailure =
           this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
         if (
@@ -616,11 +606,7 @@ export class DeviceCommands {
             subcode,
             firmwareMessage: message,
           });
-        } else if (
-          isProtocolV2DeviceBusyFailure ||
-          isProtocolV2PinCancelledBusyFailure ||
-          isProtocolV2FirmwareUpdateBusyFailure
-        ) {
+        } else if (isProtocolV2DeviceBusyFailure) {
           error = ERRORS.TypedError(HardwareErrorCode.DeviceBusy, message, {
             failureCode: code,
             subcode,

package/src/device/DevicePool.ts

@@ -114,11 +114,7 @@ export class DevicePool extends EventEmitter {
         const exist = canPathIdentifyDevice(cachedPath)
           ? descriptorList.find(d => d.path === cachedPath)
           : undefined;
-        if (
-          exist &&
-          !initOptions?.forceProtocolDetection &&
-          !(device.needReloadDevice && device.isUnacquired())
-        ) {
+        if (exist && !initOptions?.forceProtocolDetection) {
           // Log.debug('find existed Device: ', connectId);
           device.updateDescriptor(exist, true);
           await this._refreshRuntimeState(device, initOptions);
@@ -174,13 +170,7 @@ export class DevicePool extends EventEmitter {
     const forceProtocolDetection = initOptions?.forceProtocolDetection === true;
     const isNewDevice = !cachedDevice;
     const device = cachedDevice ?? Device.fromDescriptor(descriptor);
-    if (
-      isNewDevice ||
-      forceProtocolDetection ||
-      (device.needReloadDevice && device.isUnacquired())
-    ) {
-      // Wipe invalidates state while the same USB path can remain discoverable.
-      if (cachedDevice) device.updateDescriptor(descriptor, true);
+    if (isNewDevice || forceProtocolDetection) {
       device.deviceConnector = this.connector;
       // Search/discovery acquires outside Device.run(). Start a new attempt so
       // a previous user cancel does not hide this device from later searches.

package/src/events/core.ts

@@ -54,9 +54,9 @@ export const parseMessage = (messageData: any): CoreMessage => {
 };
 
 export const createErrorMessage = (error: Error & { code?: string | number }): Unsuccessful => {
-  let payload: Unsuccessful['payload'] = { error: error.message, code: error.code };
+  let payload = { error: error.message, code: error.code };
   if (error instanceof HardwareError) {
-    payload = { error: error.message, code: error.errorCode, params: error.params };
+    payload = { error: error.message, code: error.errorCode };
   }
   return {
     success: false,

package/src/events/logBlockEvent.ts

@@ -11,6 +11,7 @@ export const LogBlockEvent: Set<string> = new Set([
 // These resource/file APIs did not exist in 1.1.32. Skip the payload so
 // the log layer does not copy huge Base64 or binary data.
 const LogPayloadBlockMethod: Set<string> = new Set([
+  'btcDeriveContextHash',
   'deviceUploadNft',
   'deviceUploadWallpaper',
   'uploadPortfolio',

package/src/inject.ts

@@ -309,6 +309,8 @@ export const createCoreApi = (
     call({ ...params, connectId, deviceId, method: 'btcGetAddress' }),
   btcGetPublicKey: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'btcGetPublicKey' }),
+  btcDeriveContextHash: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'btcDeriveContextHash' }),
   btcSignMessage: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'btcSignMessage' }),
   btcSignPsbt: (connectId, deviceId, params) =>

package/src/types/api/btcDeriveContextHash.ts

@@ -0,0 +1,15 @@
+import type { BabylonDerivedContextHash } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type BTCDeriveContextHashParams = {
+  path: string | number[];
+  appName: string;
+  context: string;
+  network: 'bitcoin-mainnet' | 'bitcoin-testnet' | 'bitcoin-signet' | 'bitcoin-regtest';
+};
+
+export declare function btcDeriveContextHash(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & BTCDeriveContextHashParams
+): Response<BabylonDerivedContextHash>;

package/src/types/api/export.ts

@@ -1,5 +1,6 @@
 export type { BTCAddress, BTCGetAddressParams } from './btcGetAddress';
 export type { BTCPublicKey, BTCGetPublicKeyParams } from './btcGetPublicKey';
+export type { BTCDeriveContextHashParams } from './btcDeriveContextHash';
 export type { BTCSignMessageParams } from './btcSignMessage';
 export type { BTCVerifyMessageParams } from './btcVerifyMessage';
 export type {

package/src/types/api/index.ts

@@ -73,6 +73,7 @@ import type { evmSignTypedData } from './evmSignTypedData';
 import type { evmVerifyMessage } from './evmVerifyMessage';
 import type { btcGetAddress } from './btcGetAddress';
 import type { btcGetPublicKey } from './btcGetPublicKey';
+import type { btcDeriveContextHash } from './btcDeriveContextHash';
 import type { btcSignMessage } from './btcSignMessage';
 import type { btcSignPsbt } from './btcSignPsbt';
 import type { btcSignTransaction } from './btcSignTransaction';
@@ -286,6 +287,7 @@ export type CoreApi = {
    */
   btcGetAddress: typeof btcGetAddress;
   btcGetPublicKey: typeof btcGetPublicKey;
+  btcDeriveContextHash: typeof btcDeriveContextHash;
   btcSignMessage: typeof btcSignMessage;
   btcSignPsbt: typeof btcSignPsbt;
   btcSignTransaction: typeof btcSignTransaction;

package/src/types/params.ts

@@ -83,7 +83,7 @@ export type Params<T> = CommonParams & T & { bundle?: undefined };
 
 export interface Unsuccessful {
   success: false;
-  payload: { error: string; code?: string | number; params?: Record<string, unknown> };
+  payload: { error: string; code?: string | number };
 }
 
 export interface Success<T> {