feat: impl ethereum builder

crates/network/src/ethereum/mod.rs

@@ -1,8 +1,11 @@
-use crate::{BuilderResult, Network, NetworkSigner, TransactionBuilder};
+use crate::{BuilderResult, Network, NetworkSigner, TransactionBuilder, TransactionBuilderError};
+use alloy_consensus::{TxEip1559, TxEip2930, TxEip4844, TxEip4844Variant, TxLegacy};
+use alloy_primitives::{Address, TxKind, U256, U64};
+use alloy_rpc_types::request::TransactionRequest;
+use async_trait::async_trait;
 
 mod receipt;
 mod signer;
-use alloy_primitives::{Address, TxKind, U256, U64};
 pub use signer::EthereumSigner;
 
 /// Types for a mainnet-like Ethereum network.
@@ -27,6 +30,7 @@ impl Network for Ethereum {
     type HeaderResponse = alloy_rpc_types::Header;
 }
 
+#[async_trait]
 impl TransactionBuilder<Ethereum> for alloy_rpc_types::TransactionRequest {
     fn chain_id(&self) -> Option<alloy_primitives::ChainId> {
         self.chain_id
@@ -120,13 +124,143 @@ impl TransactionBuilder<Ethereum> for alloy_rpc_types::TransactionRequest {
     }
 
     fn build_unsigned(self) -> BuilderResult<<Ethereum as Network>::UnsignedTx> {
-        todo!()
+        match (
+            self.gas_price.as_ref(),
+            self.max_fee_per_gas.as_ref(),
+            self.access_list.as_ref(),
+            self.max_fee_per_blob_gas.as_ref(),
+            self.blob_versioned_hashes.as_ref(),
+            self.sidecar.as_ref(),
+        ) {
+            // Legacy transaction
+            (Some(_), None, None, None, None, None) => build_legacy(self).map(Into::into),
+            // EIP-2930
+            // If only accesslist is set, and there are no EIP-1559 fees
+            (_, None, Some(_), None, None, None) => build_2930(self).map(Into::into),
+            // EIP-1559
+            // If EIP-4844 fields are missing
+            (None, _, _, None, None, None) => build_1559(self).map(Into::into),
+            // EIP-4844
+            // All blob fields required
+            (None, _, _, Some(_), Some(_), Some(_)) => {
+                build_4844(self).map(TxEip4844Variant::from).map(Into::into)
+            }
+            _ => build_legacy(self).map(Into::into),
+        }
     }
 
-    fn build<S: NetworkSigner<Ethereum>>(
+    async fn build<S: NetworkSigner<Ethereum>>(
         self,
         signer: &S,
     ) -> BuilderResult<<Ethereum as Network>::TxEnvelope> {
-        todo!()
+        // todo: BuilderResult + SignerResult
+        Ok(signer.sign(self.build_unsigned()?).await.unwrap())
     }
 }
+
+/// Build a legacy transaction.
+fn build_legacy(request: TransactionRequest) -> Result<TxLegacy, TransactionBuilderError> {
+    Ok(TxLegacy {
+        chain_id: request.chain_id,
+        nonce: request.nonce.ok_or_else(|| TransactionBuilderError::MissingKey("nonce"))?.to(),
+        gas_price: request
+            .gas_price
+            .ok_or_else(|| TransactionBuilderError::MissingKey("gas_price"))?
+            .to(),
+        gas_limit: request
+            .gas
+            .ok_or_else(|| TransactionBuilderError::MissingKey("gas_limit"))?
+            .to(),
+        to: request.to.into(),
+        value: request.value.unwrap_or_default(),
+        input: request.input.into_input().unwrap_or_default(),
+    })
+}
+
+/// Build an EIP-1559 transaction.
+fn build_1559(request: TransactionRequest) -> Result<TxEip1559, TransactionBuilderError> {
+    Ok(TxEip1559 {
+        chain_id: request.chain_id.unwrap_or(1),
+        nonce: request.nonce.ok_or_else(|| TransactionBuilderError::MissingKey("nonce"))?.to(),
+        max_priority_fee_per_gas: request
+            .max_priority_fee_per_gas
+            .ok_or_else(|| TransactionBuilderError::MissingKey("max_priority_fee_per_gas"))?
+            .to(),
+        max_fee_per_gas: request
+            .max_fee_per_gas
+            .ok_or_else(|| TransactionBuilderError::MissingKey("max_fee_per_gas"))?
+            .to(),
+        gas_limit: request
+            .gas
+            .ok_or_else(|| TransactionBuilderError::MissingKey("gas_limit"))?
+            .to(),
+        to: request.to.into(),
+        value: request.value.unwrap_or_default(),
+        input: request.input.into_input().unwrap_or_default(),
+        access_list: convert_access_list(request.access_list.unwrap_or_default()),
+    })
+}
+
+/// Build an EIP-2930 transaction.
+fn build_2930(request: TransactionRequest) -> Result<TxEip2930, TransactionBuilderError> {
+    Ok(TxEip2930 {
+        chain_id: request.chain_id.unwrap_or(1),
+        nonce: request.nonce.ok_or_else(|| TransactionBuilderError::MissingKey("nonce"))?.to(),
+        gas_price: request
+            .gas_price
+            .ok_or_else(|| TransactionBuilderError::MissingKey("gas_price"))?
+            .to(),
+        gas_limit: request
+            .gas
+            .ok_or_else(|| TransactionBuilderError::MissingKey("gas_limit"))?
+            .to(),
+        to: request.to.into(),
+        value: request.value.unwrap_or_default(),
+        input: request.input.into_input().unwrap_or_default(),
+        access_list: convert_access_list(request.access_list.unwrap_or_default()),
+    })
+}
+
+/// Build an EIP-4844 transaction.
+fn build_4844(request: TransactionRequest) -> Result<TxEip4844, TransactionBuilderError> {
+    Ok(TxEip4844 {
+        chain_id: request.chain_id.unwrap_or(1),
+        nonce: request.nonce.ok_or_else(|| TransactionBuilderError::MissingKey("nonce"))?.to(),
+        gas_limit: request
+            .gas
+            .ok_or_else(|| TransactionBuilderError::MissingKey("gas_limit"))?
+            .to(),
+        max_fee_per_gas: request
+            .max_fee_per_gas
+            .ok_or_else(|| TransactionBuilderError::MissingKey("max_fee_per_gas"))?
+            .to(),
+        max_priority_fee_per_gas: request
+            .max_priority_fee_per_gas
+            .ok_or_else(|| TransactionBuilderError::MissingKey("max_priority_fee_per_gas"))?
+            .to(),
+        to: request.to.into(),
+        value: request.value.unwrap_or_default(),
+        access_list: convert_access_list(request.access_list.unwrap_or_default()),
+        blob_versioned_hashes: request
+            .blob_versioned_hashes
+            .ok_or_else(|| TransactionBuilderError::MissingKey("blob_versioned_hashes"))?,
+        max_fee_per_blob_gas: request
+            .max_fee_per_blob_gas
+            .ok_or_else(|| TransactionBuilderError::MissingKey("max_fee_per_blob_gas"))?
+            .to(),
+        input: request.input.into_input().unwrap_or_default(),
+    })
+}
+
+// todo: these types are almost 1:1, minus rlp decoding and ser/de, should dedupe
+fn convert_access_list(list: alloy_rpc_types::AccessList) -> alloy_eips::eip2930::AccessList {
+    alloy_eips::eip2930::AccessList(
+        list.0
+            .into_iter()
+            .map(|item| alloy_eips::eip2930::AccessListItem {
+                address: item.address,
+                storage_keys: item.storage_keys,
+            })
+            .collect(),
+    )
+}

crates/network/src/transaction/builder.rs

@@ -1,6 +1,7 @@
 use super::signer::NetworkSigner;
 use crate::Network;
 use alloy_primitives::{Address, Bytes, ChainId, TxKind, U256, U64};
+use async_trait::async_trait;
 
 /// Error type for transaction builders.
 #[derive(Debug, thiserror::Error)]
@@ -42,6 +43,7 @@ pub type BuilderResult<T, E = TransactionBuilderError> = std::result::Result<T,
 ///
 /// Transaction builders should be able to construct all available transaction types on a given
 /// network.
+#[async_trait]
 pub trait TransactionBuilder<N: Network>: Default + Sized + Send + Sync + 'static {
     /// Get the chain ID for the transaction.
     fn chain_id(&self) -> Option<ChainId>;
@@ -192,5 +194,5 @@ pub trait TransactionBuilder<N: Network>: Default + Sized + Send + Sync + 'stati
     fn build_unsigned(self) -> BuilderResult<N::UnsignedTx>;
 
     /// Build a signed transaction.
-    fn build<S: NetworkSigner<N>>(self, signer: &S) -> BuilderResult<N::TxEnvelope>;
+    async fn build<S: NetworkSigner<N>>(self, signer: &S) -> BuilderResult<N::TxEnvelope>;
 }

crates/network/src/transaction/signer.rs

@@ -5,7 +5,7 @@ use async_trait::async_trait;
 // todo: move
 /// A signer capable of signing any transaction for the given network.
 #[async_trait]
-pub trait NetworkSigner<N: Network> {
+pub trait NetworkSigner<N: Network>: Sync {
     /// Asynchronously sign an unsigned transaction.
     async fn sign(&self, tx: N::UnsignedTx) -> alloy_signer::Result<N::TxEnvelope>;
 }

crates/rpc-types/Cargo.toml

@@ -33,12 +33,22 @@ proptest-derive = { version = "0.4", optional = true }
 jsonrpsee-types = { version = "0.20", optional = true }
 
 [features]
-arbitrary = ["dep:arbitrary", "dep:proptest-derive", "dep:proptest", "alloy-primitives/arbitrary"]
+arbitrary = [
+    "dep:arbitrary",
+    "dep:proptest-derive",
+    "dep:proptest",
+    "alloy-primitives/arbitrary",
+]
 jsonrpsee-types = ["dep:jsonrpsee-types"]
-ssz = ["dep:ethereum_ssz" ,"dep:ethereum_ssz_derive", "alloy-primitives/ssz"]
+ssz = ["dep:ethereum_ssz", "dep:ethereum_ssz_derive", "alloy-primitives/ssz"]
 
 [dev-dependencies]
-alloy-primitives = { workspace = true, features = ["rand", "rlp", "serde", "arbitrary"] }
+alloy-primitives = { workspace = true, features = [
+    "rand",
+    "rlp",
+    "serde",
+    "arbitrary",
+] }
 
 arbitrary = { workspace = true, features = ["derive"] }
 proptest.workspace = true