@onekeyfe/hd-core 1.1.9-alpha.0 → 1.1.9

package/src/api/evm/latest/signTransaction.ts

@@ -1,13 +1,12 @@
 import {
   EthereumSignTx,
   EthereumSignTxEIP1559,
-  EthereumSignTxEIP7702OneKey,
   EthereumTxRequestOneKey,
   MessageResponse,
   TypedCall,
 } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { EVMSignedTx, EVMTransaction, EVMTransactionEIP1559, EVMTransactionEIP7702 } from '../../../types';
+import { EVMSignedTx, EVMTransaction, EVMTransactionEIP1559 } from '../../../types';
 import { cutString } from '../../helpers/stringUtils';
 import { stripHexStartZeroes } from '../../helpers/hexUtils';
 
@@ -181,91 +180,17 @@ export const evmSignTxEip1559 = async ({
 
   return processTxRequest({ typedCall, request: response.message, data: rest, supportTrezor });
 };
-
-export const evmSignTxEip7702 = async ({
-  typedCall,
-  addressN,
-  tx,
-  supportTrezor,
-}: {
-  typedCall: TypedCall;
-  addressN: number[];
-  tx: EVMTransactionEIP7702;
-  supportTrezor?: boolean;
-}) => {
-  const {
-    to,
-    value,
-    gasLimit,
-    nonce,
-    data,
-    chainId,
-    maxFeePerGas,
-    maxPriorityFeePerGas,
-    accessList,
-    authorizationList,
-  } = tx;
-
-  const length = data == null ? 0 : data.length / 2;
-
-  const [first, rest] = cutString(data, 1024 * 2);
-
-  const message: EthereumSignTxEIP7702OneKey = {
-    address_n: addressN,
-    nonce: stripHexStartZeroes(nonce),
-    max_gas_fee: stripHexStartZeroes(maxFeePerGas),
-    max_priority_fee: stripHexStartZeroes(maxPriorityFeePerGas),
-    gas_limit: stripHexStartZeroes(gasLimit),
-    to,
-    value: stripHexStartZeroes(value),
-    data_length: length,
-    data_initial_chunk: first,
-    chain_id: chainId,
-    access_list: (accessList || []).map(a => ({
-      address: a.address,
-      storage_keys: a.storageKeys,
-    })),
-    authorization_list: authorizationList.map(auth => ({
-      address_n: auth.addressN || [],
-      chain_id: auth.chainId,
-      address: auth.address,
-      nonce: stripHexStartZeroes(auth.nonce),
-      signature: auth.signature ? {
-        y_parity: auth.signature.yParity,
-        r: auth.signature.r,
-        s: auth.signature.s,
-      } : undefined,
-    })),
-  };
-
-  let response;
-  if (supportTrezor) {
-    // Note: Trezor doesn't support EIP7702 yet, this is for future compatibility
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'EIP7702 not supported by Trezor');
-  } else {
-    response = await typedCall('EthereumSignTxEIP7702OneKey', 'EthereumTxRequestOneKey', message);
-  }
-
-  return processTxRequest({ typedCall, request: response.message, data: rest, supportTrezor });
-};
-
 export const signTransaction = async ({
   typedCall,
   isEIP1559,
-  isEIP7702,
   addressN,
   tx,
 }: {
   addressN: number[];
-  tx: EVMTransaction | EVMTransactionEIP1559 | EVMTransactionEIP7702;
+  tx: EVMTransaction | EVMTransactionEIP1559;
   isEIP1559: boolean;
-  isEIP7702?: boolean;
   typedCall: TypedCall;
-}) => {
-  if (isEIP7702) {
-    return evmSignTxEip7702({ typedCall, addressN, tx: tx as EVMTransactionEIP7702 });
-  }
-  return isEIP1559
+}) =>
+  isEIP1559
     ? evmSignTxEip1559({ typedCall, addressN, tx: tx as EVMTransactionEIP1559 })
     : evmSignTx({ typedCall, addressN, tx: tx as EVMTransaction });
-};

package/src/data/messages/messages.json

@@ -5323,125 +5323,6 @@
         }
       }
     },
