restructuring crates

Author: d4mr

Cargo.lock

@@ -1,3 +1,3 @@
 [workspace]
-members = ["aa-core", "core", "executors", "server", "thirdweb-core", "twmq", "types-core"]
+members = ["aa-types", "aa-core", "core", "executors", "server", "thirdweb-core", "twmq"]
 resolver = "2"

Cargo.toml

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

aa-core/Cargo.toml

@@ -6,14 +6,14 @@ use alloy::{
     providers::Provider,
     rpc::types::{PackedUserOperation, UserOperation},
 };
+use engine_aa_types::VersionedUserOp;
 use engine_core::{
     chain::Chain,
     credentials::SigningCredential,
     error::{AlloyRpcErrorToEngineError, EngineError},
     execution_options::aa::{EntrypointAndFactoryDetails, EntrypointVersion},
     userop::{UserOpSigner, UserOpSignerParams},
 };
-use thirdweb_core::iaw::UserOpVersion;
 
 pub struct UserOpBuilderConfig<'a, C: Chain> {
     pub account_address: Address,
@@ -41,7 +41,7 @@ impl<'a, C: Chain> UserOpBuilder<'a, C> {
         Self { config }
     }
 
-    pub async fn build(self) -> Result<UserOpVersion, EngineError> {
+    pub async fn build(self) -> Result<VersionedUserOp, EngineError> {
         let mut userop = match self.config.entrypoint_and_factory.version {
             EntrypointVersion::V0_6 => UserOpBuilderV0_6::new(&self.config).build().await?,
             EntrypointVersion::V0_7 => UserOpBuilderV0_7::new(&self.config).build().await?,
@@ -62,10 +62,10 @@ impl<'a, C: Chain> UserOpBuilder<'a, C> {
             .await?;
 
         match &mut userop {
-            UserOpVersion::V0_6(userop) => {
+            VersionedUserOp::V0_6(userop) => {
                 userop.signature = signature;
             }
-            UserOpVersion::V0_7(userop) => {
+            VersionedUserOp::V0_7(userop) => {
                 userop.signature = signature;
             }
         }
@@ -115,7 +115,7 @@ impl<'a, C: Chain> UserOpBuilderV0_6<'a, C> {
         }
     }
 
-    async fn build(mut self) -> Result<UserOpVersion, EngineError> {
+    async fn build(mut self) -> Result<VersionedUserOp, EngineError> {
         let prices = self
             .chain
             .provider()
@@ -154,7 +154,7 @@ impl<'a, C: Chain> UserOpBuilderV0_6<'a, C> {
                     .chain
                     .bundler_client()
                     .estimate_user_op_gas(
-                        &UserOpVersion::V0_6(self.userop.clone()),
+                        &VersionedUserOp::V0_6(self.userop.clone()),
                         self.entrypoint,
                         None,
                     )
@@ -173,7 +173,7 @@ impl<'a, C: Chain> UserOpBuilderV0_6<'a, C> {
         self.userop.verification_gas_limit = verification_gas_limit;
         self.userop.pre_verification_gas = pre_verification_gas;
 
-        Ok(UserOpVersion::V0_6(self.userop))
+        Ok(VersionedUserOp::V0_6(self.userop))
     }
 }
 
@@ -220,7 +220,7 @@ impl<'a, C: Chain> UserOpBuilderV0_7<'a, C> {
         }
     }
 
-    async fn build(mut self) -> Result<UserOpVersion, EngineError> {
+    async fn build(mut self) -> Result<VersionedUserOp, EngineError> {
         // Get gas prices, same as v0.6
         let prices = self
             .chain
@@ -273,7 +273,7 @@ impl<'a, C: Chain> UserOpBuilderV0_7<'a, C> {
                     .chain
                     .bundler_client()
                     .estimate_user_op_gas(
-                        &UserOpVersion::V0_7(self.userop.clone()),
+                        &VersionedUserOp::V0_7(self.userop.clone()),
                         self.entrypoint,
                         None,
                     )
@@ -301,6 +301,6 @@ impl<'a, C: Chain> UserOpBuilderV0_7<'a, C> {
         self.userop.paymaster_verification_gas_limit = Some(paymaster_verification_gas_limit);
         self.userop.paymaster_post_op_gas_limit = Some(paymaster_post_op_gas_limit);
 
-        Ok(UserOpVersion::V0_7(self.userop))
+        Ok(VersionedUserOp::V0_7(self.userop))
     }
 }

aa-core/src/userop/builder.rs

@@ -1,9 +1,12 @@
 [package]
-name = "types-core"
+name = "engine-aa-types"
 version = "0.1.0"
 edition = "2024"
 
 [dependencies]
 alloy = { version = "1.0.8", features = ["serde"] }
 serde = { version = "1.0.219", features = ["derive"] }
-serde_json = "1.0.140" 
+serde_json = "1.0.140"
+thiserror = "2.0.12"
+schemars = "0.8.22"
+utoipa = "5.4.0"

types-core/Cargo.toml renamed to aa-types/Cargo.toml

@@ -0,0 +1,3 @@
+pub mod userop;
+
+pub use userop::*;

aa-types/src/lib.rs

@@ -3,15 +3,30 @@ use alloy::{
     primitives::{keccak256, Address, ChainId, Bytes, U256, B256},
     rpc::types::{PackedUserOperation, UserOperation},
 };
+use serde::{Deserialize, Serialize};
+
+/// UserOp version enum
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum VersionedUserOp {
+    V0_6(UserOperation),
+    V0_7(PackedUserOperation),
+}
 
-use super::IAWError;
+/// Error type for UserOp operations
+#[derive(Debug, Clone, thiserror::Error, serde::Serialize, serde::Deserialize, schemars::JsonSchema, utoipa::ToSchema)]
+#[serde(tag = "type", rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum UserOpError {
+    #[error("Unexpected error: {0}")]
+    UnexpectedError(String),
+}
 
 /// Compute UserOperation v0.6 hash
 pub fn compute_user_op_v06_hash(
     op: &UserOperation,
     entrypoint: Address,
     chain_id: ChainId,
-) -> Result<B256, IAWError> {
+) -> Result<B256, UserOpError> {
     // Hash the byte fields first
     let init_code_hash = keccak256(&op.init_code);
     let call_data_hash = keccak256(&op.call_data);
@@ -49,7 +64,7 @@ pub fn compute_user_op_v07_hash(
     op: &PackedUserOperation,
     entrypoint: Address,
     chain_id: ChainId,
-) -> Result<B256, IAWError> {
+) -> Result<B256, UserOpError> {
     // Construct initCode from factory and factoryData
     let init_code: Bytes = if let Some(factory) = op.factory {
         if factory != Address::ZERO {
@@ -63,10 +78,10 @@ pub fn compute_user_op_v07_hash(
 
     // Construct accountGasLimits
     let vgl_u128: u128 = op.verification_gas_limit.try_into().map_err(|_| {
-        IAWError::UnexpectedError("verification_gas_limit too large".to_string())
+        UserOpError::UnexpectedError("verification_gas_limit too large".to_string())
     })?;
     let cgl_u128: u128 = op.call_gas_limit.try_into().map_err(|_| {
-        IAWError::UnexpectedError("call_gas_limit too large".to_string())
+        UserOpError::UnexpectedError("call_gas_limit too large".to_string())
     })?;
 
     let mut account_gas_limits_bytes = [0u8; 32];
@@ -76,10 +91,10 @@ pub fn compute_user_op_v07_hash(
 
     // Construct gasFees
     let mpfpg_u128: u128 = op.max_priority_fee_per_gas.try_into().map_err(|_| {
-        IAWError::UnexpectedError("max_priority_fee_per_gas too large".to_string())
+        UserOpError::UnexpectedError("max_priority_fee_per_gas too large".to_string())
     })?;
     let mfpg_u128: u128 = op.max_fee_per_gas.try_into().map_err(|_| {
-        IAWError::UnexpectedError("max_fee_per_gas too large".to_string())
+        UserOpError::UnexpectedError("max_fee_per_gas too large".to_string())
     })?;
 
     let mut gas_fees_bytes = [0u8; 32];
@@ -91,10 +106,10 @@ pub fn compute_user_op_v07_hash(
     let paymaster_and_data: Bytes = if let Some(paymaster) = op.paymaster {
         if paymaster != Address::ZERO {
             let pm_vgl_u128: u128 = op.paymaster_verification_gas_limit.unwrap_or_default().try_into().map_err(|_| {
-                IAWError::UnexpectedError("paymaster_verification_gas_limit too large".to_string())
+                UserOpError::UnexpectedError("paymaster_verification_gas_limit too large".to_string())
             })?;
             let pm_pogl_u128: u128 = op.paymaster_post_op_gas_limit.unwrap_or_default().try_into().map_err(|_| {
-                IAWError::UnexpectedError("paymaster_post_op_gas_limit too large".to_string())
+                UserOpError::UnexpectedError("paymaster_post_op_gas_limit too large".to_string())
             })?;
             [
                 &paymaster[..],
@@ -139,4 +154,4 @@ pub fn compute_user_op_v07_hash(
     let outer_encoded = outer_tuple.abi_encode();
     let final_hash = keccak256(&outer_encoded);
     Ok(final_hash)
-} 
+}

thirdweb-core/src/iaw/userop.rs renamed to aa-types/src/userop.rs

@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 alloy = { version = "1.0.8", features = ["serde", "json-rpc"] }
+engine-aa-types = { path = "../aa-types" }
 schemars = "0.8.22"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
@@ -16,7 +17,6 @@ tracing = "0.1.41"
 async-nats = "0.40.0"
 twmq = { version = "0.1.0", path = "../twmq" }
 thirdweb-core = { version = "0.1.0", path = "../thirdweb-core" }
-types-core = { path = "../types-core" }
 uuid = { version = "1.17.0", features = ["v4"] }
 utoipa = { version = "5.4.0", features = ["preserve_order"] }
 serde_with = "3.13.0"

core/Cargo.toml

@@ -208,9 +208,12 @@ pub enum EngineError {
     VaultError { message: String },
 
     #[schema(title = "Engine IAW Service Error")]
-    #[error("Error interaction with IAW service: {message}")]
+    #[error("Error interaction with IAW service: {error}")]
     #[serde(rename_all = "camelCase")]
-    IawError { message: String },
+    IawError {
+        #[from]
+        error: thirdweb_core::iaw::IAWError,
+    },
 
     #[schema(title = "RPC Configuration Error")]
     #[error("Bad RPC configuration: {message}")]
@@ -463,10 +466,3 @@ impl From<TwmqError> for EngineError {
     }
 }
 
-impl From<thirdweb_core::iaw::IAWError> for EngineError {
-    fn from(error: thirdweb_core::iaw::IAWError) -> Self {
-        EngineError::IawError {
-            message: error.to_string(),
-        }
-    }
-}

core/src/error.rs

@@ -6,7 +6,7 @@ use alloy::transports::{IntoBoxTransport, TransportResult};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-use types_core::UserOpVersion;
+use crate::userop::VersionedUserOp;
 
 // Gas buffer added for managed account factories (matches TypeScript)
 pub const MANAGED_ACCOUNT_GAS_BUFFER: U256 = U256::from_limbs([21_000, 0, 0, 0]);
@@ -81,7 +81,7 @@ impl BundlerClient {
     /// Estimate the gas for a user operation
     pub async fn estimate_user_op_gas(
         &self,
-        user_op: &UserOpVersion,
+        user_op: &VersionedUserOp,
         entrypoint: Address,
         state_overrides: Option<HashMap<String, HashMap<String, String>>>,
     ) -> TransportResult<UseropGasEstimation> {
@@ -104,7 +104,7 @@ impl BundlerClient {
 
     pub async fn send_user_op(
         &self,
-        user_op: &UserOpVersion,
+        user_op: &VersionedUserOp,
         entrypoint: Address,
     ) -> TransportResult<Bytes> {
         let result: Bytes = self