feat: make signing eip 712 compliant

.gitmodules

@@ -16,3 +16,6 @@
 [submodule "examples/validating-public-input/contracts/lib/forge-std"]
 	path = examples/validating-public-input/contracts/lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "contracts/lib/openzeppelin-contracts"]
+	path = contracts/lib/openzeppelin-contracts
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts

batcher/aligned-batcher/src/lib.rs

@@ -1249,13 +1249,15 @@ impl Batcher {
                     nonce_bytes,
                     DEFAULT_MAX_FEE_PER_PROOF.into(), // 13_000 gas per proof * 100 gwei gas price (upper bound)
                     self.chain_id,
+                    self.payment_service.address(),
                 )
             };
 
             let client_msg = ClientMessage::new(
                 nonced_verification_data.clone(),
                 non_paying_config.replacement.clone(),
-            );
+            )
+            .await;
 
             let batch_state = self.batch_state.lock().await;
             self.clone()

batcher/aligned-sdk/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-ethers = { tag = "v2.0.15-fix-reconnections", features = ["ws", "rustls"], git = "https://github.com/yetanotherco/ethers-rs.git" }
+ethers = { tag = "v2.0.15-fix-reconnections", features = ["ws", "rustls", "eip712"], git = "https://github.com/yetanotherco/ethers-rs.git" }
 log = { version = "0.4.21"}
 serde_json = "1.0.117"
 tokio-tungstenite = { version = "0.23.1", features = ["native-tls"] }

batcher/aligned-sdk/src/communication/messaging.rs

@@ -1,4 +1,5 @@
 use ethers::signers::Signer;
+use ethers::types::Address;
 use futures_util::{stream::SplitStream, SinkExt, StreamExt};
 use log::{debug, error, info};
 use std::sync::Arc;
@@ -30,6 +31,7 @@ pub type ResponseStream = TryFilter<
 pub async fn send_messages(
     response_stream: Arc<Mutex<ResponseStream>>,
     ws_write: Arc<Mutex<SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>>>,
+    payment_service_addr: Address,
     verification_data: &[VerificationData],
     max_fees: &[U256],
     wallet: Wallet<SigningKey>,
@@ -53,11 +55,12 @@ pub async fn send_messages(
             nonce_bytes,
             max_fees[idx],
             chain_id,
+            payment_service_addr,
         );
 
         nonce += U256::one();
 
-        let msg = ClientMessage::new(verification_data.clone(), wallet.clone());
+        let msg = ClientMessage::new(verification_data.clone(), wallet.clone()).await;
         let msg_bin = cbor_serialize(&msg).map_err(SubmitError::SerializationError)?;
         ws_write
             .send(Message::Binary(msg_bin.clone()))

batcher/aligned-sdk/src/communication/protocol.rs

@@ -6,7 +6,7 @@ use crate::core::{errors::SubmitError, types::ResponseMessage};
 
 use super::serialization::cbor_deserialize;
 
-pub const EXPECTED_PROTOCOL_VERSION: u16 = 3;
+pub const EXPECTED_PROTOCOL_VERSION: u16 = 4;
 
 pub async fn check_protocol_version(
     ws_read: &mut SplitStream<WebSocketStream<MaybeTlsStream<TcpStream>>>,

batcher/aligned-sdk/src/core/errors.rs

@@ -1,6 +1,8 @@
 use core::fmt;
 use ethers::providers::ProviderError;
 use ethers::signers::WalletError;
+use ethers::types::transaction::eip712::Eip712Error;
+use ethers::types::SignatureError;
 use std::io;
 use std::path::PathBuf;
 use tokio_tungstenite::tungstenite::protocol::CloseFrame;
@@ -233,3 +235,32 @@ impl fmt::Display for ChainIdError {
         }
     }
 }
+
+#[derive(Debug)]
+pub enum VerifySignatureError {
+    RecoverTypedDataError(SignatureError),
+    EncodeError(Eip712Error),
+}
+
+impl From<SignatureError> for VerifySignatureError {
+    fn from(e: SignatureError) -> Self {
+        VerifySignatureError::RecoverTypedDataError(e)
+    }
+}
+
+impl From<Eip712Error> for VerifySignatureError {
+    fn from(e: Eip712Error) -> Self {
+        VerifySignatureError::EncodeError(e)
+    }
+}
+
+impl fmt::Display for VerifySignatureError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            VerifySignatureError::RecoverTypedDataError(e) => {
+                write!(f, "Recover typed data error: {}", e)
+            }
+            VerifySignatureError::EncodeError(e) => write!(f, "Encode error: {}", e),
+        }
+    }
+}

batcher/aligned-sdk/src/core/types.rs

@@ -1,15 +1,26 @@
 use ethers::core::k256::ecdsa::SigningKey;
+use ethers::signers::Signer;
 use ethers::signers::Wallet;
+use ethers::types::transaction::eip712::EIP712Domain;
+use ethers::types::transaction::eip712::Eip712;
+use ethers::types::transaction::eip712::Eip712Error;
 use ethers::types::Address;
 use ethers::types::Signature;
-use ethers::types::SignatureError;
 use ethers::types::U256;
 use lambdaworks_crypto::merkle_tree::{
     merkle::MerkleTree, proof::Proof, traits::IsMerkleTreeBackend,
 };
 use serde::{Deserialize, Serialize};
 use sha3::{Digest, Keccak256};
 
