plumb it all together

Author: d4mr

Cargo.lock

@@ -9,7 +9,7 @@ pub trait DeploymentCache: Send + Sync {
         &self,
         chain_id: u64,
         account_address: &Address,
-    ) -> impl Future<Output = Option<bool>> + Send + Sync;
+    ) -> impl Future<Output = Option<bool>> + Send;
 }
 
 pub enum AcquireLockResult {
@@ -26,15 +26,22 @@ pub trait DeploymentLock: Send + Sync {
         &self,
         chain_id: u64,
         account_address: &Address,
-    ) -> impl Future<Output = Option<(LockId, Duration)>> + Send + Sync;
+    ) -> impl Future<Output = Option<(LockId, Duration)>> + Send;
 
     /// Try to acquire a deployment lock
     /// Returns true if successful, false if already locked
     fn acquire_lock(
         &self,
         chain_id: u64,
         account_address: &Address,
-    ) -> impl Future<Output = Result<AcquireLockResult, EngineError>> + Send + Sync;
+    ) -> impl Future<Output = Result<AcquireLockResult, EngineError>> + Send;
+
+    /// Release a deployment lock
+    fn release_lock(
+        &self,
+        chain_id: u64,
+        account_address: &Address,
+    ) -> impl Future<Output = Result<bool, EngineError>> + Send;
 }
 
 pub enum DeploymentStatus {

aa-core/src/userop/deployment.rs

@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 aide = { version = "0.14.2", features = ["axum"] }
-alloy = { version = "1.0.8", features = ["serde"] }
+alloy = { version = "1.0.8", features = ["serde", "json-rpc"] }
 schemars = "0.8.22"
 serde = "1.0.219"
 serde_json = "1.0.140"

core/Cargo.toml

@@ -1,17 +1,53 @@
-use crate::rpc_clients::{BundlerClient, PaymasterClient};
+use crate::rpc_clients::{BundlerClient, PaymasterClient, transport::SharedClientTransportBuilder};
 use alloy::{
     providers::{ProviderBuilder, RootProvider},
-    transports::http::{
-        Http,
-        reqwest::{
-            ClientBuilder as HttpClientBuilder, Url,
-            header::{HeaderMap, HeaderValue},
-        },
+    rpc::client::RpcClient,
+    transports::http::reqwest::{
+        ClientBuilder as HttpClientBuilder, Url,
+        header::{HeaderMap, HeaderValue},
     },
 };
+use serde::{Deserialize, Serialize};
 
 use crate::error::EngineError;
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct ThirdwebClientIdAndServiceKey {
+    pub client_id: String,
+    pub service_key: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum ThirdwebRpcCredentials {
+    ClientIdServiceKey(ThirdwebClientIdAndServiceKey),
+}
+
+impl ThirdwebRpcCredentials {
+    pub fn to_header_map(&self) -> Result<HeaderMap, EngineError> {
+        match self {
+            ThirdwebRpcCredentials::ClientIdServiceKey(creds) => {
+                let mut headers = HeaderMap::new();
+                headers.insert("x-client-id", HeaderValue::from_str(&creds.client_id)?);
+                headers.insert("x-service-key", HeaderValue::from_str(&creds.service_key)?);
+                Ok(headers)
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum RpcCredentials {
+    Thirdweb(ThirdwebRpcCredentials),
+}
+
+impl RpcCredentials {
+    pub fn to_header_map(&self) -> Result<HeaderMap, EngineError> {
+        match self {
+            RpcCredentials::Thirdweb(creds) => creds.to_header_map(),
+        }
+    }
+}
+
 pub trait Chain: Send + Sync {
     fn chain_id(&self) -> u64;
     fn rpc_url(&self) -> Url;
@@ -21,6 +57,11 @@ pub trait Chain: Send + Sync {
     fn provider(&self) -> &RootProvider;
     fn bundler_client(&self) -> &BundlerClient;
     fn paymaster_client(&self) -> &PaymasterClient;
+
+    fn bundler_client_with_headers(&self, headers: HeaderMap) -> BundlerClient;
+    fn paymaster_client_with_headers(&self, headers: HeaderMap) -> PaymasterClient;
+
+    fn with_new_default_headers(&self, headers: HeaderMap) -> Self;
 }
 
 pub struct ThirdwebChainConfig<'a> {
@@ -32,15 +73,22 @@ pub struct ThirdwebChainConfig<'a> {
     pub client_id: &'a str,
 }
 
+#[derive(Clone)]
 pub struct ThirdwebChain {
+    transport_builder: SharedClientTransportBuilder,
+
     chain_id: u64,
     rpc_url: Url,
     bundler_url: Url,
     paymaster_url: Url,
 
+    /// Default clients (these also use the shared connection pool)
     pub bundler_client: BundlerClient,
     pub paymaster_client: PaymasterClient,
     pub provider: RootProvider,
+
+    pub sensitive_bundler_client: BundlerClient,
+    pub sensitive_paymaster_client: PaymasterClient,
 }
 
 impl Chain for ThirdwebChain {
@@ -71,6 +119,30 @@ impl Chain for ThirdwebChain {
     fn paymaster_client(&self) -> &PaymasterClient {
         &self.paymaster_client
     }
+
+    fn bundler_client_with_headers(&self, headers: HeaderMap) -> BundlerClient {
+        let transport = self
+            .transport_builder
+            .with_headers(self.bundler_url.clone(), headers);
+        let rpc_client = RpcClient::builder().transport(transport, false);
+        BundlerClient { inner: rpc_client }
+    }
+
+    fn paymaster_client_with_headers(&self, headers: HeaderMap) -> PaymasterClient {
+        let transport = self
+            .transport_builder
+            .with_headers(self.paymaster_url.clone(), headers);
+        let rpc_client = RpcClient::builder().transport(transport, false);
+        PaymasterClient { inner: rpc_client }
+    }
+
+    fn with_new_default_headers(&self, headers: HeaderMap) -> Self {
+        let mut new_self = self.to_owned();
+        new_self.bundler_client = self.bundler_client_with_headers(headers.clone());
+        new_self.paymaster_client = self.paymaster_client_with_headers(headers.clone());
+
+        new_self
+    }
 }
 
 impl<'a> ThirdwebChainConfig<'a> {
@@ -103,36 +175,67 @@ impl<'a> ThirdwebChainConfig<'a> {
             message: format!("Failed to parse Paymaster URL: {}", e.to_string()),
         })?;
 
-        let mut headers = HeaderMap::new();
-        headers.insert(
+        let mut sensitive_headers = HeaderMap::new();
+        sensitive_headers.insert(
             "x-client-id",
             HeaderValue::from_str(&self.client_id).map_err(|e| EngineError::RpcConfigError {
                 message: format!("Unserialisable client-id used: {e}"),
             })?,
         );
 
-        headers.insert(
+        sensitive_headers.insert(
             "x-secret-key",
             HeaderValue::from_str(&self.secret_key).map_err(|e| EngineError::RpcConfigError {
                 message: format!("Unserialisable secret-key used: {e}"),
             })?,
         );
 
-        let reqwest_client = HttpClientBuilder::new()
-            .default_headers(headers)
-            .build()
-            .map_err(|e| EngineError::RpcConfigError {
-                message: format!("Failed to build HTTP client: {e}"),
-            })?;
+        let reqwest_client =
+            HttpClientBuilder::new()
+                .build()
+                .map_err(|e| EngineError::RpcConfigError {
+                    message: format!("Failed to build HTTP client: {e}"),
+                })?;
+
+        let transport_builder = SharedClientTransportBuilder::new(reqwest_client.clone());
 
-        let paymaster_transport = Http::with_client(reqwest_client.clone(), paymaster_url.clone());
-        let bundler_transport = Http::with_client(reqwest_client, bundler_url.clone());
+        let paymaster_transport = transport_builder.default_transport(paymaster_url.clone());
+        let bundler_transport = transport_builder.default_transport(bundler_url.clone());
+
+        let sensitive_bundler_transport =
+            transport_builder.with_headers(bundler_url.clone(), sensitive_headers.clone());
+        let sensitive_paymaster_transport =
+            transport_builder.with_headers(paymaster_url.clone(), sensitive_headers);
+
+        let paymaster_rpc_client = RpcClient::builder().transport(paymaster_transport, false);
+        let bundler_rpc_client = RpcClient::builder().transport(bundler_transport, false);
+
+        let sensitive_bundler_rpc_client =
+            RpcClient::builder().transport(sensitive_bundler_transport, false);
+        let sensitive_paymaster_rpc_client =
+            RpcClient::builder().transport(sensitive_paymaster_transport, false);
 
         Ok(ThirdwebChain {
+            transport_builder,
+
             chain_id: self.chain_id,
             rpc_url: rpc_url.clone(),
-            bundler_client: BundlerClient::new(bundler_transport),
-            paymaster_client: PaymasterClient::new(paymaster_transport),
+
+            bundler_client: BundlerClient {
+                inner: bundler_rpc_client,
+            },
+            paymaster_client: PaymasterClient {
+                inner: paymaster_rpc_client,
+            },
+
+            sensitive_bundler_client: BundlerClient {
+                inner: sensitive_bundler_rpc_client,
+            },
+
+            sensitive_paymaster_client: PaymasterClient {
+                inner: sensitive_paymaster_rpc_client,
+            },
+
             provider: ProviderBuilder::new()
                 .disable_recommended_fillers()
                 .connect_http(rpc_url)

core/src/chain.rs

@@ -1,9 +1,12 @@
 use alloy::{
     primitives::Address,
-    transports::{RpcError as AlloyRpcError, TransportErrorKind},
+    transports::{
+        RpcError as AlloyRpcError, TransportErrorKind, http::reqwest::header::InvalidHeaderValue,
+    },
 };
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
+use twmq::error::TwmqError;
 
 use crate::chain::Chain;
 
@@ -179,6 +182,20 @@ pub enum EngineError {
         /// Specific error kind
         kind: ContractInteractionErrorKind,
     },
+
+    #[error("Validation error: {message}")]
+    ValidationError { message: String },
+
+    #[error("Internal error: {0}")]
+    InternalError(String),
+}
+
+impl From<InvalidHeaderValue> for EngineError {
+    fn from(err: InvalidHeaderValue) -> Self {
+        EngineError::ValidationError {
+            message: err.to_string(),
+        }
+    }
 }
 
 pub trait AlloyRpcErrorToEngineError {
@@ -299,3 +316,15 @@ impl ContractErrorToEngineError for alloy::contract::Error {
         }
     }
 }
+
+impl From<twmq::redis::RedisError> for EngineError {
+    fn from(error: twmq::redis::RedisError) -> Self {
+        EngineError::InternalError(error.to_string())
+    }
+}
+
+impl From<TwmqError> for EngineError {
+    fn from(error: TwmqError) -> Self {
+        EngineError::InternalError(error.to_string())
+    }
+}

core/src/error.rs

@@ -1,12 +1,14 @@
 use serde::{Deserialize, Serialize};
+
+use crate::transaction::InnerTransaction;
 pub mod aa;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct BaseExecutionOptions {
-    chain_id: u64,
+    pub chain_id: u64,
     #[serde(default = "default_idempotency_key")]
-    idempotency_key: String,
+    pub idempotency_key: String,
 }
 
 fn default_idempotency_key() -> String {
@@ -26,3 +28,50 @@ pub struct ExecutionOptions {
     #[serde(flatten)]
     pub specific: SpecificExecutionOptions,
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransactionRequest {
+    #[serde(flatten)]
+    pub execution_options: ExecutionOptions,
+    pub params: Vec<InnerTransaction>,
+    pub webhook_url: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransactionResponse {
+    pub transaction_id: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueuedNotification {
+    pub transaction_id: String,
+    pub executor_type: ExecutorType,
+    pub execution_options: ExecutionOptions,
+    pub timestamp: u64,
+    pub queue_name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ExecutorType {
+    Erc4337,
+}
+
+impl ExecutionOptions {
+    pub fn executor_type(&self) -> ExecutorType {
+        match &self.specific {
+            SpecificExecutionOptions::ERC4337(_) => ExecutorType::Erc4337,
+        }
+    }
+
+    pub fn chain_id(&self) -> u64 {
+        self.base.chain_id
+    }
+
+    pub fn transaction_id(&self) -> &str {
+        &self.base.idempotency_key
+    }
+}