Integrate the EIP 7702 authorization signature into the message signature framework (trustwallet#4365)

* Integrate the EIP 7702 authorization signature into the message signature framework

* Adjust the code according to the comments

---------

Co-authored-by: Sergei Boiko <[email protected]>

Author: 10gic

rust/tw_evm/src/message/eip7702_authorization.rs

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::message::{EthMessage, MessageSigningErrorKind, MessageSigningResult};
+use crate::rlp::list::RlpList;
+use crate::transaction::authorization_list::Authorization;
+use std::iter;
+use std::str::FromStr;
+use tw_hash::sha3::keccak256;
+use tw_hash::H256;
+
+pub const EIP_7702_MAGIC_PREFIX: u8 = 0x05;
+
+impl FromStr for Authorization {
+    type Err = MessageSigningErrorKind;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        serde_json::from_str(s).map_err(|_| MessageSigningErrorKind::TypeValueMismatch)
+    }
+}
+
+impl EthMessage for Authorization {
+    fn hash(&self) -> MessageSigningResult<H256> {
+        let mut list = RlpList::new();
+        list.append(&self.chain_id)
+            .append(&self.address)
+            .append(&self.nonce);
+
+        let to_hash: Vec<_> = iter::once(EIP_7702_MAGIC_PREFIX)
+            .chain(list.finish())
+            .collect();
+
+        let hash_data = keccak256(&to_hash);
+        Ok(H256::try_from(hash_data.as_slice()).expect("Expected 32-byte hash"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::address::Address;
+    use std::str::FromStr;
+    use tw_encoding::hex::ToHex;
+    use tw_keypair::ecdsa::secp256k1;
+    use tw_keypair::traits::SigningKeyTrait;
+    use tw_number::U256;
+
+    #[test]
+    fn test_pre_hash() {
+        let authorization = Authorization {
+            chain_id: U256::from(1_u32),
+            address: Address::from_str("0xB91aaa96B138A1B1D94c9df4628187132c5F2bf1").unwrap(),
+            nonce: U256::from(1_u32),
+        };
+        assert_eq!(
+            Authorization::hash(&authorization).unwrap().to_hex(),
+            "3ae543b2fa103a39a6985d964a67caed05f6b9bb2430ad6d498cda743fe911d9"
+        );
+    }
+
+    #[test]
+    fn test_sign_authorization() {
+        let authorization = Authorization {
+            chain_id: U256::from(1_u32),
+            address: Address::from_str("0xB91aaa96B138A1B1D94c9df4628187132c5F2bf1").unwrap(),
+            nonce: U256::from(1_u32),
+        };
+        let private_key = secp256k1::PrivateKey::try_from(
+            "0x947dd69af402e7f48da1b845dfc1df6be593d01a0d8274bd03ec56712e7164e8",
+        )
+        .unwrap();
+        let pre_hash = authorization.hash().unwrap();
+        let signature = private_key.sign(pre_hash).unwrap();
+
+        assert_eq!(
+            signature.r().to_hex(),
+            "2c39f2f64441dd38c364ee175dc6b9a87f34ca330bce968f6c8e22811e3bb710"
+        );
+        assert_eq!(
+            signature.s().to_hex(),
+            "5f1bcde93dee4b214e60bc0e63babcc13e4fecb8a23c4098fd89844762aa012c"
+        );
+        assert_eq!(signature.v(), 1);
+    }
+}

rust/tw_evm/src/message/mod.rs

@@ -7,6 +7,7 @@ use tw_hash::H256;
 
 pub mod eip191;
 pub mod eip712;
+pub mod eip7702_authorization;
 pub mod signature;
 
 pub type EthMessageBoxed = Box<dyn EthMessage>;

rust/tw_evm/src/modules/authorization_signer.rs

@@ -6,6 +6,7 @@ use crate::message::eip191::Eip191Message;
 use crate::message::eip712::eip712_message::Eip712Message;
 use crate::message::signature::{MessageSignature, SignatureType};
 use crate::message::{to_signing, EthMessage, EthMessageBoxed};
+use crate::transaction::authorization_list::Authorization;
 use std::borrow::Cow;
 use std::str::FromStr;
 use tw_coin_entry::coin_context::CoinContext;
@@ -123,13 +124,23 @@ impl EthMessageSigner {
                     .map_err(to_signing)?
                     .into_boxed()),
             },
+            Proto::MessageType::MessageType_eip7702_authorization => {
+                Ok(Authorization::from_str(&input.message)
+                    .map_err(|e| to_signing(e.into()))?
+                    .into_boxed())
+            },
         }
     }
 
     fn message_from_str(user_message: &str) -> SigningResult<EthMessageBoxed> {
         match Eip712Message::new(user_message) {
+            // Try to parse as an EIP712 message
             Ok(typed_data) => Ok(typed_data.into_boxed()),
-            Err(_) => Ok(Eip191Message::new(user_message).into_boxed()),
+            Err(_) => match Authorization::from_str(user_message) {
+                // Try to parse as an EIP7702 authorization tuple
+                Ok(authorization) => Ok(authorization.into_boxed()),
+                Err(_) => Ok(Eip191Message::new(user_message).into_boxed()),
+            },
         }
     }
 