+use super::errors::VerifySignatureError;
+
+// VerificationData is a bytes32 instead of a VerificationData struct because in the BatcherPaymentService contract
+// we don't have the fields of VerificationData, we only have the hash of the VerificationData.
+// chain_id is not included in the type because it is now part of the domain.
+const NONCED_VERIFICATION_DATA_TYPE: &[u8] =
+    b"NoncedVerificationData(bytes32 verification_data_hash,bytes32 nonce,uint256 max_fee)";
+
 #[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq)]
 #[repr(u8)]
 pub enum ProvingSystemId {
@@ -39,6 +50,7 @@ pub struct NoncedVerificationData {
     pub nonce: [u8; 32],
     pub max_fee: U256,
     pub chain_id: U256,
+    pub payment_service_addr: Address,
 }
 
 impl NoncedVerificationData {
@@ -47,12 +59,14 @@ impl NoncedVerificationData {
         nonce: [u8; 32],
         max_fee: U256,
         chain_id: U256,
+        payment_service_addr: Address,
     ) -> Self {
         Self {
             verification_data,
             nonce,
             max_fee,
             chain_id,
+            payment_service_addr,
         }
     }
 }
@@ -177,14 +191,60 @@ pub struct ClientMessage {
     pub signature: Signature,
 }
 
+impl Eip712 for NoncedVerificationData {
+    type Error = Eip712Error;
+    fn domain(&self) -> Result<EIP712Domain, Self::Error> {
+        Ok(EIP712Domain {
+            name: Some("Aligned".into()),
+            version: Some("1".into()),
+            chain_id: Some(self.chain_id),
+            verifying_contract: Some(self.payment_service_addr),
+            salt: None,
+        })
+    }
+
+    fn type_hash() -> Result<[u8; 32], Self::Error> {
+        let mut hasher = Keccak256::new();
+        hasher.update(NONCED_VERIFICATION_DATA_TYPE);
+        Ok(hasher.finalize().into())
+    }
+
+    fn struct_hash(&self) -> Result<[u8; 32], Self::Error> {
+        let verification_data_hash =
+            VerificationCommitmentBatch::hash_data(&self.verification_data.clone().into());
+
+        let mut hasher = Keccak256::new();
+
+        hasher.update(NONCED_VERIFICATION_DATA_TYPE);
+        let nonced_verification_data_type_hash = hasher.finalize_reset();
+
+        hasher.update(self.nonce);
+        let nonce_hash = hasher.finalize_reset();
+
+        let mut max_fee_bytes = [0u8; 32];
+        self.max_fee.to_big_endian(&mut max_fee_bytes);
+        hasher.update(max_fee_bytes);
+        let max_fee_hash = hasher.finalize_reset();
+
+        hasher.update(nonced_verification_data_type_hash.as_slice());
+        hasher.update(verification_data_hash.as_slice());
+        hasher.update(nonce_hash.as_slice());
+        hasher.update(max_fee_hash.as_slice());
+
+        Ok(hasher.finalize().into())
+    }
+}
+
 impl ClientMessage {
     /// Client message is a wrap around verification data and its signature.
     /// The signature is obtained by calculating the commitments and then hashing them.
-    pub fn new(verification_data: NoncedVerificationData, wallet: Wallet<SigningKey>) -> Self {
-        let hashed_data = ClientMessage::hash_with_nonce_and_chain_id(&verification_data);
-
+    pub async fn new(
+        verification_data: NoncedVerificationData,
+        wallet: Wallet<SigningKey>,
+    ) -> Self {
         let signature = wallet
-            .sign_hash(hashed_data.into())
+            .sign_typed_data(&verification_data)
+            .await
             .expect("Failed to sign the verification data");
 
         ClientMessage {
@@ -195,33 +255,14 @@ impl ClientMessage {
 
     /// The signature of the message is verified, and when it correct, the
     /// recovered address from the signature is returned.
-    pub fn verify_signature(&self) -> Result<Address, SignatureError> {
-        let hashed_data: [u8; 32] =
-            ClientMessage::hash_with_nonce_and_chain_id(&self.verification_data);
+    pub fn verify_signature(&self) -> Result<Address, VerifySignatureError> {
+        let recovered = self.signature.recover_typed_data(&self.verification_data)?;
+
+        let hashed_data = self.verification_data.encode_eip712()?;
 
-        let recovered = self.signature.recover(hashed_data)?;
         self.signature.verify(hashed_data, recovered)?;
         Ok(recovered)
     }
-
-    fn hash_with_nonce_and_chain_id(verification_data: &NoncedVerificationData) -> [u8; 32] {
-        let hashed_leaf = VerificationCommitmentBatch::hash_data(&verification_data.into());
-
-        let mut chain_id_bytes = [0u8; 32];
-        verification_data
-            .chain_id
-            .to_big_endian(&mut chain_id_bytes);
-
-        let mut max_fee_bytes = [0u8; 32];
-        verification_data.max_fee.to_big_endian(&mut max_fee_bytes);
-
-        let mut hasher = Keccak256::new();
-        hasher.update(hashed_leaf);
-        hasher.update(verification_data.nonce);
-        hasher.update(max_fee_bytes);
-        hasher.update(chain_id_bytes);
-        hasher.finalize().into()
-    }
 }
 
 #[derive(Serialize, Deserialize, Clone)]