contract endpoints POC

Author: d4mr

Cargo.lock

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

Cargo.toml

@@ -16,4 +16,5 @@ tower = "0.5.2"
 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" }
 uuid = { version = "1.17.0", features = ["v4"] }

core/Cargo.toml

@@ -8,43 +8,22 @@ use alloy::{
     },
 };
 use serde::{Deserialize, Serialize};
+use thirdweb_core::auth::ThirdwebAuth;
 
 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),
+    Thirdweb(ThirdwebAuth),
 }
 
 impl RpcCredentials {
     pub fn to_header_map(&self) -> Result<HeaderMap, EngineError> {
-        match self {
-            RpcCredentials::Thirdweb(creds) => creds.to_header_map(),
-        }
+        let header_map = match self {
+            RpcCredentials::Thirdweb(creds) => creds.to_header_map()?,
+        };
+
+        Ok(header_map)
     }
 }
 

core/src/chain.rs

@@ -5,6 +5,7 @@ use alloy::{
     },
 };
 use serde::{Deserialize, Serialize};
+use thirdweb_core::error::ThirdwebError;
 use thiserror::Error;
 use twmq::error::TwmqError;
 
@@ -186,6 +187,9 @@ pub enum EngineError {
     #[error("Validation error: {message}")]
     ValidationError { message: String },
 
+    #[error("Thirdweb error: {0}")]
+    ThirdwebError(#[from] ThirdwebError),
+
     #[error("Internal error: {0}")]
     InternalError(String),
 }

core/src/error.rs

@@ -29,15 +29,18 @@ pub struct ExecutionOptions {
     pub specific: SpecificExecutionOptions,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct WebhookOptions {
+    pub url: String,
+}
+
 #[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>,
+    pub webhook_options: Option<WebhookOptions>,
 }
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TransactionResponse {

core/src/execution_options/mod.rs

@@ -1,6 +1,7 @@
+use alloy::consensus::{Receipt, ReceiptWithBloom};
 use alloy::primitives::{Address, Bytes, U256};
 use alloy::rpc::client::RpcClient;
-use alloy::rpc::types::UserOperationReceipt;
+use alloy::rpc::types::{Log, TransactionReceipt};
 use alloy::transports::{IntoBoxTransport, TransportResult};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -28,6 +29,37 @@ pub struct UseropGasEstimation {
     pub paymaster_post_op_gas_limit: Option<U256>,
 }
 
+/// Represents the receipt of a user operation.
+// Not using UserOperationReceipt from alloy because it uses `TransactionReceipt<ReceiptEnvelope<Log>>`, which depends on a tagged enum by `type` field
+// RPC response for receipt does not return `type` field, so we cannot use `TransactionReceipt<ReceiptEnvelope<Log>>` directly
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UserOperationReceipt {
+    /// The hash of the user operation.
+    pub user_op_hash: Bytes,
+    /// The entry point address for the user operation.
+    pub entry_point: Address,
+    /// The address of the sender of the user operation.
+    pub sender: Address,
+    /// The nonce of the user operation.
+    pub nonce: U256,
+    /// The address of the paymaster, if any.
+    pub paymaster: Address,
+    /// The actual gas cost incurred by the user operation.
+    pub actual_gas_cost: U256,
+    /// The actual gas used by the user operation.
+    pub actual_gas_used: U256,
+    /// Indicates whether the user operation was successful.
+    pub success: bool,
+    /// The reason for failure, if any.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reason: Option<Bytes>,
+    /// The logs generated by the user operation.
+    pub logs: Vec<Log>,
+    /// The transaction receipt of the user operation.
+    pub receipt: TransactionReceipt<ReceiptWithBloom<Receipt<Log>>>,
+}
+
 impl BundlerClient {
     /// Create a new bundler client with the given transport
     pub fn new(transport: impl IntoBoxTransport) -> Self {

core/src/rpc_clients/bundler.rs

@@ -1,15 +1,15 @@
-use alloy::{
-    primitives::{Address, Bytes, U256},
-    rpc::types::UserOperationReceipt,
-};
+use alloy::primitives::{Address, Bytes, U256};
 use engine_core::{
-    chain::{Chain, ChainService},
+    chain::{Chain, ChainService, RpcCredentials},
     error::AlloyRpcErrorToEngineError,
+    execution_options::WebhookOptions,
+    rpc_clients::UserOperationReceipt,
 };
 use serde::{Deserialize, Serialize};
 use std::{sync::Arc, time::Duration};
 use twmq::{
     DurableExecution, FailHookData, NackHookData, Queue, SuccessHookData,
+    error::TwmqError,
     hooks::TransactionContext,
     job::{Job, JobResult, RequeuePosition, ToJobResult},
 };
@@ -19,7 +19,7 @@ use crate::webhook::{
     envelope::{ExecutorStage, HasWebhookOptions, WebhookCapable},
 };
 
-use super::{deployment::RedisDeploymentLock, send::WebhookOptions};
+use super::deployment::RedisDeploymentLock;
 
 // --- Job Payload ---
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -32,8 +32,8 @@ pub struct UserOpConfirmationJobData {
     pub nonce: U256,
     pub deployment_lock_acquired: bool,
     pub webhook_options: Option<WebhookOptions>,
-    pub thirdweb_client_id: Option<String>,
-    pub thirdweb_service_key: Option<String>,
+
+    pub rpc_credentials: RpcCredentials,
 }
 
 // --- Success Result ---
@@ -47,7 +47,7 @@ pub struct UserOpConfirmationResult {
 
 // --- Error Types ---
 #[derive(Serialize, Deserialize, Debug, Clone, thiserror::Error)]
-#[serde(rename_all = "camelCase", tag = "errorCode")]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE", tag = "errorCode")]
 pub enum UserOpConfirmationError {
     #[error("Chain service error for chainId {chain_id}: {message}")]
     ChainServiceError { chain_id: u64, message: String },
@@ -63,13 +63,21 @@ pub enum UserOpConfirmationError {
         user_op_hash: Bytes,
         message: String,
         #[serde(skip_serializing_if = "Option::is_none")]
-        technical_details: Option<String>,
+        inner_error: Option<serde_json::Value>,
     },
 
     #[error("Internal error: {message}")]
     InternalError { message: String },
 }
 
+impl From<TwmqError> for UserOpConfirmationError {
+    fn from(error: TwmqError) -> Self {
+        UserOpConfirmationError::InternalError {
+            message: format!("Deserialization error for job data: {}", error.to_string()),
+        }
+    }
+}
+
 // --- Handler ---
 pub struct UserOpConfirmationHandler<CS>
 where
@@ -115,6 +123,7 @@ where
     type ErrorData = UserOpConfirmationError;
     type JobData = UserOpConfirmationJobData;
 
+    #[tracing::instrument(skip(self, job), fields(transaction_id = job.id, stage = Self::stage_name(), executor = Self::executor_name()))]
     async fn process(&self, job: &Job<Self::JobData>) -> JobResult<Self::Output, Self::ErrorData> {
         let job_data = &job.data;
 
@@ -126,28 +135,29 @@ where
                 chain_id: job_data.chain_id,
                 message: format!("Failed to get chain instance: {}", e),
             })
-            .fail_err()?;
+            .map_err_fail()?;
+
+        let chain = chain.with_new_default_headers(
+            job.data
+                .rpc_credentials
+                .to_header_map()
+                .map_err(|e| UserOpConfirmationError::InternalError {
+                    message: format!("Bad RPC Credential values, unserialisable into headers: {e}"),
+                })
+                .map_err_fail()?,
+        );
 
         // 2. Query for User Operation Receipt
-        let receipt_result = chain
+        let receipt_option = chain
             .bundler_client()
             .get_user_op_receipt(job_data.user_op_hash.clone())
             .await
             .map_err(|e| UserOpConfirmationError::ReceiptQueryFailed {
                 user_op_hash: job_data.user_op_hash.clone(),
                 message: e.to_string(),
-                technical_details: Some(
-                    serde_json::to_string(&e.to_engine_bundler_error(&chain)).unwrap_or_default(),
-                ),
-            });
-
-        let receipt_option = match receipt_result {
-            Ok(opt) => opt,
-            Err(e) => {
-                // Network/RPC errors might be temporary, retry
-                return Err(e).nack_err(Some(self.confirmation_retry_delay), RequeuePosition::Last);
-            }
-        };
+                inner_error: serde_json::to_value(&e.to_engine_bundler_error(&chain)).ok(),
+            })
+            .map_err_nack(Some(self.confirmation_retry_delay), RequeuePosition::Last)?;
 
         let receipt = match receipt_option {
             Some(receipt) => receipt,
@@ -158,14 +168,14 @@ where
                         user_op_hash: job_data.user_op_hash.clone(),
                         attempt_number: job.attempts,
                     })
-                    .fail_err(); // FAIL - triggers on_fail hook which will release lock
+                    .map_err_fail(); // FAIL - triggers on_fail hook which will release lock
                 }
 
                 return Err(UserOpConfirmationError::ReceiptNotAvailable {
                     user_op_hash: job_data.user_op_hash.clone(),
                     attempt_number: job.attempts,
                 })
-                .nack_err(Some(self.confirmation_retry_delay), RequeuePosition::Last);
+                .map_err_nack(Some(self.confirmation_retry_delay), RequeuePosition::Last);
                 // NACK - triggers on_nack hook which keeps lock for retry
             }
         };
@@ -299,13 +309,7 @@ where
 
 impl HasWebhookOptions for UserOpConfirmationJobData {
     fn webhook_url(&self) -> Option<String> {
-        self.webhook_options
-            .as_ref()
-            .map(|opts| opts.webhook_url.clone())
-    }
-
-    fn transaction_id(&self) -> String {
-        self.transaction_id.clone()
+        self.webhook_options.as_ref().map(|opts| opts.url.clone())
     }
 }