only store vault signed access tokens

Author: d4mr

Cargo.lock

@@ -2,8 +2,7 @@ use std::sync::Arc;
 
 use alloy::{
     dyn_abi::TypedData,
-    hex::FromHex,
-    primitives::{Address, B256, Bytes, hex, keccak256},
+    primitives::{Address, B256, hex, keccak256},
     sol,
     sol_types::{SolCall, SolValue, decode_revert_reason, eip712_domain},
 };
@@ -71,19 +70,8 @@ impl<C: Chain + Clone> SmartAccountSignerBuilder<C> {
 
     /// Build the signer with computed address and factory pattern detection
     pub async fn build(self) -> Result<SmartAccountSigner<C>, EngineError> {
-        // 1. Parse Account Salt
-        let salt_data = if self.options.account_salt.starts_with("0x") {
-            Bytes::from_hex(self.options.account_salt.clone()).map_err(|e| {
-                EngineError::ValidationError {
-                    message: format!("Failed to parse hex salt: {}", e),
-                }
-            })?
-        } else {
-            let hex_string = hex::encode(self.options.account_salt.clone());
-            Bytes::from_hex(hex_string).map_err(|e| EngineError::ValidationError {
-                message: format!("Failed to encode salt as hex: {}", e),
-            })?
-        };
+        // 1. Parse Account Salt using the helper method
+        let salt_data = self.options.get_salt_data()?;
 
         // 2. Determine Smart Account
         let smart_account = match self.options.smart_account_address {
@@ -269,10 +257,6 @@ 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()

aa-core/src/signer.rs

@@ -51,7 +51,7 @@ pub enum DeploymentStatus {
     /// Account is currently being deployed by another process
     BeingDeployed { stale: bool, lock_id: LockId },
 
-    ///
+    /// Account is not deployed
     NotDeployed,
 }
 

aa-core/src/userop/deployment.rs

@@ -1,8 +1,9 @@
 use crate::{
     constants::{DEFAULT_FACTORY_ADDRESS_V0_6, ENTRYPOINT_ADDRESS_V0_6},
     defs::AddressDef,
+    error::EngineError,
 };
-use alloy::primitives::Address;
+use alloy::{hex::FromHex, primitives::{Address, Bytes}};
 use schemars::JsonSchema;
 use serde::{Deserialize, Deserializer, Serialize};
 
@@ -85,6 +86,22 @@ pub struct Erc4337ExecutionOptions {
     pub smart_account_address: Option<Address>,
 }
 
+impl Erc4337ExecutionOptions {
+    /// Parse account salt into Bytes, handling both hex and plain string formats
+    pub fn get_salt_data(&self) -> Result<Bytes, EngineError> {
+        if self.account_salt.starts_with("0x") {
+            Bytes::from_hex(&self.account_salt).map_err(|e| EngineError::ValidationError {
+                message: format!("Failed to parse hex salt: {}", e),
+            })
+        } else {
+            let hex_string = alloy::hex::encode(&self.account_salt);
+            Bytes::from_hex(hex_string).map_err(|e| EngineError::ValidationError {
+                message: format!("Failed to encode salt as hex: {}", e),
+            })
+        }
+    }
+}
+
 pub fn default_factory_address() -> Address {
     DEFAULT_FACTORY_ADDRESS_V0_7
 }

core/src/execution_options/aa.rs

@@ -1,6 +1,7 @@
 use alloy::{
     dyn_abi::TypedData,
-    primitives::{Address, ChainId},
+    hex::FromHex,
+    primitives::{Address, Bytes, ChainId},
 };
 use serde::{Deserialize, Serialize};
 use serde_with::{DisplayFromStr, PickFirst, serde_as};
@@ -91,6 +92,22 @@ pub struct Erc4337SigningOptions {
     pub chain_id: ChainId,
 }
 
+impl Erc4337SigningOptions {
+    /// Parse account salt into Bytes, handling both hex and plain string formats
+    pub fn get_salt_data(&self) -> Result<Bytes, EngineError> {
+        if self.account_salt.starts_with("0x") {
+            Bytes::from_hex(&self.account_salt).map_err(|e| EngineError::ValidationError {
+                message: format!("Failed to parse hex salt: {}", e),
+            })
+        } else {
+            let hex_string = alloy::hex::encode(&self.account_salt);
+            Bytes::from_hex(hex_string).map_err(|e| EngineError::ValidationError {
+                message: format!("Failed to encode salt as hex: {}", e),
+            })
+        }
+    }
+}
+
 /// Configuration options for signing operations
 #[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
 #[serde(tag = "type", rename_all = "camelCase")]

core/src/signer.rs

@@ -1,7 +1,4 @@
-use alloy::{
-    hex::FromHex,
-    primitives::{Address, Bytes, U256},
-};
+use alloy::primitives::{Address, Bytes, U256};
 use engine_aa_core::{
     account_factory::{AccountFactory, get_account_factory},
     smart_account::{DeterminedSmartAccount, SmartAccount, SmartAccountFromSalt},
@@ -54,6 +51,10 @@ pub struct ExternalBundlerSendJobData {
     pub webhook_options: Option<Vec<WebhookOptions>>,
 
     pub rpc_credentials: RpcCredentials,
+    
+    /// Pregenerated nonce for vault signed tokens
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pregenerated_nonce: Option<U256>,
 }
 
 impl HasWebhookOptions for ExternalBundlerSendJobData {
@@ -262,21 +263,12 @@ where
 
         let chain = chain.with_new_default_headers(chain_auth_headers);
 
-        // 2. Parse Account Salt
-        let salt_data = if job_data.execution_options.account_salt.starts_with("0x") {
-            Bytes::from_hex(job_data.execution_options.account_salt.clone())
-                .map_err(|e| ExternalBundlerSendError::InvalidAccountSalt {
-                    message: format!("Failed to parse hex salt: {}", e),
-                })
-                .map_err_fail()?
-        } else {
-            let hex_string = hex::encode(job_data.execution_options.account_salt.clone());
-            Bytes::from_hex(hex_string)
+        // 2. Parse Account Salt using the helper method
+        let salt_data = job_data.execution_options.get_salt_data()
                 .map_err(|e| ExternalBundlerSendError::InvalidAccountSalt {
-                    message: format!("Failed to encode salt as hex: {}", e),
+                    message: e.to_string(),
                 })
-                .map_err_fail()?
-        };
+                .map_err_fail()?;
 
         // 3. Determine Smart Account
         let smart_account = match job_data.execution_options.smart_account_address {
@@ -363,15 +355,15 @@ where
 
         tracing::debug!(lock_acquired = ?needs_init_code);
 
-        // 5. Get Nonce
-        let nonce = {
+        // 5. Get Nonce - use pregenerated nonce if available, otherwise generate random
+        let nonce = job_data.pregenerated_nonce.unwrap_or_else(|| {
             use rand::Rng;
             let mut rng = rand::rng();
             let limb1: u64 = rng.random();
             let limb2: u64 = rng.random();
             let limb3: u64 = rng.random();
             U256::from_limbs([0, limb1, limb2, limb3])
-        };
+        });
 
         // 6. Prepare Init Call Data
         let init_call_data = get_account_factory(