-    "EthereumAuthorizationSignature": {
-      "fields": {
-        "y_parity": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 1
-        },
-        "r": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 2
-        },
-        "s": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 3
-        }
-      }
-    },
-    "EthereumAuthorizationOneKey": {
-      "fields": {
-        "address_n": {
-          "rule": "repeated",
-          "type": "uint32",
-          "id": 1,
-          "options": {
-            "packed": false
-          }
-        },
-        "chain_id": {
-          "rule": "required",
-          "type": "uint64",
-          "id": 2
-        },
-        "address": {
-          "rule": "required",
-          "type": "string",
-          "id": 3
-        },
-        "nonce": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 4
-        },
-        "signature": {
-          "type": "EthereumAuthorizationSignature",
-          "id": 5
-        }
-      }
-    },
-    "EthereumSignTxEIP7702OneKey": {
-      "fields": {
-        "address_n": {
-          "rule": "repeated",
-          "type": "uint32",
-          "id": 1,
-          "options": {
-            "packed": false
-          }
-        },
-        "nonce": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 2
-        },
-        "max_gas_fee": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 3
-        },
-        "max_priority_fee": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 4
-        },
-        "gas_limit": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 5
-        },
-        "to": {
-          "rule": "required",
-          "type": "string",
-          "id": 6
-        },
-        "value": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 7
-        },
-        "data_initial_chunk": {
-          "type": "bytes",
-          "id": 8,
-          "options": {
-            "default": ""
-          }
-        },
-        "data_length": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 9
-        },
-        "chain_id": {
-          "rule": "required",
-          "type": "uint64",
-          "id": 10
-        },
-        "access_list": {
-          "rule": "repeated",
-          "type": "EthereumAccessListOneKey",
-          "id": 11
-        },
-        "authorization_list": {
-          "rule": "repeated",
-          "type": "EthereumAuthorizationOneKey",
-          "id": 12
-        }
-      }
-    },
     "EthereumTxRequestOneKey": {
       "fields": {
         "data_length": {
@@ -5459,11 +5340,6 @@
         "signature_s": {
           "type": "bytes",
           "id": 4
-        },
-        "authorization_signatures": {
-          "rule": "repeated",
-          "type": "EthereumAuthorizationSignature",
-          "id": 10
         }
       }
     },
@@ -12024,7 +11900,6 @@
         "MessageType_EthereumAddressOneKey": 20103,
         "MessageType_EthereumSignTxOneKey": 20104,
         "MessageType_EthereumSignTxEIP1559OneKey": 20105,
-        "MessageType_EthereumSignTxEIP7702OneKey": 20120,
         "MessageType_EthereumTxRequestOneKey": 20106,
         "MessageType_EthereumTxAckOneKey": 20107,
         "MessageType_EthereumSignMessageOneKey": 20108,

package/src/data-manager/DataManager.ts

@@ -25,7 +25,7 @@ import type {
 import { DeviceModelToTypes } from '../types';
 import { findLatestRelease, getReleaseChangelog, getReleaseStatus } from '../utils/release';
 
-export type IFirmwareField = 'firmware' | 'firmware-v2' | 'firmware-v6';
+export type IFirmwareField = 'firmware' | 'firmware-v2' | 'firmware-v7';
 
 export type MessageVersion = 'latest' | 'v1';
 

package/src/inject.ts

@@ -2,8 +2,9 @@ import { EventEmitter } from 'events';
 import { CallMethod } from './events';
 import { CoreApi } from './types/api';
 import type { AllNetworkAddress } from './types/api/allNetworkGetAddress';
+import { Unsuccessful } from './types';
 
-type CallbackFunction = (data?: any, error?: { message: string; code?: number }) => void;
+type CallbackFunction = (data?: any, error?: Unsuccessful) => void;
 
 const callbackManager = new Map<string, CallbackFunction>();
 
@@ -179,8 +180,8 @@ export const createCoreApi = (
     registerCallback(callbackId, onLoopItemResponse);
 
     const callbackIdFinish = generateCallbackId();
-    registerCallback(callbackIdFinish, (data?: AllNetworkAddress[]) => {
-      onAllItemsResponse?.(data);
+    registerCallback(callbackIdFinish, (data?: AllNetworkAddress[], error?: Unsuccessful) => {
+      onAllItemsResponse?.(data, error);
       cleanupCallback(callbackIdFinish);
       cleanupCallback(callbackId);
     });

package/src/types/api/evmSignTransaction.ts

@@ -37,37 +37,9 @@ export type EVMTransactionEIP1559 = {
   accessList?: EVMAccessList[];
 };
 
-export type EVMAuthorizationSignature = {
-  yParity: number;
-  r: string;
-  s: string;
-};
-
-export type EVMAuthorization = {
-  addressN?: number[];
-  chainId: number;
-  address: string;
-  nonce: string;
-  signature?: EVMAuthorizationSignature;
-};
-
-export type EVMTransactionEIP7702 = {
-  to: string;
-  value: string;
-  gasLimit: string;
-  gasPrice?: typeof undefined;
-  nonce: string;
-  data?: string;
-  chainId: number;
-  maxFeePerGas: string;
-  maxPriorityFeePerGas: string;
-  accessList?: EVMAccessList[];
-  authorizationList: EVMAuthorization[];
-};
-
 export type EVMSignTransactionParams = {
   path: string | number[];
-  transaction: EVMTransaction | EVMTransactionEIP1559 | EVMTransactionEIP7702;
+  transaction: EVMTransaction | EVMTransactionEIP1559;
 };
 
 export declare function evmSignTransaction(

package/src/types/settings.ts

@@ -78,7 +78,7 @@ export type DeviceTypeMap = {
   [k in IKnownDevice]: {
     firmware: IFirmwareReleaseInfo[];
     'firmware-v2'?: IFirmwareReleaseInfo[];
-    'firmware-v6'?: IFirmwareReleaseInfo[];
+    'firmware-v7'?: IFirmwareReleaseInfo[];
     ble: IBLEFirmwareReleaseInfo[];
   };
 };

package/src/utils/deviceFeaturesUtils.ts

@@ -240,21 +240,21 @@ export const getFirmwareUpdateField = ({
   }
 
   if (DeviceModelToTypes.model_mini.includes(deviceType)) {
-    return 'firmware-v6';
+    return 'firmware-v7';
   }
 
   if (deviceType === EDeviceType.Touch) {
     if (targetVersion) {
       if (semver.eq(targetVersion, '4.0.0')) return 'firmware-v2';
-      if (semver.gt(targetVersion, '4.0.0')) return 'firmware-v6';
+      if (semver.gt(targetVersion, '4.0.0')) return 'firmware-v7';
     }
 
     if (semver.lt(deviceFirmwareVersion.join('.'), '3.4.0')) return 'firmware';
 
-    return 'firmware-v6';
+    return 'firmware-v7';
   }
   if (deviceType === EDeviceType.Pro) {
-    return 'firmware-v6';
+    return 'firmware-v7';
   }
   return 'firmware';
 };
@@ -266,7 +266,7 @@ export const getFirmwareUpdateField = ({
 export const getFirmwareUpdateFieldArray = (
   features: Features,
   updateType: 'firmware' | 'ble' | 'bootloader'
-): ('firmware' | 'ble' | 'firmware-v2' | 'firmware-v6')[] => {
+): ('firmware' | 'ble' | 'firmware-v2' | 'firmware-v7')[] => {
   const deviceType = getDeviceType(features);
   if (updateType === 'ble') {
     return ['ble'];
@@ -278,25 +278,25 @@ export const getFirmwareUpdateFieldArray = (
     deviceType === 'mini' ||
     deviceType === 'classicpure'
   ) {
-    return ['firmware-v6'];
+    return ['firmware-v7'];
   }
 
   if (deviceType === 'touch') {
     const currentVersion = getDeviceFirmwareVersion(features).join('.');
     if (semver.gt(currentVersion, '4.0.0')) {
-      return ['firmware-v6', 'firmware'];
+      return ['firmware-v7', 'firmware'];
     }
     if (semver.gte(currentVersion, '4.0.0')) {
       return ['firmware-v2', 'firmware'];
     }
     if (!currentVersion || semver.lt(currentVersion, '3.0.0')) {
-      return ['firmware-v6', 'firmware-v2', 'firmware'];
+      return ['firmware-v7', 'firmware-v2', 'firmware'];
     }
     return ['firmware'];
   }
 
   if (deviceType === 'pro') {
-    return ['firmware-v6'];
+    return ['firmware-v7'];
   }
 
   return ['firmware'];

package/__tests__/evmSignTransactionEIP7702.test.ts

@@ -1,216 +0,0 @@
-import { EVMTransactionEIP7702, EVMAuthorization, EVMAuthorizationSignature } from '../src/types';
-
-describe('EVM EIP-7702 Transaction Types', () => {
-  test('should create valid EIP7702 transaction type', () => {
-    const authSignature: EVMAuthorizationSignature = {
-      yParity: 0,
-      r: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
-      s: '0xfedcba0987654321fedcba0987654321fedcba0987654321fedcba0987654321',
-    };
-
-    const authorization: EVMAuthorization = {
-      chainId: 1,
-      address: '0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb',
-      nonce: '0x0',
-      signature: authSignature,
-    };
-
-    const transaction: EVMTransactionEIP7702 = {
-      to: '0x7314e0f1c0e28474bdb6be3e2c3e0453255188f8',
-      value: '0xf4240',
-      gasLimit: '0x5208',
-      nonce: '0x0',
-      data: '0x',
-      chainId: 1,
-      maxFeePerGas: '0xbebc200',
-      maxPriorityFeePerGas: '0x9502f900',
-      accessList: [],
-      authorizationList: [authorization],
-    };
-
-    expect(transaction.authorizationList).toHaveLength(1);
-    expect(transaction.authorizationList[0].chainId).toBe(1);
-    expect(transaction.authorizationList[0].address).toBe('0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb');
-    expect(transaction.authorizationList[0].signature?.yParity).toBe(0);
-  });
-
-  test('should create EIP7702 transaction with multiple authorizations', () => {
-    const auth1: EVMAuthorization = {
-      chainId: 1,
-      address: '0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb',
-      nonce: '0x0',
-      signature: {
-        yParity: 0,
-        r: '0x1111111111111111111111111111111111111111111111111111111111111111',
-        s: '0x2222222222222222222222222222222222222222222222222222222222222222',
-      },
-    };
-
-    const auth2: EVMAuthorization = {
-      chainId: 1,
-      address: '0x7DAF91DFe55FcAb363416A6E3bceb3Da34ff1d30',
-      nonce: '0x1',
-      signature: {
-        yParity: 1,
-        r: '0x3333333333333333333333333333333333333333333333333333333333333333',
-        s: '0x4444444444444444444444444444444444444444444444444444444444444444',
-      },
-    };
-
-    const transaction: EVMTransactionEIP7702 = {
-      to: '0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb',
-      value: '0x0',
-      gasLimit: '0x7530',
-      nonce: '0x1',
-      data: '0x8129fc1c', // initialize() function selector
-      chainId: 1,
-      maxFeePerGas: '0xbebc200',
-      maxPriorityFeePerGas: '0x9502f900',
-      accessList: [
-        {
-          address: '0xA0b86a33E6417c8f2c8B758B2d7D2E0C0C2E8E8E',
-          storageKeys: ['0x0000000000000000000000000000000000000000000000000000000000000001'],
-        },
-      ],
-      authorizationList: [auth1, auth2],
-    };
-
-    expect(transaction.authorizationList).toHaveLength(2);
-    expect(transaction.authorizationList[0].address).toBe('0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb');
-    expect(transaction.authorizationList[1].address).toBe('0x7DAF91DFe55FcAb363416A6E3bceb3Da34ff1d30');
-    expect(transaction.accessList).toHaveLength(1);
-  });
-
-  test('should create EIP7702 transaction without signature (for delegation setup)', () => {
-    const authorization: EVMAuthorization = {
-      addressN: [44, 60, 0, 0, 0], // m/44'/60'/0'/0/0
-      chainId: 1,
-      address: '0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb',
-      nonce: '0x0',
-      // No signature - will be provided by hardware wallet
-    };
-
-    const transaction: EVMTransactionEIP7702 = {
-      to: '0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb',
-      value: '0x0',
-      gasLimit: '0x5208',
-      nonce: '0x0',
-      data: '0x8129fc1c',
-      chainId: 1,
-      maxFeePerGas: '0xbebc200',
-      maxPriorityFeePerGas: '0x9502f900',
-      accessList: [],
-      authorizationList: [authorization],
-    };
-
-    expect(transaction.authorizationList[0].addressN).toEqual([44, 60, 0, 0, 0]);
-    expect(transaction.authorizationList[0].signature).toBeUndefined();
-  });
-
-  test('should validate required EIP7702 fields', () => {
-    const transaction: EVMTransactionEIP7702 = {
-      to: '0x7314e0f1c0e28474bdb6be3e2c3e0453255188f8',
-      value: '0xf4240',
-      gasLimit: '0x5208',
-      nonce: '0x0',
-      chainId: 1,
-      maxFeePerGas: '0xbebc200',
-      maxPriorityFeePerGas: '0x9502f900',
-      authorizationList: [
-        {
-          chainId: 1,
-          address: '0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb',
-          nonce: '0x0',
-        },
-      ],
-    };
-
-    // Verify required fields are present
-    expect(transaction.to).toBeDefined();
-    expect(transaction.value).toBeDefined();
-    expect(transaction.gasLimit).toBeDefined();
-    expect(transaction.nonce).toBeDefined();
-    expect(transaction.chainId).toBeDefined();
-    expect(transaction.maxFeePerGas).toBeDefined();
-    expect(transaction.maxPriorityFeePerGas).toBeDefined();
-    expect(transaction.authorizationList).toBeDefined();
-    expect(transaction.authorizationList).toHaveLength(1);
-
-    // Verify EIP-1559 fields are used (not gasPrice)
-    expect(transaction.gasPrice).toBeUndefined();
-  });
-
-  test('should handle empty authorization list validation', () => {
-    // This should be caught by validation in the actual implementation
-    const createInvalidTransaction = () => {
-      const transaction: EVMTransactionEIP7702 = {
-        to: '0x7314e0f1c0e28474bdb6be3e2c3e0453255188f8',
-        value: '0xf4240',
-        gasLimit: '0x5208',
-        nonce: '0x0',
-        chainId: 1,
-        maxFeePerGas: '0xbebc200',
-        maxPriorityFeePerGas: '0x9502f900',
-        authorizationList: [], // Empty authorization list
-      };
-      return transaction;
-    };
-
-    const invalidTx = createInvalidTransaction();
-    expect(invalidTx.authorizationList).toHaveLength(0);
-    // In actual implementation, this should be validated and throw an error
-  });
-});
-
-describe('EVM EIP-7702 Authorization Types', () => {
-  test('should create authorization with all fields', () => {
-    const authorization: EVMAuthorization = {
-      addressN: [44, 60, 0, 0, 0],
-      chainId: 1,
-      address: '0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb',
-      nonce: '0x0',
-      signature: {
-        yParity: 0,
-        r: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
-        s: '0xfedcba0987654321fedcba0987654321fedcba0987654321fedcba0987654321',
-      },
-    };
-
-    expect(authorization.addressN).toEqual([44, 60, 0, 0, 0]);
-    expect(authorization.chainId).toBe(1);
-    expect(authorization.address).toBe('0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb');
-    expect(authorization.nonce).toBe('0x0');
-    expect(authorization.signature?.yParity).toBe(0);
-    expect(authorization.signature?.r).toMatch(/^0x[0-9a-f]{64}$/i);
-    expect(authorization.signature?.s).toMatch(/^0x[0-9a-f]{64}$/i);
-  });
-
-  test('should create authorization without addressN (external signature)', () => {
-    const authorization: EVMAuthorization = {
-      chainId: 1,
-      address: '0x80296FF8D1ED46f8e3C7992664D13B833504c2Bb',
-      nonce: '0x0',
-      signature: {
-        yParity: 1,
-        r: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
-        s: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
-      },
-    };
-
-    expect(authorization.addressN).toBeUndefined();
-    expect(authorization.signature).toBeDefined();
-  });
-
-  test('should validate authorization signature format', () => {
-    const signature: EVMAuthorizationSignature = {
-      yParity: 0,
-      r: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
-      s: '0xfedcba0987654321fedcba0987654321fedcba0987654321fedcba0987654321',
-    };
-
-    expect(signature.yParity).toBeGreaterThanOrEqual(0);
-    expect(signature.yParity).toBeLessThanOrEqual(1);
-    expect(signature.r).toMatch(/^0x[0-9a-f]{64}$/i);
-    expect(signature.s).toMatch(/^0x[0-9a-f]{64}$/i);
-  });
-});