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

package/src/device/Device.ts

@@ -248,6 +248,9 @@ 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;
 
@@ -351,6 +354,8 @@ 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();
 
@@ -395,6 +400,10 @@ export class Device extends EventEmitter {
     };
   }
 
+  toDisconnectMessageObject(): DeviceTyped | null {
+    return this.toMessageObject() ?? this.deviceBeforeWipe;
+  }
+
   /**
    * Device connect
    * @returns {Promise<boolean>}
@@ -1364,6 +1373,7 @@ export class Device extends EventEmitter {
   }
 
   invalidateAfterWipe() {
+    this.deviceBeforeWipe = this.toMessageObject() ?? this.deviceBeforeWipe;
     const deviceId = this.getCurrentDeviceId();
     if (deviceId) {
       deviceWalletSessionStore.deleteDevice(deviceId);
@@ -1801,7 +1811,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.isProtocolV2() && !allow.includes(UI_REQUEST.BOOTLOADER)) {
+      if ((this.isBootloader() || this.isRomloader()) && !allow.includes(UI_REQUEST.BOOTLOADER)) {
         return UI_REQUEST.BOOTLOADER;
       }
       if (!this.isInitialized() && !allow.includes(UI_REQUEST.NOT_INITIALIZE)) {

package/src/device/DeviceCommands.ts

@@ -549,6 +549,16 @@ 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 (
@@ -606,7 +616,11 @@ export class DeviceCommands {
             subcode,
             firmwareMessage: message,
           });
-        } else if (isProtocolV2DeviceBusyFailure) {
+        } else if (
+          isProtocolV2DeviceBusyFailure ||
+          isProtocolV2PinCancelledBusyFailure ||
+          isProtocolV2FirmwareUpdateBusyFailure
+        ) {
           error = ERRORS.TypedError(HardwareErrorCode.DeviceBusy, message, {
             failureCode: code,
             subcode,

package/src/device/DevicePool.ts

@@ -114,7 +114,11 @@ export class DevicePool extends EventEmitter {
         const exist = canPathIdentifyDevice(cachedPath)
           ? descriptorList.find(d => d.path === cachedPath)
           : undefined;
-        if (exist && !initOptions?.forceProtocolDetection) {
+        if (
+          exist &&
+          !initOptions?.forceProtocolDetection &&
+          !(device.needReloadDevice && device.isUnacquired())
+        ) {
           // Log.debug('find existed Device: ', connectId);
           device.updateDescriptor(exist, true);
           await this._refreshRuntimeState(device, initOptions);
@@ -170,7 +174,13 @@ export class DevicePool extends EventEmitter {
     const forceProtocolDetection = initOptions?.forceProtocolDetection === true;
     const isNewDevice = !cachedDevice;
     const device = cachedDevice ?? Device.fromDescriptor(descriptor);
-    if (isNewDevice || forceProtocolDetection) {
+    if (
+      isNewDevice ||
+      forceProtocolDetection ||
+      (device.needReloadDevice && device.isUnacquired())
+    ) {
+      // Wipe invalidates state while the same USB path can remain discoverable.
+      if (cachedDevice) device.updateDescriptor(descriptor, true);
       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 = { error: error.message, code: error.code };
+  let payload: Unsuccessful['payload'] = { error: error.message, code: error.code };
   if (error instanceof HardwareError) {
-    payload = { error: error.message, code: error.errorCode };
+    payload = { error: error.message, code: error.errorCode, params: error.params };
   }
   return {
     success: false,

package/src/events/logBlockEvent.ts

@@ -11,7 +11,6 @@ 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,8 +309,6 @@ 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/export.ts

@@ -1,6 +1,5 @@
 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,7 +73,6 @@ 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';
@@ -287,7 +286,6 @@ 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 };
+  payload: { error: string; code?: string | number; params?: Record<string, unknown> };
 }
 
 export interface Success<T> {

package/__tests__/btc-derive-context-hash.test.ts

@@ -1,200 +0,0 @@
-import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import BTCDeriveContextHash from '../src/api/btc/BTCDeriveContextHash';
-import { findMethod } from '../src/api/utils';
-import { getLogBlockLabel, getSafeLogPayload } from '../src/events/logBlockEvent';
-import { createCoreApi } from '../src/inject';
-import { Device } from '../src/device/Device';
-
-import type { DeviceFirmwareRange } from '../src/types';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-const createMethod = (overrides: Record<string, unknown> = {}) =>
-  new BTCDeriveContextHash({
-    id: 1,
-    payload: {
-      method: 'btcDeriveContextHash',
-      path: "m/84'/0'/0'/0/0",
-      appName: 'test-app',
-      context: 'deadbeef',
-      network: 'bitcoin-mainnet',
-      ...overrides,
-    },
-  });
-
-describe('btcDeriveContextHash', () => {
-  test('forwards the public API call through the existing dispatcher', async () => {
-    const call = jest
-      .fn()
-      .mockResolvedValue({ success: true, payload: { secret: '00'.repeat(32) } });
-    const api = createCoreApi(call);
-    const params = {
-      path: "m/84'/0'/0'/0/0",
-      appName: 'test-app',
-      context: 'deadbeef',
-      network: 'bitcoin-mainnet' as const,
-    };
-    await api.btcDeriveContextHash('connect-id', 'device-id', params);
-    expect(call).toHaveBeenCalledWith({
-      ...params,
-      connectId: 'connect-id',
-      deviceId: 'device-id',
-      method: 'btcDeriveContextHash',
-    });
-  });
-
-  test.each([
-    ['bitcoin-mainnet', 'BITCOIN_MAINNET'],
-    ['bitcoin-testnet', 'BITCOIN_TESTNET'],
-    ['bitcoin-signet', 'BITCOIN_SIGNET'],
-    ['bitcoin-regtest', 'BITCOIN_REGTEST'],
-  ])('maps %s and returns the device result', async (network, wireNetwork) => {
-    const method = createMethod({ network });
-    method.init();
-    const response = { secret: '00'.repeat(32) };
-    const typedCall = jest.fn().mockResolvedValue({ message: response });
-    method.device = { commands: { typedCall } } as unknown as Device;
-
-    await expect(method.run()).resolves.toBe(response);
-    expect(typedCall).toHaveBeenCalledWith(
-      'BabylonDeriveContextHash',
-      'BabylonDerivedContextHash',
-      {
-        address_n: [2147483732, 2147483648, 2147483648, 0, 0],
-        script_type: 'SPENDWITNESS',
-        app_name: '746573742d617070',
-        context: 'deadbeef',
-        network: wireNetwork,
-      }
-    );
-  });
-
-  test.each([
-    ["m/44'/0'/0'/0/0", 'SPENDADDRESS'],
-    ["m/49'/0'/0'/0/0", 'SPENDP2SHWITNESS'],
-    [[2147483734, 2147483648, 2147483648, 0, 0], 'SPENDTAPROOT'],
-  ])('uses the selected path script type for %s', (path, scriptType) => {
-    const method = createMethod({ path });
-    method.init();
-    expect(method.params.script_type).toBe(scriptType);
-  });
-
-  test('accepts the maximum app name and context sizes', () => {
-    const method = createMethod({ appName: 'a'.repeat(64), context: 'ab'.repeat(1024) });
-    expect(() => method.init()).not.toThrow();
-    expect(method.params.context).toHaveLength(2048);
-  });
-
-  test.each([
-    { appName: '' },
-    { appName: 'a'.repeat(65) },
-    { appName: 'Test-App' },
-    { appName: 'test_app' },
-    { appName: '你好' },
-    { appName: null },
-    { context: '' },
-    { context: 'abc' },
-    { context: 'DEADBEEF' },
-    { context: '0xdeadbeef' },
-    { context: 'gg' },
-    { context: 'ab'.repeat(1025) },
-    { context: null },
-    { network: '' },
-    { network: 'litecoin' },
-    { network: 'toString' },
-    { network: 1 },
-    { path: 'm' },
-    { path: "m/84x'/0'/0'/0/0" },
-    { path: "m/2147483648'/0'/0'/0/0" },
-    { path: [2147483732, 2147483648, 2147483648, 0, 0.5] },
-    { path: [2147483732, 2147483648, 2147483648, 0, 4294967296] },
-  ])('rejects invalid inputs before a device call: %j', overrides => {
-    expect(() => createMethod(overrides).init()).toThrow(
-      expect.objectContaining({ errorCode: HardwareErrorCode.CallMethodInvalidParameter })
-    );
-  });
-
-  test('rejects sparse numeric paths before a device call', () => {
-    const sparsePath = [2147483732, 2147483648, 2147483648, 0, 5];
-    delete sparsePath[3];
-
-    [Array<number>(3), sparsePath].forEach(path => {
-      expect(() => createMethod({ path }).init()).toThrow(
-        expect.objectContaining({ errorCode: HardwareErrorCode.CallMethodInvalidParameter })
-      );
-    });
-  });
-
-  test('registers the public method and restricts it to supported firmware and protocol', () => {
-    const method = findMethod({ id: 1, payload: { ...createMethod().payload } });
-    method.init();
-    expect(method).toBeInstanceOf(BTCDeriveContextHash);
-    expect(method.strictCheckDeviceSupport).toBe(true);
-    expect(() => method.assertProtocolSupported('V2', EFirmwareType.Universal)).toThrow(
-      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotSupportMethod })
-    );
-  });
-
-  test.each([EDeviceType.Classic1s, EDeviceType.ClassicPure])(
-    'resolves the firmware requirement for %s through the device support check',
-    deviceType => {
-      const method = createMethod();
-      const device = Object.create(Device.prototype) as Device;
-      device.getCurrentDeviceType = jest.fn(() => deviceType);
-      const range: DeviceFirmwareRange = method.getVersionRange();
-
-      expect(device.getCurrentMethodVersionRange(type => range[type])).toEqual({ min: '3.21.0' });
-      expect(() => method.assertProtocolSupported('V1', EFirmwareType.Universal)).not.toThrow();
-    }
-  );
-
-  test.each([EDeviceType.Classic, EDeviceType.Mini, EDeviceType.Touch, EDeviceType.Pro])(
-    'keeps %s outside the supported firmware range',
-    deviceType => {
-      const method = createMethod();
-      const device = Object.create(Device.prototype) as Device;
-      device.getCurrentDeviceType = jest.fn(() => deviceType);
-      const range: DeviceFirmwareRange = method.getVersionRange();
-
-      expect(device.getCurrentMethodVersionRange(type => range[type])).toBeUndefined();
-    }
-  );
-
-  test('propagates device rejection without returning a secret', async () => {
-    const method = createMethod();
-    method.init();
-    const error = new Error('User rejected');
-    method.device = {
-      commands: { typedCall: jest.fn().mockRejectedValue(error) },
-    } as unknown as Device;
-    await expect(method.run()).rejects.toBe(error);
-  });
-
-  test.each([undefined, '00', '00'.repeat(33)])(
-    'rejects malformed device responses',
-    async secret => {
-      const method = createMethod();
-      method.init();
-      method.device = {
-        commands: { typedCall: jest.fn().mockResolvedValue({ message: { secret } }) },
-      } as unknown as Device;
-      await expect(method.run()).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.CallMethodError,
-      });
-    }
-  );
-
-  test('blocks API request and response payloads in logs', () => {
-    const request = { payload: { method: 'btcDeriveContextHash' } };
-    const label = getLogBlockLabel(request);
-    expect(label).toBe('btcDeriveContextHash');
-    expect(getSafeLogPayload({ payload: { secret: '00'.repeat(32) } }, label)).toEqual({
-      method: 'btcDeriveContextHash',
-      payload: '[REDACTED]',
-    });
-  });
-});

package/dist/api/btc/BTCDeriveContextHash.d.ts

@@ -1,16 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-import type { BabylonDeriveContextHash } from '@onekeyfe/hd-transport';
-export default class BTCDeriveContextHash extends BaseMethod<BabylonDeriveContextHash> {
-    strictCheckDeviceSupport: boolean;
-    init(): void;
-    getVersionRange(): {
-        classic1s: {
-            min: string;
-        };
-        classicpure: {
-            min: string;
-        };
-    };
-    run(): Promise<import("@onekeyfe/hd-transport").BabylonDerivedContextHash>;
-}
-//# sourceMappingURL=BTCDeriveContextHash.d.ts.map

package/dist/api/btc/BTCDeriveContextHash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BTCDeriveContextHash.d.ts","sourceRoot":"","sources":["../../../src/api/btc/BTCDeriveContextHash.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,OAAO,KAAK,EAAE,wBAAwB,EAA2B,MAAM,wBAAwB,CAAC;AAUhG,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,UAAU,CAAC,wBAAwB,CAAC;IACpF,wBAAwB,UAAQ;IAEhC,IAAI;IAgDJ,eAAe;;;;;;;;IAOT,GAAG;CAcV"}

package/dist/types/api/btcDeriveContextHash.d.ts

@@ -1,10 +0,0 @@
-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>;
-//# sourceMappingURL=btcDeriveContextHash.d.ts.map

package/dist/types/api/btcDeriveContextHash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"btcDeriveContextHash.d.ts","sourceRoot":"","sources":["../../../src/types/api/btcDeriveContextHash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAExD,MAAM,MAAM,0BAA0B,GAAG;IACvC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,iBAAiB,GAAG,iBAAiB,GAAG,gBAAgB,GAAG,iBAAiB,CAAC;CACvF,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAC1C,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,YAAY,GAAG,0BAA0B,GAChD,QAAQ,CAAC,yBAAyB,CAAC,CAAC"}

package/src/api/btc/BTCDeriveContextHash.ts

@@ -1,90 +0,0 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { Buffer } from 'buffer';
-
-import { BaseMethod } from '../BaseMethod';
-import { invalidParameter, validateParams } from '../helpers/paramsValidator';
-import { getScriptType, validatePath } from '../helpers/pathUtils';
-
-import type { BabylonDeriveContextHash, CanonicalBitcoinNetwork } from '@onekeyfe/hd-transport';
-import type { BTCDeriveContextHashParams } from '../../types';
-
-const NETWORKS: Record<BTCDeriveContextHashParams['network'], CanonicalBitcoinNetwork> = {
-  'bitcoin-mainnet': 'BITCOIN_MAINNET',
-  'bitcoin-testnet': 'BITCOIN_TESTNET',
-  'bitcoin-signet': 'BITCOIN_SIGNET',
-  'bitcoin-regtest': 'BITCOIN_REGTEST',
-};
-
-export default class BTCDeriveContextHash extends BaseMethod<BabylonDeriveContextHash> {
-  strictCheckDeviceSupport = true;
-
-  init() {
-    this.checkDeviceId = true;
-    this.allowUsePreInitialize = true;
-
-    validateParams(this.payload, [
-      { name: 'path', required: true },
-      { name: 'appName', type: 'string', required: true },
-      { name: 'context', type: 'string', required: true },
-      { name: 'network', type: 'string', required: true },
-    ]);
-
-    const { path, appName, context, network } = this.payload;
-    if (typeof appName !== 'string' || !/^[a-z0-9-]{1,64}$/.test(appName)) {
-      throw invalidParameter(
-        'appName must contain 1..64 ASCII lowercase letters, digits or hyphens'
-      );
-    }
-    if (typeof context !== 'string' || !/^(?:[0-9a-f]{2}){1,1024}$/.test(context)) {
-      throw invalidParameter('context must be 1..1024 bytes of lowercase hex without a prefix');
-    }
-    if (typeof network !== 'string' || !Object.prototype.hasOwnProperty.call(NETWORKS, network)) {
-      throw invalidParameter('Unsupported Bitcoin network');
-    }
-
-    // Reject malformed or overflowing indices before validatePath can truncate them.
-    if (
-      (typeof path === 'string' &&
-        (!/^m(?:\/\d+'?)+$/i.test(path) ||
-          path
-            .split('/')
-            .slice(1)
-            .some(index => Number(index.replace(/'/g, '')) >= 0x80000000))) ||
-      (Array.isArray(path) &&
-        path.findIndex(index => !Number.isInteger(index) || index < 0 || index > 0xffffffff) !== -1)
-    ) {
-      throw invalidParameter('Not a valid BIP-32 path');
-    }
-    const addressN = validatePath(path, 3);
-
-    this.params = {
-      address_n: addressN,
-      script_type: getScriptType(addressN),
-      app_name: Buffer.from(appName, 'ascii').toString('hex'),
-      context,
-      network: NETWORKS[network as BTCDeriveContextHashParams['network']],
-    };
-  }
-
-  getVersionRange() {
-    return {
-      classic1s: { min: '3.21.0' },
-      classicpure: { min: '3.21.0' },
-    };
-  }
-
-  async run() {
-    const { message } = await this.device.commands.typedCall(
-      'BabylonDeriveContextHash',
-      'BabylonDerivedContextHash',
-      this.params
-    );
-    if (typeof message.secret !== 'string' || !/^[0-9a-f]{64}$/.test(message.secret)) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.CallMethodError,
-        'Invalid Babylon context hash response'
-      );
-    }
-    return message;
-  }
-}

package/src/types/api/btcDeriveContextHash.ts

@@ -1,15 +0,0 @@
-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>;