@@ -138,7 +149,8 @@ impl EthMessageSigner {
         maybe_chain_id: Option<Proto::MaybeChainId>,
     ) -> SignatureType {
         match msg_type {
-            Proto::MessageType::MessageType_immutable_x => SignatureType::Standard,
+            Proto::MessageType::MessageType_immutable_x
+            | Proto::MessageType::MessageType_eip7702_authorization => SignatureType::Standard,
             Proto::MessageType::MessageType_legacy | Proto::MessageType::MessageType_typed => {
                 SignatureType::Legacy
             },

rust/tw_evm/src/modules/message_signer.rs

@@ -3,7 +3,6 @@
 // Copyright © 2017 Trust Wallet.
 
 pub mod abi_encoder;
-pub mod authorization_signer;
 pub mod compiler;
 pub mod message_signer;
 pub mod rlp_encoder;

rust/tw_evm/src/modules/mod.rs

@@ -11,7 +11,7 @@ use crate::abi::prebuild::erc721::Erc721;
 use crate::abi::prebuild::ExecuteArgs;
 use crate::address::{Address, EvmAddress};
 use crate::evm_context::EvmContext;
-use crate::modules::authorization_signer::AuthorizationSigner;
+use crate::message::{to_signing, EthMessage};
 use crate::transaction::access_list::{Access, AccessList};
 use crate::transaction::authorization_list::{
     Authorization, AuthorizationList, SignedAuthorization,
@@ -29,6 +29,7 @@ use tw_encoding::hex::DecodeHex;
 use tw_hash::H256;
 use tw_keypair::ecdsa::secp256k1;
 use tw_keypair::ecdsa::secp256k1::Signature;
+use tw_keypair::traits::SigningKeyTrait;
 use tw_keypair::KeyPairError;
 use tw_memory::Data;
 use tw_number::U256;
@@ -657,7 +658,7 @@ impl<Context: EvmContext> TxBuilder<Context> {
             .into_tw()
             .context("Invalid authority address")?;
 
-        let signed_authorization =
+        let (authorization, signature) =
             if let Some(other_auth_fields) = &eip7702_authorization.custom_signature {
                 // If field `custom_signature` is provided, it means that the authorization is already signed.
                 let chain_id = U256::from_big_endian_slice(&other_auth_fields.chain_id)
@@ -676,16 +677,14 @@ impl<Context: EvmContext> TxBuilder<Context> {
                 .tw_err(SigningErrorType::Error_invalid_params)
                 .context("Invalid signature")?;
 
-                SignedAuthorization {
-                    authorization: Authorization {
+                (
+                    Authorization {
                         chain_id,
                         address,
                         nonce,
                     },
-                    y_parity: signature.v(),
-                    r: U256::from_big_endian(signature.r()),
-                    s: U256::from_big_endian(signature.s()),
-                }
+                    signature,
+                )
             } else {
                 // If field `custom_signature` is not provided, the authorization will be signed with the provided private key, nonce and chainId
                 let signer_key = secp256k1::PrivateKey::try_from(input.private_key.as_ref())
@@ -707,17 +706,26 @@ impl<Context: EvmContext> TxBuilder<Context> {
                     .into_tw()
                     .context("Invalid nonce")?;
 
-                AuthorizationSigner::sign(
-                    &signer_key,
-                    Authorization {
-                        chain_id,
-                        address,
-                        // `authorization.nonce` must be incremented by 1 over `transaction.nonce`.
-                        nonce: nonce + 1,
-                    },
-                )?
+                let authorization = Authorization {
+                    chain_id,
+                    address,
+                    // `authorization.nonce` must be incremented by 1 over `transaction.nonce`.
+                    nonce: nonce + 1,
+                };
+
+                let pre_hash = authorization.hash().map_err(to_signing)?;
+                let signature = signer_key.sign(pre_hash)?;
+
+                (authorization, signature)
             };
 
+        let signed_authorization = SignedAuthorization {
+            authorization,
+            y_parity: signature.v(),
+            r: U256::from_big_endian(signature.r()),
+            s: U256::from_big_endian(signature.s()),
+        };
+
         Ok(AuthorizationList::from(vec![signed_authorization]))
     }
 }

rust/tw_evm/src/modules/tx_builder.rs

@@ -5,15 +5,20 @@
 use crate::address::Address;
 use crate::rlp::buffer::RlpBuffer;
 use crate::rlp::RlpEncode;
+use serde::Deserialize;
 use tw_number::U256;
 
 /// Authorization for 7702 txn support.
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct Authorization {
     /// The chain ID of the authorization.
+    #[serde(deserialize_with = "U256::from_hex_or_decimal_str")]
     pub chain_id: U256,
     /// The address of the authorization.
     pub address: Address,
     /// The nonce for the authorization.
+    #[serde(deserialize_with = "U256::from_hex_or_decimal_str")]
     pub nonce: U256,
 }
 

rust/tw_evm/src/transaction/authorization_list.rs

@@ -0,0 +1,5 @@
+{
+  "chainId": "0x310c5",
+  "address": "0x3535353535353535353535353535353535353535",
+  "nonce": "0xabc"
+}

rust/tw_evm/tests/data/eip7702_authorization.json

@@ -0,0 +1,5 @@
+{
+  "chainId": "200901",
+  "address": "0x3535353535353535353535353535353535353535",
+  "nonce": "2748"
+}

rust/tw_evm/tests/data/eip7702_authorization_decimal_string.json

@@ -20,6 +20,9 @@ const EIP712_GREENFIELD: &str = include_str!("data/eip712_greenfield.json");
 const EIP712_FIXED_BYTES: &str = include_str!("data/eip712_fixed_bytes.json");
 const EIP712_LONG_BYTES: &str = include_str!("data/eip712_long_bytes.json");
 const EIP712_DIFFERENT_BYTES: &str = include_str!("data/eip712_different_bytes.json");
+const EIP7702_AUTHORIZATION: &str = include_str!("data/eip7702_authorization.json");
+const EIP7702_AUTHORIZATION_DECIMAL_STRING: &str =
+    include_str!("data/eip7702_authorization_decimal_string.json");
 
 struct SignVerifyTestInput {
     private_key: &'static str,
@@ -312,3 +315,25 @@ fn test_message_signer_sign_verify_eip712_different_bytes() {
         signature: "48dc667cd8a53beb58ea6b1745f98c21b12e1a57587ce28bae07689dba3600d40cef2685dc8a68028d38f3e63289891868ecdf05e8affc275fee3001e51d6c581c",
     });
 }
+
+#[test]
+fn test_message_signer_sign_eip7702_authorization() {
+    test_message_signer_sign_verify(SignVerifyTestInput {
+        private_key: "6f96f3aa7e8052170f1864f72a9a53606ee9c0d185188266cab895512a4bcf84",
+        msg: EIP7702_AUTHORIZATION,
+        msg_type: Proto::MessageType::MessageType_eip7702_authorization,
+        chain_id: None,
+        signature: "a2c790e864ff524e703c6a476609e0b738cdcd3a96628be0ef74cb5610a29a473908f07f762f4da896e7f8d3cdaad567c58aa81412ac6dd864eb5d3956a1f04c00",
+    });
+}
+
+#[test]
+fn test_message_signer_sign_eip7702_authorization_decimal_string() {
+    test_message_signer_sign_verify(SignVerifyTestInput {
+        private_key: "6f96f3aa7e8052170f1864f72a9a53606ee9c0d185188266cab895512a4bcf84",
+        msg: EIP7702_AUTHORIZATION_DECIMAL_STRING,
+        msg_type: Proto::MessageType::MessageType_eip7702_authorization,
+        chain_id: None,
+        signature: "a2c790e864ff524e703c6a476609e0b738cdcd3a96628be0ef74cb5610a29a473908f07f762f4da896e7f8d3cdaad567c58aa81412ac6dd864eb5d3956a1f04c00",
+    });
+}