support deployment transactions (without "to")

Author: d4mr

aa-core/src/smart_account/mod.rs

@@ -38,7 +38,7 @@ pub trait SmartAccount {
     /// Encode a transaction call to the account
     fn encode_execute(&self, tx: &InnerTransaction) -> Bytes {
         executeCall {
-            _target: tx.to,
+            _target: tx.to.unwrap_or(Address::ZERO),
             _value: tx.value,
             _calldata: tx.data.clone(),
         }
@@ -49,7 +49,10 @@ pub trait SmartAccount {
     /// Encode a batch transaction call to the account
     fn encode_execute_batch(&self, batch: &Vec<InnerTransaction>) -> Bytes {
         executeBatchCall {
-            _target: batch.iter().map(|tx| tx.to).collect(),
+            _target: batch
+                .iter()
+                .map(|tx| tx.to.unwrap_or(Address::ZERO))
+                .collect(),
             _value: batch.iter().map(|tx| tx.value).collect(),
             _calldata: batch.iter().map(|tx| tx.data.clone()).collect(),
         }

core/src/transaction.rs

@@ -1,22 +1,18 @@
 use crate::defs::{AddressDef, BytesDef, U256Def};
 use alloy::primitives::{Address, Bytes, U256};
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 /// # InnerTransaction
 /// This is the actual encoded inner transaction data that will be sent to the blockchain.
-#[derive(Deserialize, Serialize, Debug, Clone, JsonSchema, utoipa::ToSchema)]
+#[derive(Deserialize, Serialize, Debug, Clone, utoipa::ToSchema)]
 pub struct InnerTransaction {
-    #[schemars(with = "AddressDef")]
-    #[schema(value_type = AddressDef)]
-    pub to: Address,
+    #[schema(value_type = Option<AddressDef>)]
+    pub to: Option<Address>,
 
-    #[schemars(with = "BytesDef")]
     #[schema(value_type = BytesDef)]
     #[serde(default)]
     pub data: Bytes,
 
-    #[schemars(with = "U256Def")]
     #[schema(value_type = U256Def)]
     #[serde(default)]
     pub value: U256,

server/src/http/dyn_contract.rs

@@ -312,7 +312,7 @@ impl ContractCall {
         value: U256,
     ) -> InnerTransaction {
         InnerTransaction {
-            to: prepared.target,
+            to: Some(prepared.target),
             data: prepared.call_data.clone(),
             value,
         }