@onekeyfe/hd-core 1.1.10-alpha.2 → 1.1.10-alpha.4

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

@@ -1,14 +1,20 @@
 import {
   EthereumSignTx,
   EthereumSignTxEIP1559,
+  EthereumSignTxEIP7702OneKey,
   EthereumTxRequestOneKey,
   MessageResponse,
   TypedCall,
 } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { EVMSignedTx, EVMTransaction, EVMTransactionEIP1559 } from '../../../types';
+import {
+  EVMSignedTx,
+  EVMTransaction,
+  EVMTransactionEIP1559,
+  EVMTransactionEIP7702,
+} from '../../../types';
 import { cutString } from '../../helpers/stringUtils';
-import { stripHexStartZeroes } from '../../helpers/hexUtils';
+import { stripHexStartZeroes, addHexPrefix } from '../../helpers/hexUtils';
 
 export const processTxRequest = async ({
   typedCall,
@@ -27,6 +33,7 @@ export const processTxRequest = async ({
     let v = request.signature_v;
     const r = request.signature_r;
     const s = request.signature_s;
+    const authorizationSignatures = request.authorization_signatures;
 
     if (v == null || r == null || s == null) {
       throw ERRORS.TypedError(
@@ -40,11 +47,22 @@ export const processTxRequest = async ({
       v += 2 * chainId + 35;
     }
 
-    return Promise.resolve({
+    const result: any = {
       v: `0x${v.toString(16)}`,
       r: `0x${r}`,
       s: `0x${s}`,
-    });
+    };
+
+    // Add authorization signatures for EIP7702 transactions
+    if (authorizationSignatures && authorizationSignatures.length > 0) {
+      result.authorizationSignatures = authorizationSignatures.map(sig => ({
+        yParity: sig.y_parity,
+        r: sig.r,
+        s: sig.s,
+      }));
+    }
+
+    return Promise.resolve(result);
   }
 
   const [first, rest] = cutString(data, request.data_length * 2);
@@ -180,17 +198,93 @@ 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: addHexPrefix(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;
+  tx: EVMTransaction | EVMTransactionEIP1559 | EVMTransactionEIP7702;
   isEIP1559: boolean;
+  isEIP7702?: boolean;
   typedCall: TypedCall;
-}) =>
-  isEIP1559
+}) => {
+  if (isEIP7702) {
+    return evmSignTxEip7702({ typedCall, addressN, tx: tx as EVMTransactionEIP7702 });
+  }
+  return isEIP1559
     ? evmSignTxEip1559({ typedCall, addressN, tx: tx as EVMTransactionEIP1559 })
     : evmSignTx({ typedCall, addressN, tx: tx as EVMTransaction });
+};

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

@@ -1,23 +1,36 @@
 import { TypedCall } from '@onekeyfe/hd-transport';
-import { EVMTransaction, EVMTransactionEIP1559 } from '../../../types';
-import { evmSignTx, evmSignTxEip1559 } from '../latest/signTransaction';
+import { EVMTransaction, EVMTransactionEIP1559, EVMTransactionEIP7702 } from '../../../types';
+import { evmSignTx, evmSignTxEip1559, evmSignTxEip7702 } from '../latest/signTransaction';
 
 export const signTransaction = async ({
   typedCall,
   isEIP1559,
+  isEIP7702,
   addressN,
   tx,
 }: {
   addressN: number[];
-  tx: EVMTransaction | EVMTransactionEIP1559;
+  tx: EVMTransaction | EVMTransactionEIP1559 | EVMTransactionEIP7702;
   isEIP1559: boolean;
+  isEIP7702: boolean;
   typedCall: TypedCall;
-}) =>
-  isEIP1559
-    ? evmSignTxEip1559({
-        typedCall,
-        addressN,
-        tx: tx as EVMTransactionEIP1559,
-        supportTrezor: true,
-      })
-    : evmSignTx({ typedCall, addressN, tx: tx as EVMTransaction, supportTrezor: true });
+}) => {
+  if (isEIP7702) {
+    return evmSignTxEip7702({
+      typedCall,
+      addressN,
+      tx: tx as EVMTransactionEIP7702,
+      supportTrezor: true,
+    });
+  }
+  if (isEIP1559) {
+    return evmSignTxEip1559({
+      typedCall,
+      addressN,
+      tx: tx as EVMTransactionEIP1559,
+      supportTrezor: true,
+    });
+  }
+
+  return evmSignTx({ typedCall, addressN, tx: tx as EVMTransaction, supportTrezor: true });
+};

package/src/api/index.ts

@@ -91,6 +91,7 @@ export { default as aptosGetAddress } from './aptos/AptosGetAddress';
 export { default as aptosGetPublicKey } from './aptos/AptosGetPublicKey';
 export { default as aptosSignTransaction } from './aptos/AptosSignTransaction';
 export { default as aptosSignMessage } from './aptos/AptosSignMessage';
+export { default as aptosSignInMessage } from './aptos/AptosSignInMessage';
 
 export { default as algoGetAddress } from './algo/AlgoGetAddress';
 export { default as algoSignTransaction } from './algo/AlgoSignTransaction';

package/src/api/tron/TronSignMessage.ts

@@ -1,4 +1,8 @@
-import { TronSignMessage as HardwareTronSignMessage } from '@onekeyfe/hd-transport';
+import {
+  TronSignMessage as HardwareTronSignMessage,
+  TronMessageType,
+} from '@onekeyfe/hd-transport';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
@@ -14,15 +18,26 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
     validateParams(this.payload, [
       { name: 'path', required: true },
       { name: 'messageHex', type: 'hexString', required: true },
+      { name: 'messageType', type: 'string' },
     ]);
 
     const { path, messageHex } = this.payload;
     const addressN = validatePath(path, 3);
 
+    if (this.payload.messageType === 'V1' || this.payload.messageType == null) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceNotSupportMethod,
+        'not support tron message v1'
+      );
+    }
+
+    const messageType = TronMessageType.V2;
+
     // init params
     this.params = {
       address_n: addressN,
       message: stripHexPrefix(messageHex),
+      message_type: messageType,
     };
   }
 
