signing routes compiling

Author: d4mr

aa-core/src/signer.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use alloy::{
     dyn_abi::TypedData,
     hex::FromHex,
@@ -44,15 +46,15 @@ const ERC6492_MAGIC_SUFFIX: [u8; 32] =
 
 /// Builder for creating SmartAccountSigner with computed address and factory pattern detection
 pub struct SmartAccountSignerBuilder<C: Chain> {
-    eoa_signer: EoaSigner,
+    eoa_signer: Arc<EoaSigner>,
     credentials: SigningCredential,
     options: SmartAccountSigningOptions,
     chain: C,
 }
 
 impl<C: Chain + Clone> SmartAccountSignerBuilder<C> {
     pub fn new(
-        eoa_signer: EoaSigner,
+        eoa_signer: Arc<EoaSigner>,
         credentials: SigningCredential,
         options: SmartAccountSigningOptions,
         chain: C,
@@ -142,7 +144,7 @@ pub struct SmartAccountSigner<C: Chain> {
     options: SmartAccountSigningOptions,
     credentials: SigningCredential,
     chain: C,
-    eoa_signer: EoaSigner,
+    eoa_signer: Arc<EoaSigner>,
     smart_account: DeterminedSmartAccount,
     init_calldata: Vec<u8>,
     supports_712_factory: bool,

core/src/signer.rs

@@ -10,8 +10,7 @@ use vault_sdk::VaultClient;
 use vault_types::enclave::encrypted::eoa::MessageFormat;
 
 use crate::{
-    chain::Chain,
-    credentials::{self, SigningCredential},
+    credentials::SigningCredential,
     defs::AddressDef,
     error::EngineError,
     execution_options::aa::{EntrypointAndFactoryDetails, EntrypointAndFactoryDetailsDeserHelper},
@@ -65,9 +64,11 @@ pub struct SmartAccountSigningOptions {
 pub enum SigningOptions {
     /// Standard EOA (Externally Owned Account) signing
     #[serde(rename = "eoa")]
+    #[schema(title = "EOA Signing Options")]
     Eoa(EoaSigningOptions),
     /// Smart Account signing with advanced signature patterns
     #[serde(rename = "smart_account")]
+    #[schema(title = "Smart Account Signing Options")]
     SmartAccount(SmartAccountSigningOptions),
 }
 

server/src/http/routes/sign_message.rs

@@ -1,58 +1,52 @@
-// Sign Message Operations
-
-use alloy::primitives::{Address, ChainId};
 use axum::{
     extract::State,
     http::StatusCode,
     response::{IntoResponse, Json},
 };
+use engine_aa_core::signer::SmartAccountSignerBuilder;
 use engine_core::{
-    error::EngineError, 
-    signer::{EoaSigner, SigningOptions, SmartAccountSigningOptions},
+    chain::ChainService,
     credentials::SigningCredential,
+    error::EngineError,
+    signer::{AccountSigner, SigningOptions},
 };
-use engine_aa_core::signer::{SmartAccountSigner, SmartAccountSignerBuilder};
 use futures::future::join_all;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use thirdweb_core::auth::ThirdwebAuth;
 use vault_types::enclave::encrypted::eoa::MessageFormat;
 
 use crate::http::{
     error::ApiEngineError,
     extractors::{EngineJson, SigningCredentialsExtractor},
     server::EngineServerState,
-    types::ErrorResponse,
 };
 
 // ===== REQUEST/RESPONSE TYPES =====
-
-/// Options for signing messages
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, utoipa::ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct SignOptions {
-    /// Configuration options for signing
-    #[serde(flatten)]
-    pub signing_options: SigningOptions,
-}
-
 /// Individual message to sign
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, utoipa::ToSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct MessageInput {
     /// The message to sign
     pub message: String,
     /// Message format (text or hex)
     #[serde(default = "default_message_format")]
+    #[schema(value_type = MessageFormatDef)]
     pub format: MessageFormat,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, utoipa::ToSchema)]
+#[serde(rename_all = "lowercase")]
+pub enum MessageFormatDef {
+    Text,
+    Hex,
+}
+
 /// Request to sign messages
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, utoipa::ToSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct SignMessageRequest {
     /// Configuration options for signing
-    pub sign_options: SignOptions,
+    pub signing_options: SigningOptions,
     /// List of messages to sign
     pub params: Vec<MessageInput>,
 }
@@ -177,7 +171,12 @@ pub async fn sign_message(
 ) -> Result<impl IntoResponse, ApiEngineError> {
     // Process all messages in parallel
     let sign_futures = request.params.iter().map(|message_input| {
-        sign_single_message(&state, &signing_credential, &request.sign_options.signing_options, message_input)
+        sign_single_message(
+            &state,
+            &signing_credential,
+            &request.signing_options,
+            message_input,
+        )
     });
 
     let results: Vec<SignResultItem> = join_all(sign_futures).await;
@@ -201,7 +200,8 @@ async fn sign_single_message(
     let result = match signing_options {
         SigningOptions::Eoa(eoa_options) => {
             // Direct EOA signing
-            state.eoa_signer
+            state
+                .eoa_signer
                 .sign_message(
                     eoa_options.clone(),
                     &message_input.message,
@@ -232,7 +232,10 @@ async fn sign_single_message(
                     }
                 }
                 Err(e) => Err(EngineError::ValidationError {
-                    message: format!("Failed to get chain {}: {}", smart_account_options.chain_id, e),
+                    message: format!(
+                        "Failed to get chain {}: {}",
+                        smart_account_options.chain_id, e
+                    ),
                 }),
             }
         }
@@ -246,4 +249,4 @@ async fn sign_single_message(
 
 fn default_message_format() -> MessageFormat {
     MessageFormat::Text
-}
+}

server/src/http/routes/sign_typed_data.rs

@@ -1,27 +1,28 @@
 // Sign Typed Data Operations
 
-use alloy::{dyn_abi::TypedData, primitives::Address};
+use alloy::dyn_abi::TypedData;
 use axum::{
     extract::State,
     http::StatusCode,
     response::{IntoResponse, Json},
 };
+use engine_aa_core::signer::SmartAccountSignerBuilder;
 use engine_core::{
-    error::EngineError, 
-    signer::{EoaSigner, SigningOptions, SmartAccountSigningOptions},
+    chain::ChainService,
     credentials::SigningCredential,
+    defs::{AddressDef, U256Def},
+    error::EngineError,
+    signer::{AccountSigner, SigningOptions},
 };
-use engine_aa_core::signer::{SmartAccountSigner, SmartAccountSignerBuilder};
 use futures::future::join_all;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use thirdweb_core::auth::ThirdwebAuth;
+use serde_json::Value;
 
 use crate::http::{
     error::ApiEngineError,
     extractors::{EngineJson, SigningCredentialsExtractor},
     server::EngineServerState,
-    types::ErrorResponse,
 };
 
 // ===== REQUEST/RESPONSE TYPES =====
@@ -36,15 +37,55 @@ pub struct SignOptions {
 }
 
 /// Request to sign typed data
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, utoipa::ToSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct SignTypedDataRequest {
     /// Configuration options for signing
     pub sign_options: SignOptions,
     /// List of typed data to sign
+    #[schema(value_type = Vec<TypedDataDef>)]
     pub params: Vec<TypedData>,
 }
 
+#[derive(utoipa::ToSchema)]
+pub struct TypedDataDef {
+    /// Signing domain metadata. The signing domain is the intended context for
+    /// the signature (e.g. the dapp, protocol, etc. that it's intended for).
+    /// This data is used to construct the domain separator of the message.
+    pub domain: TypedDataDomainDef,
+
+    /// The custom types used by this message.
+    #[schema(rename = "types")]
+    pub resolver: Value,
+
+    /// The type of the message.
+    #[schema(rename = "primaryType")]
+    pub primary_type: String,
+
+    /// The message to be signed.
+    pub message: serde_json::Value,
+}
+
+#[derive(utoipa::ToSchema)]
+pub struct TypedDataDomainDef {
+    pub name: Option<String>,
+
+    /// The current major version of the signing domain. Signatures from
+    /// different versions are not compatible.
+    pub version: Option<String>,
+
+    /// The EIP-155 chain ID. The user-agent should refuse signing if it does
+    /// not match the currently active chain.
+    pub chain_id: Option<U256Def>,
+
+    /// The address of the contract that will verify the signature.
+    pub verifying_contract: Option<AddressDef>,
+
+    /// A disambiguating salt for the protocol. This can be used as a domain
+    /// separator of last resort.
+    pub salt: Option<String>,
+}
+
 /// Result of a single typed data signing operation
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, utoipa::ToSchema)]
 #[serde(untagged)]
@@ -165,7 +206,12 @@ pub async fn sign_typed_data(
 ) -> Result<impl IntoResponse, ApiEngineError> {
     // Process all typed data in parallel
     let sign_futures = request.params.iter().map(|typed_data| {
-        sign_single_typed_data(&state.userop_signer, &signing_credential, &request.sign_options.signing_options, typed_data)
+        sign_single_typed_data(
+            &state,
+            &signing_credential,
+            &request.sign_options.signing_options,
+            typed_data,
+        )
     });
 
     let results: Vec<SignResultItem> = join_all(sign_futures).await;
@@ -181,26 +227,53 @@ pub async fn sign_typed_data(
 // ===== HELPER FUNCTIONS =====
 
 async fn sign_single_typed_data(
-    signer: &Signer,
+    state: &EngineServerState,
     signing_credential: &SigningCredential,
     signing_options: &SigningOptions,
     typed_data: &TypedData,
 ) -> SignResultItem {
-    let params = TypedDataSignerParams {
-        credentials: signing_credential.clone(),
-        typed_data: typed_data.clone(),
-        signing_options: signing_options.clone(),
+    let result = match signing_options {
+        SigningOptions::Eoa(eoa_options) => {
+            // Direct EOA signing
+            state
+                .eoa_signer
+                .sign_typed_data(eoa_options.clone(), typed_data, signing_credential.clone())
+                .await
+        }
+        SigningOptions::SmartAccount(smart_account_options) => {
+            // Smart account signing via builder
+            match state.chains.get_chain(smart_account_options.chain_id) {
+                Ok(chain) => {
+                    match SmartAccountSignerBuilder::new(
+                        state.eoa_signer.clone(),
+                        signing_credential.clone(),
+                        smart_account_options.clone(),
+                        chain,
+                    )
+                    .build()
+                    .await
+                    {
+                        Ok(smart_signer) => smart_signer.sign_typed_data(typed_data).await,
+                        Err(e) => Err(e),
+                    }
+                }
+                Err(e) => Err(EngineError::ValidationError {
+                    message: format!(
+                        "Failed to get chain {}: {}",
+                        smart_account_options.chain_id, e
+                    ),
+                }),
+            }
+        }
     };
 
-    let result = signer.sign_typed_data(params).await;
-
     match result {
         Ok(signature) => {
             // Convert typed data to JSON string for signed_data field
             let signed_data = serde_json::to_string(typed_data)
                 .unwrap_or_else(|_| "Failed to serialize typed data".to_string());
             SignResultItem::success(signature, signed_data)
-        },
+        }
         Err(e) => SignResultItem::failure(e),
     }
-}
+}

server/src/http/server.rs

@@ -58,6 +58,10 @@ impl EngineServer {
             .routes(routes!(
                 crate::http::routes::transaction::cancel_transaction
             ))
+            .routes(routes!(crate::http::routes::sign_message::sign_message))
+            .routes(routes!(
+                crate::http::routes::sign_typed_data::sign_typed_data
+            ))
             .layer(cors)
             .layer(TraceLayer::new_for_http())
             .with_state(state);

server/src/main.rs

@@ -38,7 +38,9 @@ async fn main() -> anyhow::Result<()> {
         rpc_base_url: config.thirdweb.urls.rpc,
     });
 
-    let signer = Arc::new(UserOpSigner { vault_client });
+    let signer = Arc::new(UserOpSigner {
+        vault_client: vault_client.clone(),
+    });
     let eoa_signer = Arc::new(EoaSigner { vault_client });
 
     let queue_manager =