various fixes + clippy fix

Author: d4mr

.dockerignore

@@ -0,0 +1,5 @@
+.gitignore
+README.md
+.github/
+scripts/
+target/

Cargo.lock

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-alloy = { version = "1.0.8" }
+alloy = { version = "1.0.8", features = ["serde"] }
 tokio = "1.44.2"
 engine-core = { path = "../core" }
 vault-types = { version = "0.1.0", git = "ssh://git@github.com/thirdweb-dev/vault.git", branch = "main" }

aa-core/Cargo.toml

@@ -53,7 +53,7 @@ pub enum SmartAccountFactory<'a, C: Chain> {
 }
 
 // Implement the AccountFactory trait for our enum
-impl<'a, C: Chain> AccountFactory for SmartAccountFactory<'a, C> {
+impl<C: Chain> AccountFactory for SmartAccountFactory<'_, C> {
     fn factory_address(&self) -> &Address {
         match self {
             Self::Default(factory) => &factory.factory_address,
@@ -81,11 +81,11 @@ impl<'a, C: Chain> AccountFactory for SmartAccountFactory<'a, C> {
 }
 
 /// Get the appropriate account factory based on the factory address
-pub fn get_account_factory<'a, C: Chain>(
-    chain: &'a C,
+pub fn get_account_factory<C: Chain>(
+    chain: &C,
     factory_address: Address,
     implementation_address: Option<Address>,
-) -> SmartAccountFactory<'a, C> {
+) -> SmartAccountFactory<'_, C> {
     // Check if the factory address matches default v0.6
     if factory_address == DEFAULT_FACTORY_ADDRESS_V0_6 {
         SmartAccountFactory::Default(DefaultAccountFactory::v0_6())

aa-core/src/account_factory/mod.rs

@@ -34,7 +34,7 @@ pub fn predict_deterministic_address(
     init_code.extend_from_slice(&code_prefix);
 
     // Add the implementation address
-    init_code.extend_from_slice(&implementation.as_slice());
+    init_code.extend_from_slice(implementation.as_slice());
 
     // Add the suffix, but without the final 'ff' byte
     // The suffix in your constant is 16 bytes, but OpenZeppelin uses 15 bytes

aa-core/src/account_factory/utils.rs

@@ -5,14 +5,15 @@ use alloy::{
     hex::FromHex,
     primitives::{Address, B256, Bytes, hex, keccak256},
     sol,
-    sol_types::{SolCall, SolStruct, SolValue, eip712_domain},
+    sol_types::{SolCall, SolValue, decode_revert_reason, eip712_domain},
 };
 use engine_core::{
     chain::Chain,
     credentials::SigningCredential,
     error::EngineError,
-    signer::{AccountSigner, EoaSigner, EoaSigningOptions, SmartAccountSigningOptions},
+    signer::{AccountSigner, EoaSigner, EoaSigningOptions, Erc4337SigningOptions},
 };
+use serde::Serialize;
 use vault_types::enclave::encrypted::eoa::MessageFormat;
 
 use crate::{
@@ -35,6 +36,7 @@ sol! {
 }
 
 sol! {
+    #[derive(Serialize)]
     struct AccountMessage {
         bytes message;
     }
@@ -48,15 +50,15 @@ const ERC6492_MAGIC_SUFFIX: [u8; 32] =
 pub struct SmartAccountSignerBuilder<C: Chain> {
     eoa_signer: Arc<EoaSigner>,
     credentials: SigningCredential,
-    options: SmartAccountSigningOptions,
+    options: Erc4337SigningOptions,
     chain: C,
 }
 
 impl<C: Chain + Clone> SmartAccountSignerBuilder<C> {
     pub fn new(
         eoa_signer: Arc<EoaSigner>,
         credentials: SigningCredential,
-        options: SmartAccountSigningOptions,
+        options: Erc4337SigningOptions,
         chain: C,
     ) -> Self {
         Self {
@@ -141,7 +143,7 @@ impl<C: Chain + Clone> SmartAccountSignerBuilder<C> {
 /// Smart Account signer with pre-computed address and factory pattern support
 #[derive(Clone)]
 pub struct SmartAccountSigner<C: Chain> {
-    options: SmartAccountSigningOptions,
+    options: Erc4337SigningOptions,
     credentials: SigningCredential,
     chain: C,
     eoa_signer: Arc<EoaSigner>,
@@ -242,17 +244,16 @@ impl<C: Chain + Clone> SmartAccountSigner<C> {
         };
 
         // Get the EIP712 signing hash using alloy's native functionality
-        let signing_hash = account_message.eip712_signing_hash(&domain);
+        let typed_data = TypedData::from_struct(&account_message, Some(domain));
 
         // Sign the hash directly with EOA
         self.eoa_signer
-            .sign_message(
+            .sign_typed_data(
                 EoaSigningOptions {
                     chain_id: Some(self.chain.chain_id()),
                     from: self.options.signer_address,
                 },
-                &format!("0x{}", hex::encode(signing_hash)),
-                MessageFormat::Hex,
+                &typed_data,
                 self.credentials.clone(),
             )
             .await
@@ -268,16 +269,25 @@ impl<C: Chain + Clone> SmartAccountSigner<C> {
         let contract =
             ERC1271Contract::new(self.smart_account.address, self.chain.provider().clone());
 
+        dbg!(self.options.signer_address);
+        dbg!(hash);
+        dbg!(signature);
+
         match contract
             .isValidSignature(hash, signature_bytes.into())
             .call()
             .await
         {
             Ok(response) => {
+                dbg!(response);
                 let expected_magic = ERC1271Contract::isValidSignatureCall::SELECTOR;
                 Ok(response.as_slice() == expected_magic)
             }
-            Err(_) => Ok(false),
+            Err(e) => {
+                let data = e.as_revert_data().unwrap();
+                dbg!(decode_revert_reason(data.as_ref()));
+                Ok(false)
+            }
         }
     }
 

aa-core/src/signer.rs

@@ -28,11 +28,11 @@ pub trait SmartAccount {
     async fn is_deployed(&self, chain: &impl Chain) -> Result<bool, EngineError> {
         let code = chain
             .provider()
-            .get_code_at(self.address().clone())
+            .get_code_at(self.address().to_owned())
             .await
             .map_err(|t| t.to_engine_error(chain))?;
 
-        Ok(code.len() > 0)
+        Ok(!code.is_empty())
     }
 
     /// Encode a transaction call to the account
@@ -74,7 +74,7 @@ impl<C: Chain> SmartAccountFromSalt<'_, C> {
     pub async fn to_determined_smart_account(self) -> Result<DeterminedSmartAccount, EngineError> {
         let factory = get_account_factory(self.chain, self.factory_address, None);
         let address = factory
-            .predict_address(&self.admin_address, &self.salt_data)
+            .predict_address(&self.admin_address, self.salt_data)
             .await?;
 
         Ok(DeterminedSmartAccount { address })

aa-core/src/smart_account/mod.rs

@@ -130,7 +130,7 @@ impl<'a, C: Chain> UserOpBuilderV0_6<'a, C> {
         let pm_response = self
             .chain
             .paymaster_client()
-            .get_user_op_paymaster_and_data_v0_6(&self.userop, self.entrypoint.clone())
+            .get_user_op_paymaster_and_data_v0_6(&self.userop, self.entrypoint)
             .await
             .map_err(|err| err.to_engine_paymaster_error(self.chain))?;
 

aa-core/src/userop/builder.rs

@@ -17,5 +17,5 @@ async-nats = "0.40.0"
 twmq = { version = "0.1.0", path = "../twmq" }
 thirdweb-core = { version = "0.1.0", path = "../thirdweb-core" }
 uuid = { version = "1.17.0", features = ["v4"] }
-utoipa = "5.4.0"
+utoipa = { version = "5.4.0", features = ["preserve_order"] }
 serde_with = "3.13.0"

core/Cargo.toml

@@ -124,7 +124,7 @@ impl Chain for ThirdwebChain {
     }
 }
 
-impl<'a> ThirdwebChainConfig<'a> {
+impl ThirdwebChainConfig<'_> {
     pub fn to_chain(&self) -> Result<ThirdwebChain, EngineError> {
         let rpc_url = Url::parse(&format!(
             "https://{chain_id}.{base_url}/{client_id}",
@@ -133,7 +133,7 @@ impl<'a> ThirdwebChainConfig<'a> {
             client_id = self.client_id,
         ))
         .map_err(|e| EngineError::RpcConfigError {
-            message: format!("Failed to parse RPC URL: {}", e.to_string()),
+            message: format!("Failed to parse RPC URL: {}", e),
         })?;
 
         let bundler_url = Url::parse(&format!(
@@ -142,7 +142,7 @@ impl<'a> ThirdwebChainConfig<'a> {
             base_url = self.bundler_base_url,
         ))
         .map_err(|e| EngineError::RpcConfigError {
-            message: format!("Failed to parse Bundler URL: {}", e.to_string()),
+            message: format!("Failed to parse Bundler URL: {}", e),
         })?;
 
         let paymaster_url = Url::parse(&format!(
@@ -151,20 +151,20 @@ impl<'a> ThirdwebChainConfig<'a> {
             base_url = self.paymaster_base_url,
         ))
         .map_err(|e| EngineError::RpcConfigError {
-            message: format!("Failed to parse Paymaster URL: {}", e.to_string()),
+            message: format!("Failed to parse Paymaster URL: {}", e),
         })?;
 
         let mut sensitive_headers = HeaderMap::new();
         sensitive_headers.insert(
             "x-client-id",
-            HeaderValue::from_str(&self.client_id).map_err(|e| EngineError::RpcConfigError {
+            HeaderValue::from_str(self.client_id).map_err(|e| EngineError::RpcConfigError {
                 message: format!("Unserialisable client-id used: {e}"),
             })?,
         );
 
         sensitive_headers.insert(
             "x-secret-key",
-            HeaderValue::from_str(&self.secret_key).map_err(|e| EngineError::RpcConfigError {
+            HeaderValue::from_str(self.secret_key).map_err(|e| EngineError::RpcConfigError {
                 message: format!("Unserialisable secret-key used: {e}"),
             })?,
         );
@@ -217,8 +217,7 @@ impl<'a> ThirdwebChainConfig<'a> {
 
             provider: ProviderBuilder::new()
                 .disable_recommended_fillers()
-                .connect_http(rpc_url)
-                .into(),
+                .connect_http(rpc_url),
 
             bundler_url,
             paymaster_url,