@@ -34,7 +49,23 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
     };
   }
 
+  getMessageV2VersionRange() {
+    return {
+      pro: {
+        min: '4.16.0',
+      },
+    };
+  }
+
   async run() {
+    this.checkFeatureVersionLimit(
+      () => this.params.message_type === TronMessageType.V2,
+      () => this.getMessageV2VersionRange(),
+      {
+        strictCheckDeviceSupport: true,
+      }
+    );
+
     const response = await this.device.commands.typedCall(
       'TronSignMessage',
       'TronMessageSignature',

package/src/data/messages/messages.json

@@ -341,6 +341,23 @@
         }
       }
     },
+    "AptosSignSIWAMessage": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "siwa_payload": {
+          "rule": "required",
+          "type": "string",
+          "id": 2
+        }
+      }
+    },
     "BenfenGetAddress": {
       "fields": {
         "address_n": {
@@ -5241,6 +5258,20 @@
         }
       }
     },
+    "EthereumAccessListOneKey": {
+      "fields": {
+        "address": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        },
+        "storage_keys": {
+          "rule": "repeated",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
     "EthereumSignTxEIP1559OneKey": {
       "fields": {
         "address_n": {
@@ -5305,19 +5336,124 @@
           "type": "EthereumAccessListOneKey",
           "id": 11
         }
+      }
+    },
+    "EthereumAuthorizationSignature": {
+      "fields": {
+        "y_parity": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        },
+        "r": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        },
+        "s": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 3
+        }
+      }
+    },
+    "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
+        }
       },
       "nested": {
-        "EthereumAccessListOneKey": {
+        "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": 1
+              "id": 3
             },
-            "storage_keys": {
-              "rule": "repeated",
+            "nonce": {
+              "rule": "required",
               "type": "bytes",
-              "id": 2
+              "id": 4
+            },
+            "signature": {
+              "type": "EthereumAuthorizationSignature",
+              "id": 5
             }
           }
         }
@@ -5340,6 +5476,11 @@
         "signature_s": {
           "type": "bytes",
           "id": 4
+        },
+        "authorization_signatures": {
+          "rule": "repeated",
+          "type": "EthereumAuthorizationSignature",
+          "id": 10
         }
       }
     },
@@ -11581,6 +11722,12 @@
         }
       }
     },
+    "TronMessageType": {
+      "values": {
+        "V1": 1,
+        "V2": 2
+      }
+    },
     "TronSignMessage": {
       "fields": {
         "address_n": {
@@ -11595,6 +11742,13 @@
           "rule": "required",
           "type": "bytes",
           "id": 2
+        },
+        "message_type": {
+          "type": "TronMessageType",
+          "id": 3,
+          "options": {
+            "default": "V1"
+          }
         }
       }
     },
@@ -11914,6 +12068,7 @@
         "MessageType_EthereumSignTypedHashOneKey": 20117,
         "MessageType_EthereumGnosisSafeTxAck": 20118,
         "MessageType_EthereumGnosisSafeTxRequest": 20119,
+        "MessageType_EthereumSignTxEIP7702OneKey": 20120,
         "MessageType_NEMGetAddress": 67,
         "MessageType_NEMAddress": 68,
         "MessageType_NEMSignTx": 69,
@@ -12055,6 +12210,7 @@
         "MessageType_AptosSignedTx": 10603,
         "MessageType_AptosSignMessage": 10604,
         "MessageType_AptosMessageSignature": 10605,
+        "MessageType_AptosSignSIWAMessage": 10606,
         "MessageType_WebAuthnListResidentCredentials": 800,
         "MessageType_WebAuthnCredentials": 801,
         "MessageType_WebAuthnAddResidentCredential": 802,

package/src/inject.ts

@@ -288,6 +288,8 @@ export const createCoreApi = (
     call({ ...params, connectId, deviceId, method: 'aptosGetPublicKey' }),
   aptosSignMessage: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'aptosSignMessage' }),
+  aptosSignInMessage: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'aptosSignInMessage' }),
   aptosSignTransaction: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'aptosSignTransaction' }),
 

package/src/types/api/aptosSignInMessage.ts

@@ -0,0 +1,17 @@
+import { AptosMessageSignature as HardwareAptosMessageSignature } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type AptosSignInMessageSignature = {
+  path: string;
+} & HardwareAptosMessageSignature;
+
+export type AptosSignInMessageParams = {
+  path: string | number[];
+  payload: string;
+};
+
+export declare function aptosSignInMessage(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & AptosSignInMessageParams
+): Response<AptosSignInMessageSignature>;

package/src/types/api/evmSignTransaction.ts

@@ -4,6 +4,7 @@ export type EVMSignedTx = {
   v: string;
   r: string;
   s: string;
+  authorizationSignatures?: EVMAuthorizationSignature[];
 };
 
 export type EVMTransaction = {
@@ -37,9 +38,37 @@ 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;
+  transaction: EVMTransaction | EVMTransactionEIP1559 | EVMTransactionEIP7702;
 };
 
 export declare function evmSignTransaction(

package/src/types/api/export.ts

@@ -36,6 +36,9 @@ export type { EVMSignMessageEIP712Params } from './evmSignMessageEIP712';
 export type {
   EVMTransaction,
   EVMTransactionEIP1559,
+  EVMTransactionEIP7702,
+  EVMAuthorization,
+  EVMAuthorizationSignature,
   EVMSignedTx,
   EVMSignTransactionParams,
   EVMAccessList,
@@ -115,6 +118,7 @@ export type { NearSignTransactionParams } from './nearSignTransaction';
 export type { AptosAddress, AptosGetAddressParams } from './aptosGetAddress';
 export type { AptosPublicKey, AptosGetPublicKeyParams } from './aptosGetPublicKey';
 export type { AptosMessageSignature, AptosSignMessageParams } from './aptosSignMessage';
+export type { AptosSignInMessageSignature, AptosSignInMessageParams } from './aptosSignInMessage';
 export type { AptosSignedTx, AptosSignTransactionParams } from './aptosSignTransaction';
 
 export type { AlgoAddress, AlgoGetAddressParams } from './algoGetAddress';
@@ -134,6 +138,10 @@ export type {
   CardanoAddress,
   CardanoGetAddressParams,
 } from './cardanoGetAddress';
+export type {
+  CardanoSignMessageMethodParams,
+  CardanoSignMessageParams,
+} from './cardanoSignMessage';
 export type { CardanoSignTransaction, CardanoSignedTxData } from './cardano';
 
 export type { FilecoinAddress, FilecoinGetAddressParams } from './filecoinGetAddress';

package/src/types/api/index.ts

@@ -92,6 +92,7 @@ import { nearSignTransaction } from './nearSignTransaction';
 import { aptosGetAddress } from './aptosGetAddress';
 import { aptosGetPublicKey } from './aptosGetPublicKey';
 import { aptosSignMessage } from './aptosSignMessage';
+import { aptosSignInMessage } from './aptosSignInMessage';
 import { aptosSignTransaction } from './aptosSignTransaction';
 
 import { algoGetAddress } from './algoGetAddress';
@@ -309,6 +310,7 @@ export type CoreApi = {
   aptosGetAddress: typeof aptosGetAddress;
   aptosGetPublicKey: typeof aptosGetPublicKey;
   aptosSignMessage: typeof aptosSignMessage;
+  aptosSignInMessage: typeof aptosSignInMessage;
   aptosSignTransaction: typeof aptosSignTransaction;
 
   /**

package/src/types/api/tronSignMessage.ts

@@ -4,6 +4,7 @@ import type { CommonParams, Response } from '../params';
 export type TronSignMessageParams = {
   path: string | number[];
   messageHex: string;
+  messageType?: 'V1' | 'V2';
 };
 
 export declare function tronSignMessage(