diff --git a/.github/ISSUE_TEMPLATE/bug.yml b/.github/ISSUE_TEMPLATE/bug.yml
index d17ebe3c176..76e9bfcaaa2 100644
--- a/.github/ISSUE_TEMPLATE/bug.yml
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@@ -76,7 +76,7 @@ body:
id: terms
attributes:
label: Code of Conduct
- description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/foundry-rs/reth/blob/main/CODE_OF_CONDUCT.md)
+ description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/paradigmxyz/reth/blob/main/CONTRIBUTING.md#code-of-conduct)
options:
- label: I agree to follow the Code of Conduct
required: true
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index cd5b3f54d6a..db26044dfa5 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -5,7 +5,6 @@ on:
branches: [main]
env:
- RUSTFLAGS: -D warnings
CARGO_TERM_COLOR: always
concurrency:
diff --git a/.github/workflows/dependencies.yml b/.github/workflows/dependencies.yml
new file mode 100644
index 00000000000..e731a7a5692
--- /dev/null
+++ b/.github/workflows/dependencies.yml
@@ -0,0 +1,61 @@
+# Automatically run `cargo update` periodically
+
+name: Update Dependencies
+
+on:
+ schedule:
+ # Run weekly
+ - cron: "0 0 * * SUN"
+ workflow_dispatch:
+ # Needed so we can run it manually
+
+env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ BRANCH: cargo-update
+ TITLE: "chore(deps): weekly `cargo update`"
+ BODY: |
+ Automation to keep dependencies in `Cargo.lock` current.
+
+ cargo update log
+
+
+ ```log
+ $cargo_update_log
+ ```
+
+
+
+
+Arguments:
+
+ The table name
Options:
--datadir
@@ -116,6 +189,11 @@ Options:
[default: default]
+ -s, --skip
+ Skip first N entries
+
+ [default: 0]
+
--chain
The chain this node is running.
@@ -128,6 +206,17 @@ Options:
[default: mainnet]
+ -r, --reverse
+ Reverse the order of the entries. If enabled last table entries are read
+
+ -l, --len
+ How many items to take from the walker
+
+ [default: 5]
+
+ -j, --json
+ Dump as JSON instead of using TUI
+
-h, --help
Print help (see a summary with '-h')
@@ -238,18 +327,14 @@ Display:
Silence all log output
```
-## `reth db list`
+## `reth db drop`
-Lists the contents of a table
+Deletes all database entries
```bash
-$ reth db list --help
-
-Usage: reth db list [OPTIONS]
+$ reth db drop --help
-Arguments:
-
- The table name
+Usage: reth db drop [OPTIONS]
Options:
--datadir
@@ -263,11 +348,6 @@ Options:
[default: default]
- -s, --skip
- Skip first N entries
-
- [default: 0]
-
--chain
The chain this node is running.
@@ -280,17 +360,6 @@ Options:
[default: mainnet]
- -r, --reverse
- Reverse the order of the entries. If enabled last table entries are read
-
- -l, --len
- How many items to take from the walker
-
- [default: 5]
-
- -j, --json
- Dump as JSON instead of using TUI
-
-h, --help
Print help (see a summary with '-h')
@@ -325,14 +394,18 @@ Display:
Silence all log output
```
-## `reth db path`
+## `reth db clear`
-Returns the full database path
+Deletes all table entries
```bash
-$ reth db path --help
+$ reth db clear --help
-Usage: reth db path [OPTIONS]
+Usage: reth db clear [OPTIONS]
+
+Arguments:
+
+ Table name
Options:
--datadir
@@ -392,14 +465,14 @@ Display:
Silence all log output
```
-## `reth db stats`
+## `reth db version`
-Lists all the tables, their entry count and their size
+Lists current and local database versions
```bash
-$ reth db stats --help
+$ reth db version --help
-Usage: reth db stats [OPTIONS]
+Usage: reth db version [OPTIONS]
Options:
--datadir
@@ -459,14 +532,14 @@ Display:
Silence all log output
```
-## `reth db version`
+## `reth db path`
-Lists current and local database versions
+Returns the full database path
```bash
-$ reth db version --help
+$ reth db path --help
-Usage: reth db version [OPTIONS]
+Usage: reth db path [OPTIONS]
Options:
--datadir
diff --git a/crates/blockchain-tree/src/blockchain_tree.rs b/crates/blockchain-tree/src/blockchain_tree.rs
index ce92f48b283..8edee773bad 100644
--- a/crates/blockchain-tree/src/blockchain_tree.rs
+++ b/crates/blockchain-tree/src/blockchain_tree.rs
@@ -1001,9 +1001,12 @@ impl BlockchainTree
old: Arc::new(old_canon_chain.clone()),
new: Arc::new(new_canon_chain.clone()),
};
+ let reorg_depth = old_canon_chain.len();
+
// insert old canon chain
self.insert_chain(AppendableChain::new(old_canon_chain));
- self.metrics.reorgs.increment(1);
+
+ self.update_reorg_metrics(reorg_depth as f64);
} else {
// error here to confirm that we are reverting nothing from db.
error!(target: "blockchain_tree", "Reverting nothing from db on block: #{:?}", block_hash);
@@ -1094,6 +1097,11 @@ impl BlockchainTree
}
}
+ fn update_reorg_metrics(&mut self, reorg_depth: f64) {
+ self.metrics.reorgs.increment(1);
+ self.metrics.latest_reorg_depth.set(reorg_depth);
+ }
+
/// Update blockchain tree chains (canonical and sidechains) and sync metrics.
///
/// NOTE: this method should not be called during the pipeline sync, because otherwise the sync
diff --git a/crates/blockchain-tree/src/metrics.rs b/crates/blockchain-tree/src/metrics.rs
index fd48307d4be..b49ad3c5b92 100644
--- a/crates/blockchain-tree/src/metrics.rs
+++ b/crates/blockchain-tree/src/metrics.rs
@@ -13,6 +13,8 @@ pub struct TreeMetrics {
pub canonical_chain_height: Gauge,
/// The number of reorgs
pub reorgs: Counter,
+ /// The latest reorg depth
+ pub latest_reorg_depth: Gauge,
/// Longest sidechain height
pub longest_sidechain_height: Gauge,
}
diff --git a/crates/consensus/auto-seal/src/lib.rs b/crates/consensus/auto-seal/src/lib.rs
index 668a2117f6b..29cb6f49177 100644
--- a/crates/consensus/auto-seal/src/lib.rs
+++ b/crates/consensus/auto-seal/src/lib.rs
@@ -269,6 +269,8 @@ impl StorageInner {
nonce: 0,
base_fee_per_gas,
extra_data: Default::default(),
+ blob_gas_used: None,
+ excess_blob_gas: None,
};
header.transactions_root = if transactions.is_empty() {
diff --git a/crates/consensus/beacon/Cargo.toml b/crates/consensus/beacon/Cargo.toml
index 6b23c39642b..76737b20e48 100644
--- a/crates/consensus/beacon/Cargo.toml
+++ b/crates/consensus/beacon/Cargo.toml
@@ -44,3 +44,12 @@ reth-revm = { path = "../../revm" }
reth-downloaders = { path = "../../net/downloaders" }
assert_matches = "1.5"
+
+[features]
+optimism = [
+ "reth-consensus-common/optimism",
+ "reth-primitives/optimism",
+ "reth-interfaces/optimism",
+ "reth-provider/optimism",
+ "reth-rpc-types/optimism",
+]
diff --git a/crates/consensus/beacon/src/engine/message.rs b/crates/consensus/beacon/src/engine/message.rs
index 2e5e542aab1..76808558595 100644
--- a/crates/consensus/beacon/src/engine/message.rs
+++ b/crates/consensus/beacon/src/engine/message.rs
@@ -145,6 +145,7 @@ impl Future for PendingPayloadId {
/// A message for the beacon engine from other components of the node (engine RPC API invoked by the
/// consensus layer).
#[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
pub enum BeaconEngineMessage {
/// Message with new payload.
NewPayload {
diff --git a/crates/consensus/common/Cargo.toml b/crates/consensus/common/Cargo.toml
index 8611aa2317f..72d057744cc 100644
--- a/crates/consensus/common/Cargo.toml
+++ b/crates/consensus/common/Cargo.toml
@@ -18,3 +18,6 @@ reth-interfaces = { workspace = true, features = ["test-utils"] }
reth-provider = { workspace = true, features = ["test-utils"] }
assert_matches = "1.5.0"
mockall = "0.11.3"
+
+[features]
+optimism = ["reth-primitives/optimism"]
diff --git a/crates/consensus/common/src/validation.rs b/crates/consensus/common/src/validation.rs
index 485d6146737..3aea32b5b45 100644
--- a/crates/consensus/common/src/validation.rs
+++ b/crates/consensus/common/src/validation.rs
@@ -1,12 +1,20 @@
//! Collection of methods for block validation.
use reth_interfaces::{consensus::ConsensusError, Result as RethResult};
use reth_primitives::{
- constants, BlockNumber, ChainSpec, Hardfork, Header, InvalidTransactionError, SealedBlock,
- SealedHeader, Transaction, TransactionSignedEcRecovered, TxEip1559, TxEip2930, TxLegacy,
+ blobfee::calculate_excess_blob_gas,
+ constants::{
+ self,
+ eip4844::{DATA_GAS_PER_BLOB, MAX_DATA_GAS_PER_BLOCK},
+ },
+ BlockNumber, ChainSpec, Hardfork, Header, InvalidTransactionError, SealedBlock, SealedHeader,
+ Transaction, TransactionSignedEcRecovered, TxEip1559, TxEip2930, TxLegacy,
};
use reth_provider::{AccountReader, HeaderProvider, WithdrawalsProvider};
use std::collections::{hash_map::Entry, HashMap};
+#[cfg(feature = "optimism")]
+use reth_primitives::TxDeposit;
+
/// Validate header standalone
pub fn validate_header_standalone(
header: &SealedHeader,
@@ -38,6 +46,15 @@ pub fn validate_header_standalone(
return Err(ConsensusError::WithdrawalsRootUnexpected)
}
+ // Ensures that EIP-4844 fields are valid once cancun is active.
+ if chain_spec.fork(Hardfork::Cancun).active_at_timestamp(header.timestamp) {
+ validate_4844_header_standalone(header)?;
+ } else if header.blob_gas_used.is_some() {
+ return Err(ConsensusError::BlobGasUsedUnexpected)
+ } else if header.excess_blob_gas.is_some() {
+ return Err(ConsensusError::ExcessBlobGasUnexpected)
+ }
+
Ok(())
}
@@ -86,6 +103,8 @@ pub fn validate_transaction_regarding_header(
Some(*chain_id)
}
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(TxDeposit { .. }) => None,
};
if let Some(chain_id) = chain_id {
if chain_id != chain_spec.chain().id() {
@@ -252,27 +271,32 @@ pub fn validate_header_regarding_parent(
// TODO Check difficulty increment between parent and child
// Ace age did increment it by some formula that we need to follow.
- let mut parent_gas_limit = parent.gas_limit;
+ // Check gas limit, max diff between child/parent gas_limit should be max_diff=parent_gas/1024
+ // On Optimism, the gas limit can adjust instantly, so we skip this check if the optimism
+ // feature flag is enabled.
+ #[cfg(not(feature = "optimism"))]
+ {
+ let mut parent_gas_limit = parent.gas_limit;
- // By consensus, gas_limit is multiplied by elasticity (*2) on
- // on exact block that hardfork happens.
- if chain_spec.fork(Hardfork::London).transitions_at_block(child.number) {
- parent_gas_limit = parent.gas_limit * constants::EIP1559_ELASTICITY_MULTIPLIER;
- }
+ // By consensus, gas_limit is multiplied by elasticity (*2) on
+ // on exact block that hardfork happens.
+ if chain_spec.fork(Hardfork::London).transitions_at_block(child.number) {
+ parent_gas_limit = parent.gas_limit * constants::EIP1559_ELASTICITY_MULTIPLIER;
+ }
- // Check gas limit, max diff between child/parent gas_limit should be max_diff=parent_gas/1024
- if child.gas_limit > parent_gas_limit {
- if child.gas_limit - parent_gas_limit >= parent_gas_limit / 1024 {
- return Err(ConsensusError::GasLimitInvalidIncrease {
+ if child.gas_limit > parent_gas_limit {
+ if child.gas_limit - parent_gas_limit >= parent_gas_limit / 1024 {
+ return Err(ConsensusError::GasLimitInvalidIncrease {
+ parent_gas_limit,
+ child_gas_limit: child.gas_limit,
+ })
+ }
+ } else if parent_gas_limit - child.gas_limit >= parent_gas_limit / 1024 {
+ return Err(ConsensusError::GasLimitInvalidDecrease {
parent_gas_limit,
child_gas_limit: child.gas_limit,
})
}
- } else if parent_gas_limit - child.gas_limit >= parent_gas_limit / 1024 {
- return Err(ConsensusError::GasLimitInvalidDecrease {
- parent_gas_limit,
- child_gas_limit: child.gas_limit,
- })
}
// EIP-1559 check base fee
@@ -291,6 +315,11 @@ pub fn validate_header_regarding_parent(
}
}
+ // ensure that the blob gas fields for this block
+ if chain_spec.fork(Hardfork::Cancun).active_at_timestamp(child.timestamp) {
+ validate_4844_header_with_parent(parent, child)?;
+ }
+
Ok(())
}
@@ -376,6 +405,72 @@ pub fn full_validation Result<(), ConsensusError> {
+ // From [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844#header-extension):
+ //
+ // > For the first post-fork block, both parent.blob_gas_used and parent.excess_blob_gas
+ // > are evaluated as 0.
+ //
+ // This means in the first post-fork block, calculate_excess_blob_gas will return 0.
+ let parent_blob_gas_used = parent.blob_gas_used.unwrap_or(0);
+ let parent_excess_blob_gas = parent.excess_blob_gas.unwrap_or(0);
+
+ if child.blob_gas_used.is_none() {
+ return Err(ConsensusError::BlobGasUsedMissing)
+ }
+ let excess_blob_gas = child.excess_blob_gas.ok_or(ConsensusError::ExcessBlobGasMissing)?;
+
+ let expected_excess_blob_gas =
+ calculate_excess_blob_gas(parent_excess_blob_gas, parent_blob_gas_used);
+ if expected_excess_blob_gas != excess_blob_gas {
+ return Err(ConsensusError::ExcessBlobGasDiff {
+ expected: expected_excess_blob_gas,
+ got: excess_blob_gas,
+ parent_excess_blob_gas,
+ parent_blob_gas_used,
+ })
+ }
+
+ Ok(())
+}
+
+/// Validates that the EIP-4844 header fields exist and conform to the spec. This ensures that:
+///
+/// * `blob_gas_used` exists as a header field
+/// * `excess_blob_gas` exists as a header field
+/// * `blob_gas_used` is less than or equal to `MAX_DATA_GAS_PER_BLOCK`
+/// * `blob_gas_used` is a multiple of `DATA_GAS_PER_BLOB`
+pub fn validate_4844_header_standalone(header: &SealedHeader) -> Result<(), ConsensusError> {
+ let blob_gas_used = header.blob_gas_used.ok_or(ConsensusError::BlobGasUsedMissing)?;
+
+ if header.excess_blob_gas.is_none() {
+ return Err(ConsensusError::ExcessBlobGasMissing)
+ }
+
+ if blob_gas_used > MAX_DATA_GAS_PER_BLOCK {
+ return Err(ConsensusError::BlobGasUsedExceedsMaxBlobGasPerBlock {
+ blob_gas_used,
+ max_blob_gas_per_block: MAX_DATA_GAS_PER_BLOCK,
+ })
+ }
+
+ if blob_gas_used % DATA_GAS_PER_BLOB != 0 {
+ return Err(ConsensusError::BlobGasUsedNotMultipleOfBlobGasPerBlob {
+ blob_gas_used,
+ blob_gas_per_blob: DATA_GAS_PER_BLOB,
+ })
+ }
+
+ Ok(())
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -530,6 +625,8 @@ mod tests {
nonce: 0x0000000000000000,
base_fee_per_gas: 0x28f0001df.into(),
withdrawals_root: None,
+ blob_gas_used: None,
+ excess_blob_gas: None,
};
// size: 0x9b5
diff --git a/crates/interfaces/Cargo.toml b/crates/interfaces/Cargo.toml
index c0525a77841..57ab3a7e9e2 100644
--- a/crates/interfaces/Cargo.toml
+++ b/crates/interfaces/Cargo.toml
@@ -54,4 +54,5 @@ secp256k1 = { workspace = true, features = [
[features]
test-utils = ["tokio-stream/sync", "secp256k1", "rand/std_rng"]
-cli = ["clap"]
\ No newline at end of file
+cli = ["clap"]
+optimism = ["reth-eth-wire/optimism"]
diff --git a/crates/interfaces/src/blockchain_tree/error.rs b/crates/interfaces/src/blockchain_tree/error.rs
index edcdb569bae..c2e463a7328 100644
--- a/crates/interfaces/src/blockchain_tree/error.rs
+++ b/crates/interfaces/src/blockchain_tree/error.rs
@@ -194,6 +194,9 @@ impl InsertBlockErrorKind {
BlockExecutionError::BlockHashNotFoundInChain { .. } |
BlockExecutionError::AppendChainDoesntConnect { .. } |
BlockExecutionError::UnavailableForTest => false,
+ #[cfg(feature = "optimism")]
+ BlockExecutionError::L1BlockInfoError { .. } |
+ BlockExecutionError::InsufficientFundsForL1Cost { .. } => false,
}
}
InsertBlockErrorKind::Tree(err) => {
diff --git a/crates/interfaces/src/consensus.rs b/crates/interfaces/src/consensus.rs
index 16f4d6c07ad..76c2175c9af 100644
--- a/crates/interfaces/src/consensus.rs
+++ b/crates/interfaces/src/consensus.rs
@@ -113,6 +113,27 @@ pub enum ConsensusError {
WithdrawalIndexInvalid { got: u64, expected: u64 },
#[error("Missing withdrawals")]
BodyWithdrawalsMissing,
+ #[error("Missing blob gas used")]
+ BlobGasUsedMissing,
+ #[error("Unexpected blob gas used")]
+ BlobGasUsedUnexpected,
+ #[error("Missing excess blob gas")]
+ ExcessBlobGasMissing,
+ #[error("Unexpected excess blob gas")]
+ ExcessBlobGasUnexpected,
+ #[error("Blob gas used {blob_gas_used} exceeds maximum allowance {max_blob_gas_per_block}")]
+ BlobGasUsedExceedsMaxBlobGasPerBlock { blob_gas_used: u64, max_blob_gas_per_block: u64 },
+ #[error(
+ "Blob gas used {blob_gas_used} is not a multiple of blob gas per blob {blob_gas_per_blob}"
+ )]
+ BlobGasUsedNotMultipleOfBlobGasPerBlob { blob_gas_used: u64, blob_gas_per_blob: u64 },
+ #[error("Invalid excess blob gas. Expected: {expected}, got: {got}. Parent excess blob gas: {parent_excess_blob_gas}, parent blob gas used: {parent_blob_gas_used}.")]
+ ExcessBlobGasDiff {
+ expected: u64,
+ got: u64,
+ parent_excess_blob_gas: u64,
+ parent_blob_gas_used: u64,
+ },
/// Error for a transaction that violates consensus.
#[error(transparent)]
InvalidTransaction(#[from] InvalidTransactionError),
diff --git a/crates/interfaces/src/executor.rs b/crates/interfaces/src/executor.rs
index cc747e29fdb..7f315688a35 100644
--- a/crates/interfaces/src/executor.rs
+++ b/crates/interfaces/src/executor.rs
@@ -42,7 +42,6 @@ pub enum BlockExecutionError {
CanonicalRevert { inner: String },
#[error("Transaction error on commit: {inner:?}")]
CanonicalCommit { inner: String },
-
// === tree errors ===
// TODO(mattsse): move this to tree error
#[error("Block hash {block_hash} not found in blockchain tree chain")]
@@ -57,6 +56,13 @@ pub enum BlockExecutionError {
/// Note: this is not feature gated for convenience.
#[error("Execution unavailable for tests")]
UnavailableForTest,
+
+ #[cfg(feature = "optimism")]
+ #[error("Could not get L1 block info from L2 block: {message:?}")]
+ L1BlockInfoError { message: String },
+ #[cfg(feature = "optimism")]
+ #[error("Insufficient funds to cover transaction L1 cost: want {want}, have {have}")]
+ InsufficientFundsForL1Cost { want: u64, have: u64 },
}
impl BlockExecutionError {
diff --git a/crates/interfaces/src/test_utils/generators.rs b/crates/interfaces/src/test_utils/generators.rs
index fbbdf42a212..d9399f8f814 100644
--- a/crates/interfaces/src/test_utils/generators.rs
+++ b/crates/interfaces/src/test_utils/generators.rs
@@ -349,6 +349,8 @@ pub fn random_receipt(
} else {
vec![]
},
+ #[cfg(feature = "optimism")]
+ deposit_nonce: None,
}
}
diff --git a/crates/net/downloaders/Cargo.toml b/crates/net/downloaders/Cargo.toml
index b5ca3d6b5b0..281dbfc6c78 100644
--- a/crates/net/downloaders/Cargo.toml
+++ b/crates/net/downloaders/Cargo.toml
@@ -32,7 +32,7 @@ thiserror.workspace = true
# optional deps for the test-utils feature
reth-rlp = { workspace = true, optional = true }
tempfile = { version = "3.3", optional = true }
-itertools = { version = "0.10", optional = true }
+itertools = { workspace = true, optional = true }
[dev-dependencies]
reth-db = { path = "../../storage/db", features = ["test-utils"] }
@@ -42,7 +42,7 @@ reth-tracing = { path = "../../tracing" }
assert_matches = "1.5.0"
tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
reth-rlp.workspace = true
-itertools = "0.10"
+itertools.workspace = true
tempfile = "3.3"
diff --git a/crates/net/eth-wire/Cargo.toml b/crates/net/eth-wire/Cargo.toml
index 19a78317c8a..f9477ca6074 100644
--- a/crates/net/eth-wire/Cargo.toml
+++ b/crates/net/eth-wire/Cargo.toml
@@ -64,6 +64,7 @@ proptest-derive = "0.3"
default = ["serde"]
serde = ["dep:serde", "smol_str/serde"]
arbitrary = ["reth-primitives/arbitrary", "dep:arbitrary", "dep:proptest", "dep:proptest-derive"]
+optimism = []
[[test]]
name = "fuzz_roundtrip"
diff --git a/crates/net/eth-wire/src/types/blocks.rs b/crates/net/eth-wire/src/types/blocks.rs
index 47777cd71b1..808c8f4a460 100644
--- a/crates/net/eth-wire/src/types/blocks.rs
+++ b/crates/net/eth-wire/src/types/blocks.rs
@@ -258,6 +258,8 @@ mod test {
nonce: 0x0000000000000000u64,
base_fee_per_gas: None,
withdrawals_root: None,
+ blob_gas_used: None,
+ excess_blob_gas: None,
},
]),
}.encode(&mut data);
@@ -289,6 +291,8 @@ mod test {
nonce: 0x0000000000000000u64,
base_fee_per_gas: None,
withdrawals_root: None,
+ blob_gas_used: None,
+ excess_blob_gas: None,
},
]),
};
@@ -401,6 +405,8 @@ mod test {
nonce: 0x0000000000000000u64,
base_fee_per_gas: None,
withdrawals_root: None,
+ blob_gas_used: None,
+ excess_blob_gas: None,
},
],
withdrawals: None,
@@ -485,6 +491,8 @@ mod test {
nonce: 0x0000000000000000u64,
base_fee_per_gas: None,
withdrawals_root: None,
+ blob_gas_used: None,
+ excess_blob_gas: None,
},
],
withdrawals: None,
diff --git a/crates/net/eth-wire/src/types/receipts.rs b/crates/net/eth-wire/src/types/receipts.rs
index f1bb3bc1209..af40108aa99 100644
--- a/crates/net/eth-wire/src/types/receipts.rs
+++ b/crates/net/eth-wire/src/types/receipts.rs
@@ -49,6 +49,8 @@ mod test {
success: false,
cumulative_gas_used: 0,
logs: vec![],
+ #[cfg(feature = "optimism")]
+ deposit_nonce: None,
},
bloom: Default::default(),
}]]);
@@ -102,10 +104,10 @@ mod test {
let mut data = vec![];
let request = RequestPair:: {
request_id: 1111,
- message: Receipts(vec![
- vec![
- ReceiptWithBloom {
- receipt: Receipt {tx_type: TxType::Legacy,
+ message: Receipts(vec![vec![
+ ReceiptWithBloom {
+ receipt: Receipt {
+ tx_type: TxType::Legacy,
cumulative_gas_used: 0x1u64,
logs: vec![
Log {
@@ -118,10 +120,12 @@ mod test {
},
],
success: false,
- },bloom: hex!("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").into(),
- }
- ],
- ]),
+ #[cfg(feature = "optimism")]
+ deposit_nonce: None,
+ },
+ bloom: hex!("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").into(),
+ },
+ ]]),
};
request.encode(&mut data);
assert_eq!(data, expected);
@@ -153,6 +157,8 @@ mod test {
},
],
success: false,
+ #[cfg(feature = "optimism")]
+ deposit_nonce: None,
},
bloom: hex!("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").into(),
},
diff --git a/crates/net/network/src/eth_requests.rs b/crates/net/network/src/eth_requests.rs
index 7cb4db72b37..10b53f61701 100644
--- a/crates/net/network/src/eth_requests.rs
+++ b/crates/net/network/src/eth_requests.rs
@@ -8,7 +8,7 @@ use reth_eth_wire::{
};
use reth_interfaces::p2p::error::RequestResult;
use reth_primitives::{BlockBody, BlockHashOrNumber, Header, HeadersDirection, PeerId};
-use reth_provider::{BlockReader, HeaderProvider};
+use reth_provider::{BlockReader, HeaderProvider, ReceiptProvider};
use std::{
borrow::Borrow,
future::Future,
@@ -21,6 +21,11 @@ use tokio_stream::wrappers::ReceiverStream;
// Limits:
+/// Maximum number of receipts to serve.
+///
+/// Used to limit lookups.
+const MAX_RECEIPTS_SERVE: usize = 1024;
+
/// Maximum number of block headers to serve.
///
/// Used to limit lookups.
@@ -32,6 +37,9 @@ const MAX_HEADERS_SERVE: usize = 1024;
/// SOFT_RESPONSE_LIMIT.
const MAX_BODIES_SERVE: usize = 1024;
+/// Estimated size in bytes of an RLP encoded receipt.
+const APPROX_RECEIPT_SIZE: usize = 24 * 1024;
+
/// Estimated size in bytes of an RLP encoded body.
// TODO: check 24kb blocksize assumption
const APPROX_BODY_SIZE: usize = 24 * 1024;
@@ -70,7 +78,7 @@ impl EthRequestHandler {
impl EthRequestHandler
where
- C: BlockReader + HeaderProvider,
+ C: BlockReader + HeaderProvider + ReceiptProvider,
{
/// Returns the list of requested headers
fn get_headers_response(&self, request: GetBlockHeaders) -> Vec {
@@ -185,6 +193,44 @@ where
let _ = response.send(Ok(BlockBodies(bodies)));
}
+
+ fn on_receipts_request(
+ &mut self,
+ _peer_id: PeerId,
+ request: GetReceipts,
+ response: oneshot::Sender>,
+ ) {
+ let mut receipts = Vec::new();
+
+ let mut total_bytes = APPROX_RECEIPT_SIZE;
+
+ for hash in request.0 {
+ if let Some(receipts_by_block) =
+ self.client.receipts_by_block(BlockHashOrNumber::Hash(hash)).unwrap_or_default()
+ {
+ receipts.push(
+ receipts_by_block
+ .into_iter()
+ .map(|receipt| receipt.with_bloom())
+ .collect::>(),
+ );
+
+ total_bytes += APPROX_RECEIPT_SIZE;
+
+ if total_bytes > SOFT_RESPONSE_LIMIT {
+ break
+ }
+
+ if receipts.len() >= MAX_RECEIPTS_SERVE {
+ break
+ }
+ } else {
+ break
+ }
+ }
+
+ let _ = response.send(Ok(Receipts(receipts)));
+ }
}
/// An endless future.
@@ -211,7 +257,9 @@ where
this.on_bodies_request(peer_id, request, response)
}
IncomingEthRequest::GetNodeData { .. } => {}
- IncomingEthRequest::GetReceipts { .. } => {}
+ IncomingEthRequest::GetReceipts { peer_id, request, response } => {
+ this.on_receipts_request(peer_id, request, response)
+ }
},
}
}
diff --git a/crates/payload/basic/Cargo.toml b/crates/payload/basic/Cargo.toml
index 874c9842d83..fd56911d338 100644
--- a/crates/payload/basic/Cargo.toml
+++ b/crates/payload/basic/Cargo.toml
@@ -29,3 +29,11 @@ futures-util.workspace = true
## misc
tracing.workspace = true
+
+[features]
+optimism = [
+ "reth-primitives/optimism",
+ "reth-revm/optimism",
+ "reth-transaction-pool/optimism",
+ "reth-provider/optimism"
+]
diff --git a/crates/payload/basic/src/lib.rs b/crates/payload/basic/src/lib.rs
index 84da180060d..3ed0a6873ce 100644
--- a/crates/payload/basic/src/lib.rs
+++ b/crates/payload/basic/src/lib.rs
@@ -659,6 +659,8 @@ fn build_payload(
success: result.is_success(),
cumulative_gas_used,
logs: result.logs().into_iter().map(into_reth_log).collect(),
+ #[cfg(feature = "optimism")]
+ deposit_nonce: None,
},
);
@@ -714,6 +716,8 @@ fn build_payload(
difficulty: U256::ZERO,
gas_used: cumulative_gas_used,
extra_data: extra_data.into(),
+ blob_gas_used: None,
+ excess_blob_gas: None,
};
// seal the block
@@ -785,6 +789,8 @@ where
difficulty: U256::ZERO,
gas_used: 0,
extra_data: extra_data.into(),
+ blob_gas_used: None,
+ excess_blob_gas: None,
};
let block = Block { header, body: vec![], ommers: vec![], withdrawals };
diff --git a/crates/payload/builder/Cargo.toml b/crates/payload/builder/Cargo.toml
index 664fae7039a..f243daee751 100644
--- a/crates/payload/builder/Cargo.toml
+++ b/crates/payload/builder/Cargo.toml
@@ -32,3 +32,9 @@ tracing.workspace = true
[features]
test-utils = []
+optimism = [
+ "reth-primitives/optimism",
+ "reth-rpc-types/optimism",
+ "reth-interfaces/optimism",
+ "reth-revm-primitives/optimism",
+]
diff --git a/crates/primitives/Cargo.toml b/crates/primitives/Cargo.toml
index cd4913698e2..bfdfcc9c846 100644
--- a/crates/primitives/Cargo.toml
+++ b/crates/primitives/Cargo.toml
@@ -22,7 +22,7 @@ crunchy = { version = "0.2.2", default-features = false, features = ["limit_256"
ruint = { version = "1.9.0", features = ["primitive-types", "rlp"] }
# Bloom
-fixed-hash = { version = "0.8", default-features = false, features = ["rustc-hex"] }
+ fixed-hash = { version = "0.8", default-features = false, features = ["rustc-hex"] }
# crypto
secp256k1 = { workspace = true, default-features = false, features = [
@@ -92,6 +92,7 @@ pprof = { version = "0.12", features = ["flamegraph", "frame-pointer", "criterio
default = []
arbitrary = ["revm-primitives/arbitrary", "dep:arbitrary", "dep:proptest", "dep:proptest-derive"]
test-utils = []
+optimism = []
[[bench]]
name = "recover_ecdsa_crit"
diff --git a/crates/primitives/res/genesis/goerli_op.json b/crates/primitives/res/genesis/goerli_op.json
new file mode 100644
index 00000000000..0ea4638d942
--- /dev/null
+++ b/crates/primitives/res/genesis/goerli_op.json
@@ -0,0 +1,92 @@
+{
+ "nonce": "0x00",
+ "timestamp": "0x00",
+ "extraData": "0x000000000000000000000000000000000000000000000000000000000000000027770a9694e4B4b1E130Ab91Bc327C36855f612E0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "difficulty": "0x01",
+ "gasLimit": "15000000",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "coinbase": "0x0000000000000000000000000000000000000000",
+ "gasUsed": "0x00",
+ "number": "0x00",
+ "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "stateRoot": "0x9e6b478a1cd331a979c39e4bddf42c676bcf5a63382f898dc441fe3fe5eb0837",
+ "alloc": {
+ "0x4200000000000000000000000000000000000000": {
+ "balance": "00",
+ "storage": {},
+ "code": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806382e3702d1461003b578063cafa81dc14610072575b600080fd5b61005e610049366004610112565b60006020819052908152604090205460ff1681565b604051901515815260200160405180910390f35b61008561008036600461015a565b610087565b005b6001600080833360405160200161009f929190610229565b604080518083037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe001815291815281516020928301208352908201929092520160002080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001691151591909117905550565b60006020828403121561012457600080fd5b5035919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60006020828403121561016c57600080fd5b813567ffffffffffffffff8082111561018457600080fd5b818401915084601f83011261019857600080fd5b8135818111156101aa576101aa61012b565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f011681019083821181831017156101f0576101f061012b565b8160405282815287602084870101111561020957600080fd5b826020860160208301376000928101602001929092525095945050505050565b6000835160005b8181101561024a5760208187018101518583015201610230565b81811115610259576000828501525b5060609390931b7fffffffffffffffffffffffffffffffffffffffff00000000000000000000000016919092019081526014019291505056fea26469706673582212209ffc0b44ce8a27c46cae74a3b3b620a72f10aaea97ed37c15b5d36792abd2aa464736f6c63430008090033"
+ },
+ "0x4200000000000000000000000000000000000002": {
+ "balance": "00",
+ "storage": {
+ "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000000000000000000000000000000000000000000000"
+ },
+ "code": "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"
+ },
+ "0x4200000000000000000000000000000000000007": {
+ "balance": "00",
+ "storage": {
+ "0x0000000000000000000000000000000000000000000000000000000000000004": "0x000000000000000000000000000000000000000000000000000000000000dead",
+ "0x0000000000000000000000000000000000000000000000000000000000000005": "0x0000000000000000000000005086d1eef304eb5284a0f6720f79403b4e9be294",
+ "0x0000000000000000000000000000000000000000000000000000000000000003": "0x00000000000000000000000000000000000000000000000000000000000186a0"
+ },
+ "code": "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"
+ },
+ "0x420000000000000000000000000000000000000F": {
+ "balance": "00",
+ "storage": {
+ "0x0000000000000000000000000000000000000000000000000000000000000000": "0x000000000000000000000000a693b8f8207ff043f6bbc2e2120bbe4c2251efe9",
+ "0x0000000000000000000000000000000000000000000000000000000000000001": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "0x0000000000000000000000000000000000000000000000000000000000000003": "0x0000000000000000000000000000000000000000000000000000000000000abe",
+ "0x0000000000000000000000000000000000000000000000000000000000000004": "0x000000000000000000000000000000000000000000000000000000000016e360",
+ "0x0000000000000000000000000000000000000000000000000000000000000005": "0x0000000000000000000000000000000000000000000000000000000000000006"
+ },
+ "code": "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"
+ },
+ "0x4200000000000000000000000000000000000010": {
+ "balance": "00",
+ "storage": {
+ "0x0000000000000000000000000000000000000000000000000000000000000001": "0x000000000000000000000000636af16bf2f682dd3109e60102b8e1a089fedaa8",
+ "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000004200000000000000000000000000000000000007"
+ },
+ "code": "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"
+ },
+ "0x4200000000000000000000000000000000000011": {
+ "balance": "00",
+ "storage": {
+ "0x0000000000000000000000000000000000000000000000000000000000000000": "0x000000000000000000000000fd1d2e729ae8eee2e146c033bf4400fe75284301"
+ },
+ "code": "0x6080604052600436106100385760003560e01c80633ccfd60b14610044578063d3e5792b1461005b578063d4ff92181461008a57600080fd5b3661003f57005b600080fd5b34801561005057600080fd5b506100596100dc565b005b34801561006757600080fd5b5061007767d02ab486cedc000081565b6040519081526020015b60405180910390f35b34801561009657600080fd5b506000546100b79073ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610081565b67d02ab486cedc000047101561019e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152605760248201527f4f564d5f53657175656e6365724665655661756c743a2077697468647261776160448201527f6c20616d6f756e74206d7573742062652067726561746572207468616e206d6960648201527f6e696d756d207769746864726177616c20616d6f756e74000000000000000000608482015260a40160405180910390fd5b600080546040805160208101825283815290517fa3a795480000000000000000000000000000000000000000000000000000000081527342000000000000000000000000000000000000109363a3a79548936102309373deaddeaddeaddeaddeaddeaddeaddeaddead00009373ffffffffffffffffffffffffffffffffffffffff909216924792909190600401610264565b600060405180830381600087803b15801561024a57600080fd5b505af115801561025e573d6000803e3d6000fd5b50505050565b600073ffffffffffffffffffffffffffffffffffffffff808816835260208188168185015286604085015263ffffffff8616606085015260a06080850152845191508160a085015260005b828110156102cb5785810182015185820160c0015281016102af565b828111156102dd57600060c084870101525b5050601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169190910160c001969550505050505056fea2646970667358221220387a6116dde263ea48767352a397053c8cffa776aecb43cded2f25a4a9cfbdc264736f6c63430008090033"
+ },
+ "0x4200000000000000000000000000000000000012": {
+ "balance": "00",
+ "storage": {},
+ "code": "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"
+ },
+ "0x4200000000000000000000000000000000000013": {
+ "balance": "00",
+ "storage": {},
+ "code": "0x4B60005260206000F3"
+ },
+ "0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000": {
+ "balance": "00",
+ "storage": {
+ "0x0000000000000000000000000000000000000000000000000000000000000006": "0x0000000000000000000000004200000000000000000000000000000000000010",
+ "0x0000000000000000000000000000000000000000000000000000000000000005": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "0x0000000000000000000000000000000000000000000000000000000000000003": "0x457468657200000000000000000000000000000000000000000000000000000a",
+ "0x0000000000000000000000000000000000000000000000000000000000000004": "0x4554480000000000000000000000000000000000000000000000000000000006"
+ },
+ "code": "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"
+ },
+ "0x4200000000000000000000000000000000000006": {
+ "balance": "00",
+ "storage": {
+ "0x0000000000000000000000000000000000000000000000000000000000000000": "0x577261707065642045746865720000000000000000000000000000000000001a",
+ "0x0000000000000000000000000000000000000000000000000000000000000001": "0x5745544800000000000000000000000000000000000000000000000000000008",
+ "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000000012"
+ },
+ "code": "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"
+ }
+ }
+}
diff --git a/crates/primitives/src/blobfee.rs b/crates/primitives/src/blobfee.rs
new file mode 100644
index 00000000000..e82b5d2f8c6
--- /dev/null
+++ b/crates/primitives/src/blobfee.rs
@@ -0,0 +1,12 @@
+//! Helpers for working with EIP-4844 blob fee
+
+use crate::constants::eip4844::TARGET_DATA_GAS_PER_BLOCK;
+
+/// Calculates the excess data gas for the next block, after applying the current set of blobs on
+/// top of the excess data gas.
+///
+/// Specified in [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844#header-extension)
+pub fn calculate_excess_blob_gas(parent_excess_blob_gas: u64, parent_blob_gas_used: u64) -> u64 {
+ let excess_blob_gas = parent_excess_blob_gas + parent_blob_gas_used;
+ excess_blob_gas.saturating_sub(TARGET_DATA_GAS_PER_BLOCK)
+}
diff --git a/crates/primitives/src/chain/mod.rs b/crates/primitives/src/chain/mod.rs
index b46519f3256..c8368a50227 100644
--- a/crates/primitives/src/chain/mod.rs
+++ b/crates/primitives/src/chain/mod.rs
@@ -14,6 +14,9 @@ pub use spec::{
ForkTimestamps, DEV, GOERLI, MAINNET, SEPOLIA,
};
+#[cfg(feature = "optimism")]
+pub use spec::OP_GOERLI;
+
// The chain info module.
mod info;
pub use info::ChainInfo;
@@ -44,6 +47,18 @@ impl Chain {
Chain::Named(ethers_core::types::Chain::Sepolia)
}
+ /// Returns the optimism goerli chain.
+ #[cfg(feature = "optimism")]
+ pub const fn optimism_goerli() -> Self {
+ Chain::Named(ethers_core::types::Chain::OptimismGoerli)
+ }
+
+ /// Returns the optimism mainnet chain.
+ #[cfg(feature = "optimism")]
+ pub const fn optimism_mainnet() -> Self {
+ Chain::Named(ethers_core::types::Chain::Optimism)
+ }
+
/// Returns the dev chain.
pub const fn dev() -> Self {
Chain::Named(ethers_core::types::Chain::Dev)
diff --git a/crates/primitives/src/chain/spec.rs b/crates/primitives/src/chain/spec.rs
index 356c9409b7e..552c1017df2 100644
--- a/crates/primitives/src/chain/spec.rs
+++ b/crates/primitives/src/chain/spec.rs
@@ -54,6 +54,8 @@ pub static MAINNET: Lazy> = Lazy::new(|| {
),
(Hardfork::Shanghai, ForkCondition::Timestamp(1681338455)),
]),
+ #[cfg(feature = "optimism")]
+ optimism: None,
}
.into()
});
@@ -88,6 +90,8 @@ pub static GOERLI: Lazy> = Lazy::new(|| {
),
(Hardfork::Shanghai, ForkCondition::Timestamp(1678832736)),
]),
+ #[cfg(feature = "optimism")]
+ optimism: None,
}
.into()
});
@@ -126,6 +130,8 @@ pub static SEPOLIA: Lazy> = Lazy::new(|| {
),
(Hardfork::Shanghai, ForkCondition::Timestamp(1677557088)),
]),
+ #[cfg(feature = "optimism")]
+ optimism: None,
}
.into()
});
@@ -163,6 +169,39 @@ pub static DEV: Lazy> = Lazy::new(|| {
),
(Hardfork::Shanghai, ForkCondition::Timestamp(0)),
]),
+ #[cfg(feature = "optimism")]
+ optimism: None,
+ }
+ .into()
+});
+
+/// The Optimism Goerli spec
+#[cfg(feature = "optimism")]
+pub static OP_GOERLI: Lazy> = Lazy::new(|| {
+ ChainSpec {
+ chain: Chain::optimism_goerli(),
+ genesis: serde_json::from_str(include_str!("../../res/genesis/goerli_op.json"))
+ .expect("Can't deserialize Optimism Goerli genesis json"),
+ genesis_hash: Some(H256(hex!(
+ "c1fc15cd51159b1f1e5cbc4b82e85c1447ddfa33c52cf1d98d14fba0d6354be1"
+ ))),
+ fork_timestamps: ForkTimestamps::default(), // TODO(clabby): update this
+ paris_block_and_final_difficulty: Some((0, U256::from(0))),
+ hardforks: BTreeMap::from([
+ (Hardfork::Byzantium, ForkCondition::Block(0)),
+ (Hardfork::Constantinople, ForkCondition::Block(0)),
+ (Hardfork::Petersburg, ForkCondition::Block(0)),
+ (Hardfork::Istanbul, ForkCondition::Block(0)),
+ (Hardfork::MuirGlacier, ForkCondition::Block(0)),
+ (Hardfork::Berlin, ForkCondition::Block(0)),
+ (Hardfork::London, ForkCondition::Block(0)),
+ (
+ Hardfork::Paris,
+ ForkCondition::TTD { fork_block: Some(0), total_difficulty: U256::from(0) },
+ ),
+ (Hardfork::Regolith, ForkCondition::Timestamp(1679079600)),
+ ]),
+ optimism: Some(OptimismConfig { eip_1559_elasticity: 10, eip_1559_denominator: 50 }),
}
.into()
});
@@ -201,6 +240,20 @@ pub struct ChainSpec {
/// The active hard forks and their activation conditions
pub hardforks: BTreeMap,
+
+ /// Optimism configuration
+ #[cfg(feature = "optimism")]
+ pub optimism: Option,
+}
+
+/// Optimism configuration.
+#[cfg(feature = "optimism")]
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct OptimismConfig {
+ /// Elasticity multiplier as defined in [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)
+ pub eip_1559_elasticity: u64,
+ /// Base fee max change denominator as defined in [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)
+ pub eip_1559_denominator: u64,
}
impl ChainSpec {
@@ -306,6 +359,15 @@ impl ChainSpec {
.unwrap_or_else(|| self.is_fork_active_at_timestamp(Hardfork::Shanghai, timestamp))
}
+ /// Convenience method to check if [Hardfork::Cancun] is active at a given timestamp.
+ #[inline]
+ pub fn is_cancun_activated_at_timestamp(&self, timestamp: u64) -> bool {
+ self.fork_timestamps
+ .cancun
+ .map(|cancun| timestamp >= cancun)
+ .unwrap_or_else(|| self.is_fork_active_at_timestamp(Hardfork::Cancun, timestamp))
+ }
+
/// Creates a [`ForkFilter`](crate::ForkFilter) for the block described by [Head].
pub fn fork_filter(&self, head: Head) -> ForkFilter {
let forks = self.forks_iter().filter_map(|(_, condition)| {
@@ -424,6 +486,8 @@ impl From for ChainSpec {
fork_timestamps: ForkTimestamps::from_hardforks(&hardforks),
hardforks,
paris_block_and_final_difficulty: None,
+ #[cfg(feature = "optimism")]
+ optimism: None,
}
}
}
@@ -433,6 +497,8 @@ impl From for ChainSpec {
pub struct ForkTimestamps {
/// The timestamp of the shanghai fork
pub shanghai: Option,
+ /// The timestamp of the cancun fork
+ pub cancun: Option,
}
impl ForkTimestamps {
@@ -442,6 +508,9 @@ impl ForkTimestamps {
if let Some(shanghai) = forks.get(&Hardfork::Shanghai).and_then(|f| f.as_timestamp()) {
timestamps = timestamps.shanghai(shanghai);
}
+ if let Some(cancun) = forks.get(&Hardfork::Cancun).and_then(|f| f.as_timestamp()) {
+ timestamps = timestamps.cancun(cancun);
+ }
timestamps
}
@@ -450,6 +519,12 @@ impl ForkTimestamps {
self.shanghai = Some(shanghai);
self
}
+
+ /// Sets the given cancun timestamp
+ pub fn cancun(mut self, cancun: u64) -> Self {
+ self.cancun = Some(cancun);
+ self
+ }
}
/// A helper type for compatibility with geth's config
@@ -495,6 +570,8 @@ pub struct ChainSpecBuilder {
chain: Option,
genesis: Option,
hardforks: BTreeMap,
+ #[cfg(feature = "optimism")]
+ optimism: Option,
}
impl ChainSpecBuilder {
@@ -504,6 +581,8 @@ impl ChainSpecBuilder {
chain: Some(MAINNET.chain),
genesis: Some(MAINNET.genesis.clone()),
hardforks: MAINNET.hardforks.clone(),
+ #[cfg(feature = "optimism")]
+ optimism: None,
}
}
@@ -614,6 +693,29 @@ impl ChainSpecBuilder {
self
}
+ /// Enable Cancun at genesis.
+ pub fn cancun_activated(mut self) -> Self {
+ self = self.paris_activated();
+ self.hardforks.insert(Hardfork::Cancun, ForkCondition::Timestamp(0));
+ self
+ }
+
+ /// Enable Bedrock at genesis
+ #[cfg(feature = "optimism")]
+ pub fn bedrock_activated(mut self) -> Self {
+ self = self.london_activated();
+ self.hardforks.insert(Hardfork::Bedrock, ForkCondition::Block(0));
+ self
+ }
+
+ /// Enable Regolith at genesis
+ #[cfg(feature = "optimism")]
+ pub fn regolith_activated(mut self) -> Self {
+ self = self.bedrock_activated();
+ self.hardforks.insert(Hardfork::Regolith, ForkCondition::Block(0));
+ self
+ }
+
/// Build the resulting [`ChainSpec`].
///
/// # Panics
@@ -628,6 +730,8 @@ impl ChainSpecBuilder {
fork_timestamps: ForkTimestamps::from_hardforks(&self.hardforks),
hardforks: self.hardforks,
paris_block_and_final_difficulty: None,
+ #[cfg(feature = "optimism")]
+ optimism: self.optimism,
}
}
}
@@ -638,6 +742,8 @@ impl From<&Arc> for ChainSpecBuilder {
chain: Some(value.chain),
genesis: Some(value.genesis.clone()),
hardforks: value.hardforks.clone(),
+ #[cfg(feature = "optimism")]
+ optimism: value.optimism.clone(),
}
}
}
@@ -930,6 +1036,10 @@ mod tests {
use bytes::BytesMut;
use ethers_core::types as EtherType;
use reth_rlp::Encodable;
+
+ #[cfg(feature = "optimism")]
+ use crate::OP_GOERLI;
+
fn test_fork_ids(spec: &ChainSpec, cases: &[(Head, ForkId)]) {
for (block, expected_id) in cases {
let computed_id = spec.fork_id(block);
@@ -1236,6 +1346,28 @@ Post-merge hard forks (timestamp based):
)
}
+ #[cfg(feature = "optimism")]
+ #[test]
+ fn optimism_goerli_forkids() {
+ test_fork_ids(
+ &OP_GOERLI,
+ &[
+ (
+ Head { number: 0, ..Default::default() },
+ ForkId { hash: ForkHash([0x6d, 0x63, 0x76, 0xbe]), next: 1679079600 },
+ ),
+ (
+ Head { number: 4061224, timestamp: 1679079599, ..Default::default() },
+ ForkId { hash: ForkHash([0x6d, 0x63, 0x76, 0xbe]), next: 1679079600 },
+ ),
+ (
+ Head { number: 4061224, timestamp: 1679079600, ..Default::default() },
+ ForkId { hash: ForkHash([0x8e, 0x32, 0xcc, 0x21]), next: 0 },
+ ),
+ ],
+ );
+ }
+
/// Checks that time-based forks work
///
/// This is based off of the test vectors here: https://github.com/ethereum/go-ethereum/blob/5c8cc10d1e05c23ff1108022f4150749e73c0ca1/core/forkid/forkid_test.go#L155-L188
diff --git a/crates/primitives/src/constants/mod.rs b/crates/primitives/src/constants/mod.rs
index 96c55cbbe11..6a5c5fefbeb 100644
--- a/crates/primitives/src/constants/mod.rs
+++ b/crates/primitives/src/constants/mod.rs
@@ -51,11 +51,21 @@ pub const MIN_PROTOCOL_BASE_FEE_U256: U256 = U256::from_limbs([7u64, 0, 0, 0]);
pub const EIP1559_INITIAL_BASE_FEE: u64 = 1_000_000_000;
/// Base fee max change denominator as defined in [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)
+#[cfg(not(feature = "optimism"))]
pub const EIP1559_BASE_FEE_MAX_CHANGE_DENOMINATOR: u64 = 8;
/// Elasticity multiplier as defined in [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)
+#[cfg(not(feature = "optimism"))]
pub const EIP1559_ELASTICITY_MULTIPLIER: u64 = 2;
+/// Base fee max change denominator for Optimism.
+#[cfg(feature = "optimism")]
+pub const EIP1559_BASE_FEE_MAX_CHANGE_DENOMINATOR: u64 = 50;
+
+/// Elasticity multiplier for Optimism.
+#[cfg(feature = "optimism")]
+pub const EIP1559_ELASTICITY_MULTIPLIER: u64 = 10;
+
/// Multiplier for converting gwei to wei.
pub const GWEI_TO_WEI: u64 = 1_000_000_000;
@@ -84,6 +94,11 @@ pub const SEPOLIA_GENESIS: H256 =
pub const DEV_GENESIS: H256 =
H256(hex!("2f980576711e3617a5e4d83dd539548ec0f7792007d505a3d2e9674833af2d7c"));
+/// Optimism goerli genesis hash.
+#[cfg(feature = "optimism")]
+pub const GOERLI_OP_GENESIS: H256 =
+ H256(hex!("c1fc15cd51159b1f1e5cbc4b82e85c1447ddfa33c52cf1d98d14fba0d6354be1"));
+
/// Keccak256 over empty array.
pub const KECCAK_EMPTY: H256 =
H256(hex!("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"));
diff --git a/crates/primitives/src/hardfork.rs b/crates/primitives/src/hardfork.rs
index f26ffbcc403..b0f5dfde04a 100644
--- a/crates/primitives/src/hardfork.rs
+++ b/crates/primitives/src/hardfork.rs
@@ -39,6 +39,14 @@ pub enum Hardfork {
Paris,
/// Shanghai.
Shanghai,
+ /// Cancun.
+ Cancun,
+ /// Bedrock.
+ #[cfg(feature = "optimism")]
+ Bedrock,
+ /// Regolith
+ #[cfg(feature = "optimism")]
+ Regolith,
}
impl Hardfork {
@@ -82,6 +90,11 @@ impl FromStr for Hardfork {
"grayglacier" => Hardfork::GrayGlacier,
"paris" => Hardfork::Paris,
"shanghai" => Hardfork::Shanghai,
+ "cancun" => Hardfork::Cancun,
+ #[cfg(feature = "optimism")]
+ "bedrock" => Hardfork::Bedrock,
+ #[cfg(feature = "optimism")]
+ "regolith" => Hardfork::Regolith,
_ => return Err(format!("Unknown hardfork: {s}")),
};
Ok(hardfork)
@@ -97,7 +110,6 @@ impl Display for Hardfork {
#[cfg(test)]
mod tests {
use super::*;
-
use crate::{Chain, Genesis};
use std::collections::BTreeMap;
@@ -120,6 +132,7 @@ mod tests {
"grayglacier",
"PARIS",
"ShAnGhAI",
+ "CaNcUn",
];
let expected_hardforks = [
Hardfork::Frontier,
@@ -138,6 +151,7 @@ mod tests {
Hardfork::GrayGlacier,
Hardfork::Paris,
Hardfork::Shanghai,
+ Hardfork::Cancun,
];
let hardforks: Vec =
@@ -146,6 +160,18 @@ mod tests {
assert_eq!(hardforks, expected_hardforks);
}
+ #[test]
+ #[cfg(feature = "optimism")]
+ fn check_op_hardfork_from_str() {
+ let hardfork_str = ["beDrOck", "rEgOlITH"];
+ let expected_hardforks = [Hardfork::Bedrock, Hardfork::Regolith];
+
+ let hardforks: Vec =
+ hardfork_str.iter().map(|h| Hardfork::from_str(h).unwrap()).collect();
+
+ assert_eq!(hardforks, expected_hardforks);
+ }
+
#[test]
fn check_nonexistent_hardfork_from_str() {
assert!(Hardfork::from_str("not a hardfork").is_err());
@@ -160,6 +186,8 @@ mod tests {
hardforks: BTreeMap::from([(Hardfork::Frontier, ForkCondition::Never)]),
fork_timestamps: Default::default(),
paris_block_and_final_difficulty: None,
+ #[cfg(feature = "optimism")]
+ optimism: None,
};
assert_eq!(Hardfork::Frontier.fork_id(&spec), None);
@@ -174,6 +202,8 @@ mod tests {
hardforks: BTreeMap::from([(Hardfork::Shanghai, ForkCondition::Never)]),
fork_timestamps: Default::default(),
paris_block_and_final_difficulty: None,
+ #[cfg(feature = "optimism")]
+ optimism: None,
};
assert_eq!(Hardfork::Shanghai.fork_filter(&spec), None);
diff --git a/crates/primitives/src/header.rs b/crates/primitives/src/header.rs
index ba8e8f31deb..e39c6a8287a 100644
--- a/crates/primitives/src/header.rs
+++ b/crates/primitives/src/header.rs
@@ -1,5 +1,6 @@
use crate::{
basefee::calculate_next_block_base_fee,
+ blobfee::calculate_excess_blob_gas,
keccak256,
proofs::{EMPTY_LIST_HASH, EMPTY_ROOT},
BlockBodyRoots, BlockHash, BlockNumHash, BlockNumber, Bloom, Bytes, H160, H256, H64, U256,
@@ -7,7 +8,7 @@ use crate::{
use bytes::{Buf, BufMut, BytesMut};
use reth_codecs::{add_arbitrary_tests, derive_arbitrary, main_codec, Compact};
-use reth_rlp::{length_of_length, Decodable, Encodable, EMPTY_STRING_CODE};
+use reth_rlp::{length_of_length, Decodable, Encodable, EMPTY_LIST_CODE, EMPTY_STRING_CODE};
use serde::{Deserialize, Serialize};
use std::{
mem,
@@ -91,6 +92,13 @@ pub struct Header {
/// above the gas target, and decreasing when blocks are below the gas target. The base fee per
/// gas is burned.
pub base_fee_per_gas: Option,
+ /// The total amount of blob gas consumed by the transactions within the block, added in
+ /// EIP-4844.
+ pub blob_gas_used: Option,
+ /// A running total of blob gas consumed in excess of the target, prior to the block. Blocks
+ /// with above-target blob gas consumption increase this value, blocks with below-target blob
+ /// gas consumption decrease it (bounded at 0). This was added in EIP-4844.
+ pub excess_blob_gas: Option,
/// An arbitrary byte array containing data relevant to this block. This must be 32 bytes or
/// fewer; formally Hx.
pub extra_data: Bytes,
@@ -116,6 +124,8 @@ impl Default for Header {
nonce: 0,
base_fee_per_gas: None,
withdrawals_root: None,
+ blob_gas_used: None,
+ excess_blob_gas: None,
}
}
}
@@ -170,6 +180,13 @@ impl Header {
Some(calculate_next_block_base_fee(self.gas_used, self.gas_limit, self.base_fee_per_gas?))
}
+ /// Calculate excess blob gas for the next block according to the EIP-4844 spec.
+ ///
+ /// Returns a `None` if no excess blob gas is set, no EIP-4844 support
+ pub fn next_block_excess_blob_gas(&self) -> Option {
+ Some(calculate_excess_blob_gas(self.excess_blob_gas?, self.blob_gas_used?))
+ }
+
/// Seal the header with a known hash.
///
/// WARNING: This method does not perform validation whether the hash is correct.
@@ -202,6 +219,8 @@ impl Header {
mem::size_of::() + // mix hash
mem::size_of::() + // nonce
mem::size_of::>() + // base fee per gas
+ mem::size_of::>() + // blob gas used
+ mem::size_of::>() + // excess blob gas
self.extra_data.len() // extra data
}
@@ -225,11 +244,34 @@ impl Header {
if let Some(base_fee) = self.base_fee_per_gas {
length += U256::from(base_fee).length();
- } else if self.withdrawals_root.is_some() {
- length += 1; // EMTY STRING CODE
+ } else if self.withdrawals_root.is_some() ||
+ self.blob_gas_used.is_some() ||
+ self.excess_blob_gas.is_some()
+ {
+ length += 1; // EMPTY STRING CODE
}
+
if let Some(root) = self.withdrawals_root {
length += root.length();
+ } else if self.blob_gas_used.is_some() || self.excess_blob_gas.is_some() {
+ length += 1; // EMPTY STRING CODE
+ }
+
+ if let Some(blob_gas_used) = self.blob_gas_used {
+ length += U256::from(blob_gas_used).length();
+ } else if self.excess_blob_gas.is_some() {
+ length += 1; // EMPTY STRING CODE
+ }
+
+ // Encode excess blob gas length. If new fields are added, the above pattern will need to
+ // be repeated and placeholder length added. Otherwise, it's impossible to tell _which_
+ // fields are missing. This is mainly relevant for contrived cases where a header is
+ // created at random, for example:
+ // * A header is created with a withdrawals root, but no base fee. Shanghai blocks are
+ // post-London, so this is technically not valid. However, a tool like proptest would
+ // generate a block like this.
+ if let Some(excess_blob_gas) = self.excess_blob_gas {
+ length += U256::from(excess_blob_gas).length();
}
length
@@ -261,12 +303,38 @@ impl Encodable for Header {
// but withdrawals root is present.
if let Some(ref base_fee) = self.base_fee_per_gas {
U256::from(*base_fee).encode(out);
- } else if self.withdrawals_root.is_some() {
+ } else if self.withdrawals_root.is_some() ||
+ self.blob_gas_used.is_some() ||
+ self.excess_blob_gas.is_some()
+ {
out.put_u8(EMPTY_STRING_CODE);
}
+ // Encode withdrawals root. Put empty string if withdrawals root is missing,
+ // but blob gas used is present.
if let Some(ref root) = self.withdrawals_root {
root.encode(out);
+ } else if self.blob_gas_used.is_some() || self.excess_blob_gas.is_some() {
+ out.put_u8(EMPTY_STRING_CODE);
+ }
+
+ // Encode blob gas used. Put empty string if blob gas used is missing,
+ // but excess blob gas is present.
+ if let Some(ref blob_gas_used) = self.blob_gas_used {
+ U256::from(*blob_gas_used).encode(out);
+ } else if self.excess_blob_gas.is_some() {
+ out.put_u8(EMPTY_LIST_CODE);
+ }
+
+ // Encode excess blob gas. If new fields are added, the above pattern will need to be
+ // repeated and placeholders added. Otherwise, it's impossible to tell _which_ fields
+ // are missing. This is mainly relevant for contrived cases where a header is created
+ // at random, for example:
+ // * A header is created with a withdrawals root, but no base fee. Shanghai blocks are
+ // post-London, so this is technically not valid. However, a tool like proptest would
+ // generate a block like this.
+ if let Some(ref excess_blob_gas) = self.excess_blob_gas {
+ U256::from(*excess_blob_gas).encode(out);
}
}
@@ -303,7 +371,10 @@ impl Decodable for Header {
nonce: H64::decode(buf)?.to_low_u64_be(),
base_fee_per_gas: None,
withdrawals_root: None,
+ blob_gas_used: None,
+ excess_blob_gas: None,
};
+
if started_len - buf.len() < rlp_head.payload_length {
if buf.first().map(|b| *b == EMPTY_STRING_CODE).unwrap_or_default() {
buf.advance(1)
@@ -311,9 +382,36 @@ impl Decodable for Header {
this.base_fee_per_gas = Some(U256::decode(buf)?.to::());
}
}
+
+ // Withdrawals root for post-shanghai headers
+ if started_len - buf.len() < rlp_head.payload_length {
+ if buf.first().map(|b| *b == EMPTY_STRING_CODE).unwrap_or_default() {
+ buf.advance(1)
+ } else {
+ this.withdrawals_root = Some(Decodable::decode(buf)?);
+ }
+ }
+
+ // Blob gas used and excess blob gas for post-cancun headers
+ if started_len - buf.len() < rlp_head.payload_length {
+ if buf.first().map(|b| *b == EMPTY_LIST_CODE).unwrap_or_default() {
+ buf.advance(1)
+ } else {
+ this.blob_gas_used = Some(U256::decode(buf)?.to::());
+ }
+ }
+
+ // Decode excess blob gas. If new fields are added, the above pattern will need to be
+ // repeated and placeholders decoded. Otherwise, it's impossible to tell _which_ fields are
+ // missing. This is mainly relevant for contrived cases where a header is created at
+ // random, for example:
+ // * A header is created with a withdrawals root, but no base fee. Shanghai blocks are
+ // post-London, so this is technically not valid. However, a tool like proptest would
+ // generate a block like this.
if started_len - buf.len() < rlp_head.payload_length {
- this.withdrawals_root = Some(Decodable::decode(buf)?);
+ this.excess_blob_gas = Some(U256::decode(buf)?.to::());
}
+
let consumed = started_len - buf.len();
if consumed != rlp_head.payload_length {
return Err(reth_rlp::DecodeError::ListLengthMismatch {
@@ -536,6 +634,8 @@ mod ethers_compat {
gas_used: block.gas_used.as_u64(),
withdrawals_root: None,
logs_bloom: block.logs_bloom.unwrap_or_default().0.into(),
+ blob_gas_used: None,
+ excess_blob_gas: None,
}
}
}
@@ -605,6 +705,8 @@ mod tests {
nonce: 0,
base_fee_per_gas: Some(0x036b_u64),
withdrawals_root: None,
+ blob_gas_used: None,
+ excess_blob_gas: None,
};
assert_eq!(header.hash_slow(), expected_hash);
}
@@ -683,6 +785,120 @@ mod tests {
assert_eq!(header.hash_slow(), expected_hash);
}
+ // Test vector from: https://github.com/ethereum/tests/blob/7e9e0940c0fcdbead8af3078ede70f969109bd85/BlockchainTests/ValidBlocks/bcExample/cancunExample.json
+ #[test]
+ fn test_decode_block_header_with_blob_fields_ef_tests() {
+ let data = hex::decode("f90221a03a9b485972e7353edd9152712492f0c58d89ef80623686b6bf947a4a6dce6cb6a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347942adc25665018aa1fe0e6bc666dac8fc2697ff9baa03c837fc158e3e93eafcaf2e658a02f5d8f99abc9f1c4c66cdea96c0ca26406aea04409cc4b699384ba5f8248d92b784713610c5ff9c1de51e9239da0dac76de9cea046cab26abf1047b5b119ecc2dda1296b071766c8b1307e1381fcecc90d513d86b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008001887fffffffffffffff8302a86582079e42a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b42188000000000000000009a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b4218302000080").unwrap();
+ let expected = Header {
+ parent_hash: H256::from_str(
+ "3a9b485972e7353edd9152712492f0c58d89ef80623686b6bf947a4a6dce6cb6",
+ )
+ .unwrap(),
+ ommers_hash: H256::from_str(
+ "1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ )
+ .unwrap(),
+ beneficiary: Address::from_str("2adc25665018aa1fe0e6bc666dac8fc2697ff9ba").unwrap(),
+ state_root: H256::from_str(
+ "3c837fc158e3e93eafcaf2e658a02f5d8f99abc9f1c4c66cdea96c0ca26406ae",
+ )
+ .unwrap(),
+ transactions_root: H256::from_str(
+ "4409cc4b699384ba5f8248d92b784713610c5ff9c1de51e9239da0dac76de9ce",
+ )
+ .unwrap(),
+ receipts_root: H256::from_str(
+ "46cab26abf1047b5b119ecc2dda1296b071766c8b1307e1381fcecc90d513d86",
+ )
+ .unwrap(),
+ logs_bloom: Default::default(),
+ difficulty: U256::from(0),
+ number: 0x1,
+ gas_limit: 0x7fffffffffffffff,
+ gas_used: 0x02a865,
+ timestamp: 0x079e,
+ extra_data: Bytes::from(vec![0x42]),
+ mix_hash: H256::from_str(
+ "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+ )
+ .unwrap(),
+ nonce: 0,
+ base_fee_per_gas: Some(9),
+ withdrawals_root: Some(
+ H256::from_str("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
+ .unwrap(),
+ ),
+ blob_gas_used: Some(0x020000),
+ excess_blob_gas: Some(0),
+ };
+
+ let header = Header::decode(&mut data.as_slice()).unwrap();
+ assert_eq!(header, expected);
+
+ let expected_hash =
+ H256::from_str("0x10aca3ebb4cf6ddd9e945a5db19385f9c105ede7374380c50d56384c3d233785")
+ .unwrap();
+ assert_eq!(header.hash_slow(), expected_hash);
+ }
+
+ #[test]
+ fn test_decode_block_header_with_blob_fields() {
+ // Block from devnet-7
+ let data = hex::decode("f90239a013a7ec98912f917b3e804654e37c9866092043c13eb8eab94eb64818e886cff5a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794f97e180c050e5ab072211ad2c213eb5aee4df134a0ec229dbe85b0d3643ad0f471e6ec1a36bbc87deffbbd970762d22a53b35d068aa056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080830305988401c9c380808464c40d5499d883010c01846765746888676f312e32302e35856c696e7578a070ccadc40b16e2094954b1064749cc6fbac783c1712f1b271a8aac3eda2f232588000000000000000007a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421808401600000").unwrap();
+ let expected = Header {
+ parent_hash: H256::from_str(
+ "13a7ec98912f917b3e804654e37c9866092043c13eb8eab94eb64818e886cff5",
+ )
+ .unwrap(),
+ ommers_hash: H256::from_str(
+ "1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ )
+ .unwrap(),
+ beneficiary: Address::from_str("f97e180c050e5ab072211ad2c213eb5aee4df134").unwrap(),
+ state_root: H256::from_str(
+ "ec229dbe85b0d3643ad0f471e6ec1a36bbc87deffbbd970762d22a53b35d068a",
+ )
+ .unwrap(),
+ transactions_root: H256::from_str(
+ "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+ )
+ .unwrap(),
+ receipts_root: H256::from_str(
+ "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+ )
+ .unwrap(),
+ logs_bloom: Default::default(),
+ difficulty: U256::from(0),
+ number: 0x30598,
+ gas_limit: 0x1c9c380,
+ gas_used: 0,
+ timestamp: 0x64c40d54,
+ extra_data: Bytes::from(
+ hex::decode("d883010c01846765746888676f312e32302e35856c696e7578").unwrap(),
+ ),
+ mix_hash: H256::from_str(
+ "70ccadc40b16e2094954b1064749cc6fbac783c1712f1b271a8aac3eda2f2325",
+ )
+ .unwrap(),
+ nonce: 0,
+ base_fee_per_gas: Some(7),
+ withdrawals_root: Some(
+ H256::from_str("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
+ .unwrap(),
+ ),
+ blob_gas_used: Some(0),
+ excess_blob_gas: Some(0x1600000),
+ };
+
+ let header = Header::decode(&mut data.as_slice()).unwrap();
+ assert_eq!(header, expected);
+
+ let expected_hash =
+ H256::from_str("0x539c9ea0a3ca49808799d3964b8b6607037227de26bc51073c6926963127087b")
+ .unwrap();
+ assert_eq!(header.hash_slow(), expected_hash);
+ }
+
#[test]
fn sanity_direction() {
let reverse = true;
diff --git a/crates/primitives/src/lib.rs b/crates/primitives/src/lib.rs
index 64faa1e03b1..36c6ce3e58a 100644
--- a/crates/primitives/src/lib.rs
+++ b/crates/primitives/src/lib.rs
@@ -23,6 +23,7 @@ pub mod abi;
mod account;
pub mod basefee;
mod bits;
+pub mod blobfee;
mod block;
pub mod bloom;
mod chain;
@@ -58,6 +59,8 @@ pub use block::{
BlockWithSenders, ForkBlock, SealedBlock, SealedBlockWithSenders,
};
pub use bloom::Bloom;
+#[cfg(feature = "optimism")]
+pub use chain::OP_GOERLI;
pub use chain::{
AllGenesisFormats, Chain, ChainInfo, ChainSpec, ChainSpecBuilder, DisplayHardforks,
ForkCondition, ForkTimestamps, DEV, GOERLI, MAINNET, SEPOLIA,
@@ -78,7 +81,7 @@ pub use net::{
SEPOLIA_BOOTNODES,
};
pub use peer::{PeerId, WithPeerId};
-pub use prune::{PruneCheckpoint, PruneMode, PruneModes, PrunePart};
+pub use prune::{PruneCheckpoint, PruneMode, PruneModes, PrunePart, PrunePartError};
pub use receipt::{Receipt, ReceiptWithBloom, ReceiptWithBloomRef};
pub use revm_primitives::JumpMap;
pub use serde_helper::JsonU256;
@@ -91,6 +94,8 @@ pub use transaction::{
TxEip1559, TxEip2930, TxEip4844, TxLegacy, TxType, EIP1559_TX_TYPE_ID, EIP2930_TX_TYPE_ID,
LEGACY_TX_TYPE_ID,
};
+#[cfg(feature = "optimism")]
+pub use transaction::{TxDeposit, DEPOSIT_TX_TYPE, DEPOSIT_VERSION};
pub use withdrawal::Withdrawal;
/// A block hash.
diff --git a/crates/primitives/src/proofs.rs b/crates/primitives/src/proofs.rs
index 95fd279d12b..40740d119af 100644
--- a/crates/primitives/src/proofs.rs
+++ b/crates/primitives/src/proofs.rs
@@ -171,6 +171,8 @@ mod tests {
success: true,
cumulative_gas_used: 102068,
logs,
+ #[cfg(feature = "optimism")]
+ deposit_nonce: None,
},
bloom,
};
diff --git a/crates/primitives/src/prune/mod.rs b/crates/primitives/src/prune/mod.rs
index 4dfc591bfcc..a3bcb959627 100644
--- a/crates/primitives/src/prune/mod.rs
+++ b/crates/primitives/src/prune/mod.rs
@@ -5,5 +5,5 @@ mod target;
pub use checkpoint::PruneCheckpoint;
pub use mode::PruneMode;
-pub use part::PrunePart;
+pub use part::{PrunePart, PrunePartError};
pub use target::PruneModes;
diff --git a/crates/primitives/src/prune/part.rs b/crates/primitives/src/prune/part.rs
index caa176b86a2..db49870735a 100644
--- a/crates/primitives/src/prune/part.rs
+++ b/crates/primitives/src/prune/part.rs
@@ -1,8 +1,10 @@
+use derive_more::Display;
use reth_codecs::{main_codec, Compact};
+use thiserror::Error;
/// Part of the data that can be pruned.
#[main_codec]
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
+#[derive(Debug, Display, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum PrunePart {
/// Prune part responsible for the `TxSenders` table.
SenderRecovery,
@@ -16,6 +18,14 @@ pub enum PrunePart {
StorageHistory,
}
+/// PrunePart error type.
+#[derive(Debug, Error)]
+pub enum PrunePartError {
+ /// Invalid configuration of a prune part.
+ #[error("The configuration provided for {0} is invalid.")]
+ Configuration(PrunePart),
+}
+
#[cfg(test)]
impl Default for PrunePart {
fn default() -> Self {
diff --git a/crates/primitives/src/prune/target.rs b/crates/primitives/src/prune/target.rs
index b314ae9d038..af6781897c2 100644
--- a/crates/primitives/src/prune/target.rs
+++ b/crates/primitives/src/prune/target.rs
@@ -1,4 +1,7 @@
-use crate::{serde_helper::deserialize_opt_prune_mode_with_min_blocks, BlockNumber, PruneMode};
+use crate::{
+ prune::PrunePartError, serde_helper::deserialize_opt_prune_mode_with_min_blocks, BlockNumber,
+ PruneMode, PrunePart,
+};
use paste::paste;
use serde::{Deserialize, Serialize};
@@ -19,10 +22,16 @@ pub struct PruneModes {
)]
pub receipts: Option,
/// Account History pruning configuration.
- #[serde(skip_serializing_if = "Option::is_none")]
+ #[serde(
+ skip_serializing_if = "Option::is_none",
+ deserialize_with = "deserialize_opt_prune_mode_with_min_blocks::<64, _>"
+ )]
pub account_history: Option,
/// Storage History pruning configuration.
- #[serde(skip_serializing_if = "Option::is_none")]
+ #[serde(
+ skip_serializing_if = "Option::is_none",
+ deserialize_with = "deserialize_opt_prune_mode_with_min_blocks::<64, _>"
+ )]
pub storage_history: Option,
}
@@ -51,12 +60,15 @@ macro_rules! impl_prune_parts {
$human_part,
" pruning needs to be done, inclusive, according to the provided tip."
)]
- pub fn [](&self, tip: BlockNumber) -> Option<(BlockNumber, PruneMode)> {
- self.$part.as_ref().and_then(|mode| {
- self.prune_target_block(mode, tip, $min_blocks).map(|block| {
- (block, *mode)
- })
- })
+ pub fn [](&self, tip: BlockNumber) -> Result, PrunePartError> {
+ match &self.$part {
+ Some(mode) =>
+ match self.prune_target_block(mode, tip, $min_blocks) {
+ Some(block) => Ok(Some((block, *mode))),
+ None => Err(PrunePartError::Configuration(PrunePart::[<$human_part>]))
+ }
+ None => Ok(None)
+ }
}
}
)+
@@ -107,17 +119,17 @@ impl PruneModes {
Some(tip.saturating_sub(*distance))
}
PruneMode::Before(n) if tip.saturating_sub(*n) >= min_blocks.unwrap_or_default() => {
- Some(*n)
+ Some(n.saturating_sub(1))
}
_ => None,
}
}
impl_prune_parts!(
- (sender_recovery, "Sender Recovery", None),
- (transaction_lookup, "Transaction Lookup", None),
+ (sender_recovery, "SenderRecovery", None),
+ (transaction_lookup, "TransactionLookup", None),
(receipts, "Receipts", Some(64)),
- (account_history, "Account History", None),
- (storage_history, "Storage History", None)
+ (account_history, "AccountHistory", Some(64)),
+ (storage_history, "StorageHistory", Some(64))
);
}
diff --git a/crates/primitives/src/receipt.rs b/crates/primitives/src/receipt.rs
index 15a5a2308df..356d13fdc2d 100644
--- a/crates/primitives/src/receipt.rs
+++ b/crates/primitives/src/receipt.rs
@@ -28,6 +28,9 @@ pub struct Receipt {
)
)]
pub logs: Vec,
+ /// Deposit nonce for Optimism deposited transactions
+ #[cfg(feature = "optimism")]
+ pub deposit_nonce: Option,
}
impl Receipt {
@@ -103,7 +106,29 @@ impl ReceiptWithBloom {
let bloom = Decodable::decode(b)?;
let logs = reth_rlp::Decodable::decode(b)?;
- let this = Self { receipt: Receipt { tx_type, success, cumulative_gas_used, logs }, bloom };
+ let receipt = match tx_type {
+ #[cfg(feature = "optimism")]
+ TxType::DEPOSIT => {
+ let deposit_nonce = reth_rlp::Decodable::decode(b)?;
+ Receipt {
+ tx_type,
+ success,
+ cumulative_gas_used,
+ logs,
+ deposit_nonce: Some(deposit_nonce),
+ }
+ }
+ _ => Receipt {
+ tx_type,
+ success,
+ cumulative_gas_used,
+ logs,
+ #[cfg(feature = "optimism")]
+ deposit_nonce: None,
+ },
+ };
+
+ let this = Self { receipt, bloom };
let consumed = started_len - b.len();
if consumed != rlp_head.payload_length {
return Err(reth_rlp::DecodeError::ListLengthMismatch {
@@ -141,12 +166,22 @@ impl Decodable for ReceiptWithBloom {
let receipt_type = *buf.first().ok_or(reth_rlp::DecodeError::Custom(
"typed receipt cannot be decoded from an empty slice",
))?;
+
+ #[cfg(feature = "optimism")]
+ if receipt_type == 0x7E {
+ buf.advance(1);
+ Self::decode_receipt(buf, TxType::DEPOSIT)
+ }
+
if receipt_type == 0x01 {
buf.advance(1);
Self::decode_receipt(buf, TxType::EIP2930)
} else if receipt_type == 0x02 {
buf.advance(1);
Self::decode_receipt(buf, TxType::EIP1559)
+ } else if receipt_type == 0x03 {
+ buf.advance(1);
+ Self::decode_receipt(buf, TxType::EIP4844)
} else {
Err(reth_rlp::DecodeError::Custom("invalid receipt type"))
}
@@ -251,6 +286,9 @@ impl<'a> ReceiptWithBloomEncoder<'a> {
TxType::EIP1559 => {
out.put_u8(0x02);
}
+ TxType::EIP4844 => {
+ out.put_u8(0x03);
+ }
_ => unreachable!("legacy handled; qed."),
}
out.put_slice(payload.as_ref());
@@ -270,7 +308,7 @@ impl<'a> Encodable for ReceiptWithBloomEncoder<'a> {
fn length(&self) -> usize {
let mut payload_len = self.receipt_length();
// account for eip-2718 type prefix and set the list
- if matches!(self.receipt.tx_type, TxType::EIP1559 | TxType::EIP2930) {
+ if matches!(self.receipt.tx_type, TxType::EIP1559 | TxType::EIP2930 | TxType::EIP4844) {
payload_len += 1;
// we include a string header for typed receipts, so include the length here
payload_len += length_of_length(payload_len);
@@ -313,6 +351,8 @@ mod tests {
data: Bytes::from_str("0100ff").unwrap().0.into(),
}],
success: false,
+ #[cfg(feature = "optimism")]
+ deposit_nonce: None,
},
bloom: [0; 256].into(),
};
@@ -349,6 +389,8 @@ mod tests {
data: Bytes::from_str("0100ff").unwrap().0.into(),
}],
success: false,
+ #[cfg(feature = "optimism")]
+ deposit_nonce: None,
},
bloom: [0; 256].into(),
};
@@ -383,6 +425,8 @@ mod tests {
data: crate::Bytes::from(vec![1; 0xffffff]),
},
],
+ #[cfg(feature = "optimism")]
+ deposit_nonce: None,
};
let mut data = vec![];
diff --git a/crates/primitives/src/transaction/eip1559.rs b/crates/primitives/src/transaction/eip1559.rs
new file mode 100644
index 00000000000..3108c6e51e6
--- /dev/null
+++ b/crates/primitives/src/transaction/eip1559.rs
@@ -0,0 +1,123 @@
+use super::access_list::AccessList;
+use crate::{Bytes, ChainId, TransactionKind};
+use reth_codecs::{main_codec, Compact};
+use std::mem;
+
+/// A transaction with a priority fee ([EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)).
+#[main_codec]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
+pub struct TxEip1559 {
+ /// Added as EIP-pub 155: Simple replay attack protection
+ pub chain_id: u64,
+ /// A scalar value equal to the number of transactions sent by the sender; formally Tn.
+ pub nonce: u64,
+ /// A scalar value equal to the maximum
+ /// amount of gas that should be used in executing
+ /// this transaction. This is paid up-front, before any
+ /// computation is done and may not be increased
+ /// later; formally Tg.
+ pub gas_limit: u64,
+ /// A scalar value equal to the maximum
+ /// amount of gas that should be used in executing
+ /// this transaction. This is paid up-front, before any
+ /// computation is done and may not be increased
+ /// later; formally Tg.
+ ///
+ /// As ethereum circulation is around 120mil eth as of 2022 that is around
+ /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
+ /// 340282366920938463463374607431768211455
+ ///
+ /// This is also known as `GasFeeCap`
+ pub max_fee_per_gas: u128,
+ /// Max Priority fee that transaction is paying
+ ///
+ /// As ethereum circulation is around 120mil eth as of 2022 that is around
+ /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
+ /// 340282366920938463463374607431768211455
+ ///
+ /// This is also known as `GasTipCap`
+ pub max_priority_fee_per_gas: u128,
+ /// The 160-bit address of the message call’s recipient or, for a contract creation
+ /// transaction, ∅, used here to denote the only member of B0 ; formally Tt.
+ pub to: TransactionKind,
+ /// A scalar value equal to the number of Wei to
+ /// be transferred to the message call’s recipient or,
+ /// in the case of contract creation, as an endowment
+ /// to the newly created account; formally Tv.
+ ///
+ /// As ethereum circulation is around 120mil eth as of 2022 that is around
+ /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
+ /// 340282366920938463463374607431768211455
+ pub value: u128,
+ /// The accessList specifies a list of addresses and storage keys;
+ /// these addresses and storage keys are added into the `accessed_addresses`
+ /// and `accessed_storage_keys` global sets (introduced in EIP-2929).
+ /// A gas cost is charged, though at a discount relative to the cost of
+ /// accessing outside the list.
+ pub access_list: AccessList,
+ /// Input has two uses depending if transaction is Create or Call (if `to` field is None or
+ /// Some). pub init: An unlimited size byte array specifying the
+ /// EVM-code for the account initialisation procedure CREATE,
+ /// data: An unlimited size byte array specifying the
+ /// input data of the message call, formally Td.
+ pub input: Bytes,
+}
+
+impl TxEip1559 {
+ /// Calculates a heuristic for the in-memory size of the [TxEip1559] transaction.
+ #[inline]
+ pub fn size(&self) -> usize {
+ mem::size_of::() + // chain_id
+ mem::size_of::() + // nonce
+ mem::size_of::() + // gas_limit
+ mem::size_of::() + // max_fee_per_gas
+ mem::size_of::() + // max_priority_fee_per_gas
+ self.to.size() + // to
+ mem::size_of::() + // value
+ self.access_list.size() + // access_list
+ self.input.len() // input
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::TxEip1559;
+ use crate::{
+ transaction::{signature::Signature, TransactionKind},
+ AccessList, Address, Transaction, TransactionSigned, H256, U256,
+ };
+ use std::str::FromStr;
+
+ #[test]
+ fn recover_signer_eip1559() {
+ use crate::hex_literal::hex;
+
+ let signer: Address = hex!("dd6b8b3dc6b7ad97db52f08a275ff4483e024cea").into();
+ let hash: H256 =
+ hex!("0ec0b6a2df4d87424e5f6ad2a654e27aaeb7dac20ae9e8385cc09087ad532ee0").into();
+
+ let tx = Transaction::Eip1559( TxEip1559 {
+ chain_id: 1,
+ nonce: 0x42,
+ gas_limit: 44386,
+ to: TransactionKind::Call( hex!("6069a6c32cf691f5982febae4faf8a6f3ab2f0f6").into()),
+ value: 0,
+ input: hex!("a22cb4650000000000000000000000005eee75727d804a2b13038928d36f8b188945a57a0000000000000000000000000000000000000000000000000000000000000000").into(),
+ max_fee_per_gas: 0x4a817c800,
+ max_priority_fee_per_gas: 0x3b9aca00,
+ access_list: AccessList::default(),
+ });
+
+ let sig = Signature {
+ r: U256::from_str("0x840cfc572845f5786e702984c2a582528cad4b49b2a10b9db1be7fca90058565")
+ .unwrap(),
+ s: U256::from_str("0x25e7109ceb98168d95b09b18bbf6b685130e0562f233877d492b94eee0c5b6d1")
+ .unwrap(),
+ odd_y_parity: false,
+ };
+
+ let signed_tx = TransactionSigned::from_transaction_and_signature(tx, sig);
+ assert_eq!(signed_tx.hash(), hash, "Expected same hash");
+ assert_eq!(signed_tx.recover_signer(), Some(signer), "Recovering signer should pass.");
+ }
+}
diff --git a/crates/primitives/src/transaction/eip2930.rs b/crates/primitives/src/transaction/eip2930.rs
new file mode 100644
index 00000000000..ecd6ecb7ec2
--- /dev/null
+++ b/crates/primitives/src/transaction/eip2930.rs
@@ -0,0 +1,127 @@
+use super::access_list::AccessList;
+use crate::{Bytes, ChainId, TransactionKind};
+use reth_codecs::{main_codec, Compact};
+use std::mem;
+
+/// Transaction with an [`AccessList`] ([EIP-2930](https://eips.ethereum.org/EIPS/eip-2930)).
+#[main_codec]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
+pub struct TxEip2930 {
+ /// Added as EIP-pub 155: Simple replay attack protection
+ pub chain_id: ChainId,
+ /// A scalar value equal to the number of transactions sent by the sender; formally Tn.
+ pub nonce: u64,
+ /// A scalar value equal to the number of
+ /// Wei to be paid per unit of gas for all computation
+ /// costs incurred as a result of the execution of this transaction; formally Tp.
+ ///
+ /// As ethereum circulation is around 120mil eth as of 2022 that is around
+ /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
+ /// 340282366920938463463374607431768211455
+ pub gas_price: u128,
+ /// A scalar value equal to the maximum
+ /// amount of gas that should be used in executing
+ /// this transaction. This is paid up-front, before any
+ /// computation is done and may not be increased
+ /// later; formally Tg.
+ pub gas_limit: u64,
+ /// The 160-bit address of the message call’s recipient or, for a contract creation
+ /// transaction, ∅, used here to denote the only member of B0 ; formally Tt.
+ pub to: TransactionKind,
+ /// A scalar value equal to the number of Wei to
+ /// be transferred to the message call’s recipient or,
+ /// in the case of contract creation, as an endowment
+ /// to the newly created account; formally Tv.
+ ///
+ /// As ethereum circulation is around 120mil eth as of 2022 that is around
+ /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
+ /// 340282366920938463463374607431768211455
+ pub value: u128,
+ /// The accessList specifies a list of addresses and storage keys;
+ /// these addresses and storage keys are added into the `accessed_addresses`
+ /// and `accessed_storage_keys` global sets (introduced in EIP-2929).
+ /// A gas cost is charged, though at a discount relative to the cost of
+ /// accessing outside the list.
+ pub access_list: AccessList,
+ /// Input has two uses depending if transaction is Create or Call (if `to` field is None or
+ /// Some). pub init: An unlimited size byte array specifying the
+ /// EVM-code for the account initialisation procedure CREATE,
+ /// data: An unlimited size byte array specifying the
+ /// input data of the message call, formally Td.
+ pub input: Bytes,
+}
+
+impl TxEip2930 {
+ /// Calculates a heuristic for the in-memory size of the [TxEip2930] transaction.
+ #[inline]
+ pub fn size(&self) -> usize {
+ mem::size_of::() + // chain_id
+ mem::size_of::() + // nonce
+ mem::size_of::() + // gas_price
+ mem::size_of::() + // gas_limit
+ self.to.size() + // to
+ mem::size_of::() + // value
+ self.access_list.size() + // access_list
+ self.input.len() // input
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::TxEip2930;
+ use crate::{
+ transaction::{signature::Signature, TransactionKind},
+ Address, Bytes, Transaction, TransactionSigned, U256,
+ };
+ use bytes::BytesMut;
+ use reth_rlp::{Decodable, Encodable};
+
+ #[test]
+ fn test_decode_create() {
+ // tests that a contract creation tx encodes and decodes properly
+ let request = Transaction::Eip2930(TxEip2930 {
+ chain_id: 1u64,
+ nonce: 0,
+ gas_price: 1,
+ gas_limit: 2,
+ to: TransactionKind::Create,
+ value: 3,
+ input: Bytes::from(vec![1, 2]),
+ access_list: Default::default(),
+ });
+ let signature = Signature { odd_y_parity: true, r: U256::default(), s: U256::default() };
+ let tx = TransactionSigned::from_transaction_and_signature(request, signature);
+
+ let mut encoded = BytesMut::new();
+ tx.encode(&mut encoded);
+ assert_eq!(encoded.len(), tx.length());
+
+ let decoded = TransactionSigned::decode(&mut &*encoded).unwrap();
+ assert_eq!(decoded, tx);
+ }
+
+ #[test]
+ fn test_decode_call() {
+ let request = Transaction::Eip2930(TxEip2930 {
+ chain_id: 1u64,
+ nonce: 0,
+ gas_price: 1,
+ gas_limit: 2,
+ to: TransactionKind::Call(Address::default()),
+ value: 3,
+ input: Bytes::from(vec![1, 2]),
+ access_list: Default::default(),
+ });
+
+ let signature = Signature { odd_y_parity: true, r: U256::default(), s: U256::default() };
+
+ let tx = TransactionSigned::from_transaction_and_signature(request, signature);
+
+ let mut encoded = BytesMut::new();
+ tx.encode(&mut encoded);
+ assert_eq!(encoded.len(), tx.length());
+
+ let decoded = TransactionSigned::decode(&mut &*encoded).unwrap();
+ assert_eq!(decoded, tx);
+ }
+}
diff --git a/crates/primitives/src/transaction/eip4844.rs b/crates/primitives/src/transaction/eip4844.rs
new file mode 100644
index 00000000000..34b43e19bb6
--- /dev/null
+++ b/crates/primitives/src/transaction/eip4844.rs
@@ -0,0 +1,118 @@
+use super::access_list::AccessList;
+use crate::{constants::eip4844::DATA_GAS_PER_BLOB, Bytes, ChainId, TransactionKind, H256};
+use reth_codecs::{main_codec, Compact};
+use std::mem;
+
+/// [EIP-4844 Blob Transaction](https://eips.ethereum.org/EIPS/eip-4844#blob-transaction)
+///
+/// A transaction with blob hashes and max blob fee
+#[main_codec]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
+pub struct TxEip4844 {
+ /// Added as EIP-pub 155: Simple replay attack protection
+ pub chain_id: u64,
+ /// A scalar value equal to the number of transactions sent by the sender; formally Tn.
+ pub nonce: u64,
+ /// A scalar value equal to the maximum
+ /// amount of gas that should be used in executing
+ /// this transaction. This is paid up-front, before any
+ /// computation is done and may not be increased
+ /// later; formally Tg.
+ pub gas_limit: u64,
+ /// A scalar value equal to the maximum
+ /// amount of gas that should be used in executing
+ /// this transaction. This is paid up-front, before any
+ /// computation is done and may not be increased
+ /// later; formally Tg.
+ ///
+ /// As ethereum circulation is around 120mil eth as of 2022 that is around
+ /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
+ /// 340282366920938463463374607431768211455
+ ///
+ /// This is also known as `GasFeeCap`
+ pub max_fee_per_gas: u128,
+ /// Max Priority fee that transaction is paying
+ ///
+ /// As ethereum circulation is around 120mil eth as of 2022 that is around
+ /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
+ /// 340282366920938463463374607431768211455
+ ///
+ /// This is also known as `GasTipCap`
+ pub max_priority_fee_per_gas: u128,
+ /// The 160-bit address of the message call’s recipient or, for a contract creation
+ /// transaction, ∅, used here to denote the only member of B0 ; formally Tt.
+ pub to: TransactionKind,
+ /// A scalar value equal to the number of Wei to
+ /// be transferred to the message call’s recipient or,
+ /// in the case of contract creation, as an endowment
+ /// to the newly created account; formally Tv.
+ ///
+ /// As ethereum circulation is around 120mil eth as of 2022 that is around
+ /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
+ /// 340282366920938463463374607431768211455
+ pub value: u128,
+ /// The accessList specifies a list of addresses and storage keys;
+ /// these addresses and storage keys are added into the `accessed_addresses`
+ /// and `accessed_storage_keys` global sets (introduced in EIP-2929).
+ /// A gas cost is charged, though at a discount relative to the cost of
+ /// accessing outside the list.
+ pub access_list: AccessList,
+
+ /// It contains a vector of fixed size hash(32 bytes)
+ pub blob_versioned_hashes: Vec,
+
+ /// Max fee per data gas
+ ///
+ /// aka BlobFeeCap
+ pub max_fee_per_blob_gas: u128,
+
+ /// Input has two uses depending if transaction is Create or Call (if `to` field is None or
+ /// Some). pub init: An unlimited size byte array specifying the
+ /// EVM-code for the account initialisation procedure CREATE,
+ /// data: An unlimited size byte array specifying the
+ /// input data of the message call, formally Td.
+ pub input: Bytes,
+}
+
+impl TxEip4844 {
+ /// Returns the effective gas price for the given `base_fee`.
+ pub fn effective_gas_price(&self, base_fee: Option) -> u128 {
+ match base_fee {
+ None => self.max_fee_per_gas,
+ Some(base_fee) => {
+ // if the tip is greater than the max priority fee per gas, set it to the max
+ // priority fee per gas + base fee
+ let tip = self.max_fee_per_gas.saturating_sub(base_fee as u128);
+ if tip > self.max_priority_fee_per_gas {
+ self.max_priority_fee_per_gas + base_fee as u128
+ } else {
+ // otherwise return the max fee per gas
+ self.max_fee_per_gas
+ }
+ }
+ }
+ }
+
+ /// Returns the total gas for all blobs in this transaction.
+ #[inline]
+ pub fn blob_gas(&self) -> u64 {
+ // SAFETY: we don't expect u64::MAX / DATA_GAS_PER_BLOB hashes in a single transaction
+ self.blob_versioned_hashes.len() as u64 * DATA_GAS_PER_BLOB
+ }
+
+ /// Calculates a heuristic for the in-memory size of the [TxEip4844] transaction.
+ #[inline]
+ pub fn size(&self) -> usize {
+ mem::size_of::() + // chain_id
+ mem::size_of::() + // nonce
+ mem::size_of::() + // gas_limit
+ mem::size_of::() + // max_fee_per_gas
+ mem::size_of::() + // max_priority_fee_per_gas
+ self.to.size() + // to
+ mem::size_of::() + // value
+ self.access_list.size() + // access_list
+ self.input.len() + // input
+ self.blob_versioned_hashes.capacity() * mem::size_of::() + // blob hashes size
+ mem::size_of::() // max_fee_per_data_gas
+ }
+}
diff --git a/crates/primitives/src/transaction/legacy.rs b/crates/primitives/src/transaction/legacy.rs
new file mode 100644
index 00000000000..cd324732bd5
--- /dev/null
+++ b/crates/primitives/src/transaction/legacy.rs
@@ -0,0 +1,101 @@
+use crate::{Bytes, ChainId, TransactionKind};
+use reth_codecs::{main_codec, Compact};
+use std::mem;
+
+/// Legacy transaction.
+#[main_codec]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
+pub struct TxLegacy {
+ /// Added as EIP-155: Simple replay attack protection
+ pub chain_id: Option,
+ /// A scalar value equal to the number of transactions sent by the sender; formally Tn.
+ pub nonce: u64,
+ /// A scalar value equal to the number of
+ /// Wei to be paid per unit of gas for all computation
+ /// costs incurred as a result of the execution of this transaction; formally Tp.
+ ///
+ /// As ethereum circulation is around 120mil eth as of 2022 that is around
+ /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
+ /// 340282366920938463463374607431768211455
+ pub gas_price: u128,
+ /// A scalar value equal to the maximum
+ /// amount of gas that should be used in executing
+ /// this transaction. This is paid up-front, before any
+ /// computation is done and may not be increased
+ /// later; formally Tg.
+ pub gas_limit: u64,
+ /// The 160-bit address of the message call’s recipient or, for a contract creation
+ /// transaction, ∅, used here to denote the only member of B0 ; formally Tt.
+ pub to: TransactionKind,
+ /// A scalar value equal to the number of Wei to
+ /// be transferred to the message call’s recipient or,
+ /// in the case of contract creation, as an endowment
+ /// to the newly created account; formally Tv.
+ ///
+ /// As ethereum circulation is around 120mil eth as of 2022 that is around
+ /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
+ /// 340282366920938463463374607431768211455
+ pub value: u128,
+ /// Input has two uses depending if transaction is Create or Call (if `to` field is None or
+ /// Some). pub init: An unlimited size byte array specifying the
+ /// EVM-code for the account initialisation procedure CREATE,
+ /// data: An unlimited size byte array specifying the
+ /// input data of the message call, formally Td.
+ pub input: Bytes,
+}
+
+impl TxLegacy {
+ /// Calculates a heuristic for the in-memory size of the [TxLegacy] transaction.
+ #[inline]
+ pub fn size(&self) -> usize {
+ mem::size_of::>() + // chain_id
+ mem::size_of::() + // nonce
+ mem::size_of::() + // gas_price
+ mem::size_of::() + // gas_limit
+ self.to.size() + // to
+ mem::size_of::() + // value
+ self.input.len() // input
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::TxLegacy;
+ use crate::{
+ transaction::{signature::Signature, TransactionKind},
+ Address, Transaction, TransactionSigned, H256, U256,
+ };
+
+ #[test]
+ fn recover_signer_legacy() {
+ use crate::hex_literal::hex;
+
+ let signer: Address = hex!("398137383b3d25c92898c656696e41950e47316b").into();
+ let hash: H256 =
+ hex!("bb3a336e3f823ec18197f1e13ee875700f08f03e2cab75f0d0b118dabb44cba0").into();
+
+ let tx = Transaction::Legacy(TxLegacy {
+ chain_id: Some(1),
+ nonce: 0x18,
+ gas_price: 0xfa56ea00,
+ gas_limit: 119902,
+ to: TransactionKind::Call( hex!("06012c8cf97bead5deae237070f9587f8e7a266d").into()),
+ value: 0x1c6bf526340000u64.into(),
+ input: hex!("f7d8c88300000000000000000000000000000000000000000000000000000000000cee6100000000000000000000000000000000000000000000000000000000000ac3e1").into(),
+ });
+
+ let sig = Signature {
+ r: U256::from_be_bytes(hex!(
+ "2a378831cf81d99a3f06a18ae1b6ca366817ab4d88a70053c41d7a8f0368e031"
+ )),
+ s: U256::from_be_bytes(hex!(
+ "450d831a05b6e418724436c05c155e0a1b7b921015d0fbc2f667aed709ac4fb5"
+ )),
+ odd_y_parity: false,
+ };
+
+ let signed_tx = TransactionSigned::from_transaction_and_signature(tx, sig);
+ assert_eq!(signed_tx.hash(), hash, "Expected same hash");
+ assert_eq!(signed_tx.recover_signer(), Some(signer), "Recovering signer should pass.");
+ }
+}
diff --git a/crates/primitives/src/transaction/mod.rs b/crates/primitives/src/transaction/mod.rs
index 5a22b60f9bc..9c7e5ae529f 100644
--- a/crates/primitives/src/transaction/mod.rs
+++ b/crates/primitives/src/transaction/mod.rs
@@ -1,301 +1,43 @@
-use std::mem;
-
use crate::{
compression::{TRANSACTION_COMPRESSOR, TRANSACTION_DECOMPRESSOR},
- keccak256, Address, Bytes, ChainId, TxHash, H256,
+ keccak256, Address, Bytes, TxHash, H256,
};
pub use access_list::{AccessList, AccessListItem, AccessListWithGasUsed};
use bytes::{Buf, BytesMut};
use derive_more::{AsRef, Deref};
pub use error::InvalidTransactionError;
pub use meta::TransactionMeta;
-use reth_codecs::{add_arbitrary_tests, derive_arbitrary, main_codec, Compact};
+use reth_codecs::{add_arbitrary_tests, derive_arbitrary, Compact};
use reth_rlp::{
length_of_length, Decodable, DecodeError, Encodable, Header, EMPTY_LIST_CODE, EMPTY_STRING_CODE,
};
use serde::{Deserialize, Serialize};
pub use signature::Signature;
+use std::mem;
pub use tx_type::{TxType, EIP1559_TX_TYPE_ID, EIP2930_TX_TYPE_ID, LEGACY_TX_TYPE_ID};
+#[cfg(feature = "optimism")]
+pub use optimism::{TxDeposit, DEPOSIT_TX_TYPE, DEPOSIT_VERSION};
+
+pub use eip1559::TxEip1559;
+pub use eip2930::TxEip2930;
+pub use eip4844::TxEip4844;
+pub use legacy::TxLegacy;
+
+#[cfg(feature = "optimism")]
+mod optimism;
+
mod access_list;
+mod eip1559;
+mod eip2930;
+mod eip4844;
mod error;
+mod legacy;
mod meta;
mod signature;
mod tx_type;
pub(crate) mod util;
-/// Legacy transaction.
-#[main_codec]
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
-pub struct TxLegacy {
- /// Added as EIP-155: Simple replay attack protection
- pub chain_id: Option,
- /// A scalar value equal to the number of transactions sent by the sender; formally Tn.
- pub nonce: u64,
- /// A scalar value equal to the number of
- /// Wei to be paid per unit of gas for all computation
- /// costs incurred as a result of the execution of this transaction; formally Tp.
- ///
- /// As ethereum circulation is around 120mil eth as of 2022 that is around
- /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
- /// 340282366920938463463374607431768211455
- pub gas_price: u128,
- /// A scalar value equal to the maximum
- /// amount of gas that should be used in executing
- /// this transaction. This is paid up-front, before any
- /// computation is done and may not be increased
- /// later; formally Tg.
- pub gas_limit: u64,
- /// The 160-bit address of the message call’s recipient or, for a contract creation
- /// transaction, ∅, used here to denote the only member of B0 ; formally Tt.
- pub to: TransactionKind,
- /// A scalar value equal to the number of Wei to
- /// be transferred to the message call’s recipient or,
- /// in the case of contract creation, as an endowment
- /// to the newly created account; formally Tv.
- ///
- /// As ethereum circulation is around 120mil eth as of 2022 that is around
- /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
- /// 340282366920938463463374607431768211455
- pub value: u128,
- /// Input has two uses depending if transaction is Create or Call (if `to` field is None or
- /// Some). pub init: An unlimited size byte array specifying the
- /// EVM-code for the account initialisation procedure CREATE,
- /// data: An unlimited size byte array specifying the
- /// input data of the message call, formally Td.
- pub input: Bytes,
-}
-
-impl TxLegacy {
- /// Calculates a heuristic for the in-memory size of the [TxLegacy] transaction.
- #[inline]
- fn size(&self) -> usize {
- mem::size_of::>() + // chain_id
- mem::size_of::() + // nonce
- mem::size_of::() + // gas_price
- mem::size_of::() + // gas_limit
- self.to.size() + // to
- mem::size_of::() + // value
- self.input.len() // input
- }
-}
-
-/// Transaction with an [`AccessList`] ([EIP-2930](https://eips.ethereum.org/EIPS/eip-2930)).
-#[main_codec]
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
-pub struct TxEip2930 {
- /// Added as EIP-pub 155: Simple replay attack protection
- pub chain_id: ChainId,
- /// A scalar value equal to the number of transactions sent by the sender; formally Tn.
- pub nonce: u64,
- /// A scalar value equal to the number of
- /// Wei to be paid per unit of gas for all computation
- /// costs incurred as a result of the execution of this transaction; formally Tp.
- ///
- /// As ethereum circulation is around 120mil eth as of 2022 that is around
- /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
- /// 340282366920938463463374607431768211455
- pub gas_price: u128,
- /// A scalar value equal to the maximum
- /// amount of gas that should be used in executing
- /// this transaction. This is paid up-front, before any
- /// computation is done and may not be increased
- /// later; formally Tg.
- pub gas_limit: u64,
- /// The 160-bit address of the message call’s recipient or, for a contract creation
- /// transaction, ∅, used here to denote the only member of B0 ; formally Tt.
- pub to: TransactionKind,
- /// A scalar value equal to the number of Wei to
- /// be transferred to the message call’s recipient or,
- /// in the case of contract creation, as an endowment
- /// to the newly created account; formally Tv.
- ///
- /// As ethereum circulation is around 120mil eth as of 2022 that is around
- /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
- /// 340282366920938463463374607431768211455
- pub value: u128,
- /// The accessList specifies a list of addresses and storage keys;
- /// these addresses and storage keys are added into the `accessed_addresses`
- /// and `accessed_storage_keys` global sets (introduced in EIP-2929).
- /// A gas cost is charged, though at a discount relative to the cost of
- /// accessing outside the list.
- pub access_list: AccessList,
- /// Input has two uses depending if transaction is Create or Call (if `to` field is None or
- /// Some). pub init: An unlimited size byte array specifying the
- /// EVM-code for the account initialisation procedure CREATE,
- /// data: An unlimited size byte array specifying the
- /// input data of the message call, formally Td.
- pub input: Bytes,
-}
-
-impl TxEip2930 {
- /// Calculates a heuristic for the in-memory size of the [TxEip2930] transaction.
- #[inline]
- pub fn size(&self) -> usize {
- mem::size_of::() + // chain_id
- mem::size_of::() + // nonce
- mem::size_of::() + // gas_price
- mem::size_of::() + // gas_limit
- self.to.size() + // to
- mem::size_of::() + // value
- self.access_list.size() + // access_list
- self.input.len() // input
- }
-}
-
-/// A transaction with a priority fee ([EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)).
-#[main_codec]
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
-pub struct TxEip1559 {
- /// Added as EIP-pub 155: Simple replay attack protection
- pub chain_id: u64,
- /// A scalar value equal to the number of transactions sent by the sender; formally Tn.
- pub nonce: u64,
- /// A scalar value equal to the maximum
- /// amount of gas that should be used in executing
- /// this transaction. This is paid up-front, before any
- /// computation is done and may not be increased
- /// later; formally Tg.
- pub gas_limit: u64,
- /// A scalar value equal to the maximum
- /// amount of gas that should be used in executing
- /// this transaction. This is paid up-front, before any
- /// computation is done and may not be increased
- /// later; formally Tg.
- ///
- /// As ethereum circulation is around 120mil eth as of 2022 that is around
- /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
- /// 340282366920938463463374607431768211455
- pub max_fee_per_gas: u128,
- /// Max Priority fee that transaction is paying
- ///
- /// As ethereum circulation is around 120mil eth as of 2022 that is around
- /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
- /// 340282366920938463463374607431768211455
- pub max_priority_fee_per_gas: u128,
- /// The 160-bit address of the message call’s recipient or, for a contract creation
- /// transaction, ∅, used here to denote the only member of B0 ; formally Tt.
- pub to: TransactionKind,
- /// A scalar value equal to the number of Wei to
- /// be transferred to the message call’s recipient or,
- /// in the case of contract creation, as an endowment
- /// to the newly created account; formally Tv.
- ///
- /// As ethereum circulation is around 120mil eth as of 2022 that is around
- /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
- /// 340282366920938463463374607431768211455
- pub value: u128,
- /// The accessList specifies a list of addresses and storage keys;
- /// these addresses and storage keys are added into the `accessed_addresses`
- /// and `accessed_storage_keys` global sets (introduced in EIP-2929).
- /// A gas cost is charged, though at a discount relative to the cost of
- /// accessing outside the list.
- pub access_list: AccessList,
- /// Input has two uses depending if transaction is Create or Call (if `to` field is None or
- /// Some). pub init: An unlimited size byte array specifying the
- /// EVM-code for the account initialisation procedure CREATE,
- /// data: An unlimited size byte array specifying the
- /// input data of the message call, formally Td.
- pub input: Bytes,
-}
-
-impl TxEip1559 {
- /// Calculates a heuristic for the in-memory size of the [TxEip1559] transaction.
- #[inline]
- pub fn size(&self) -> usize {
- mem::size_of::() + // chain_id
- mem::size_of::() + // nonce
- mem::size_of::() + // gas_limit
- mem::size_of::() + // max_fee_per_gas
- mem::size_of::() + // max_priority_fee_per_gas
- self.to.size() + // to
- mem::size_of::() + // value
- self.access_list.size() + // access_list
- self.input.len() // input
- }
-}
-
-/// A transaction with blob hashes and max blob fee
-#[main_codec]
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
-pub struct TxEip4844 {
- /// Added as EIP-pub 155: Simple replay attack protection
- pub chain_id: u64,
- /// A scalar value equal to the number of transactions sent by the sender; formally Tn.
- pub nonce: u64,
- /// A scalar value equal to the maximum
- /// amount of gas that should be used in executing
- /// this transaction. This is paid up-front, before any
- /// computation is done and may not be increased
- /// later; formally Tg.
- pub gas_limit: u64,
- /// A scalar value equal to the maximum
- /// amount of gas that should be used in executing
- /// this transaction. This is paid up-front, before any
- /// computation is done and may not be increased
- /// later; formally Tg.
- ///
- /// As ethereum circulation is around 120mil eth as of 2022 that is around
- /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
- /// 340282366920938463463374607431768211455
- pub max_fee_per_gas: u128,
- /// Max Priority fee that transaction is paying
- ///
- /// As ethereum circulation is around 120mil eth as of 2022 that is around
- /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
- /// 340282366920938463463374607431768211455
- pub max_priority_fee_per_gas: u128,
- /// The 160-bit address of the message call’s recipient or, for a contract creation
- /// transaction, ∅, used here to denote the only member of B0 ; formally Tt.
- pub to: TransactionKind,
- /// A scalar value equal to the number of Wei to
- /// be transferred to the message call’s recipient or,
- /// in the case of contract creation, as an endowment
- /// to the newly created account; formally Tv.
- ///
- /// As ethereum circulation is around 120mil eth as of 2022 that is around
- /// 120000000000000000000000000 wei we are safe to use u128 as its max number is:
- /// 340282366920938463463374607431768211455
- pub value: u128,
- /// The accessList specifies a list of addresses and storage keys;
- /// these addresses and storage keys are added into the `accessed_addresses`
- /// and `accessed_storage_keys` global sets (introduced in EIP-2929).
- /// A gas cost is charged, though at a discount relative to the cost of
- /// accessing outside the list.
- pub access_list: AccessList,
-
- /// It contains a vector of fixed size hash(32 bytes)
- pub blob_hashes: Vec,
-
- /// Max fee per data gas
- pub max_fee_per_blob: u128,
-
- /// Input has two uses depending if transaction is Create or Call (if `to` field is None or
- /// Some). pub init: An unlimited size byte array specifying the
- /// EVM-code for the account initialisation procedure CREATE,
- /// data: An unlimited size byte array specifying the
- /// input data of the message call, formally Td.
- pub input: Bytes,
-}
-
-impl TxEip4844 {
- /// Calculates a heuristic for the in-memory size of the [TxEip4844] transaction.
- #[inline]
- pub fn size(&self) -> usize {
- mem::size_of::() + // chain_id
- mem::size_of::() + // nonce
- mem::size_of::() + // gas_limit
- mem::size_of::() + // max_fee_per_gas
- mem::size_of::() + // max_priority_fee_per_gas
- self.to.size() + // to
- mem::size_of::() + // value
- self.access_list.size() + // access_list
- self.input.len() + // input
- self.blob_hashes.capacity() * mem::size_of::() + // blob hashes size
- mem::size_of::() // blob fee cap
- }
-}
-
/// A raw transaction.
///
/// Transaction types were introduced in [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718).
@@ -329,6 +71,9 @@ pub enum Transaction {
/// transaction, incentivizing miners to include transactions with higher priority fees per
/// gas.
Eip1559(TxEip1559),
+ /// Optimism deposit transaction.
+ #[cfg(feature = "optimism")]
+ Deposit(TxDeposit),
}
impl Transaction {
@@ -356,6 +101,23 @@ impl Transaction {
self.encode_fields(out);
signature.encode_with_eip155_chain_id(out, *chain_id);
}
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => {
+ let payload_length = self.fields_len() + signature.payload_len();
+ if with_header {
+ Header {
+ list: false,
+ payload_length: 1 + 1 + length_of_length(payload_length) + payload_length,
+ }
+ .encode(out);
+ }
+ out.put_u8(self.tx_type() as u8);
+ out.put_u8(DEPOSIT_VERSION);
+ let header = Header { list: true, payload_length };
+ header.encode(out);
+ self.encode_fields(out);
+ signature.encode(out);
+ }
_ => {
let payload_length = self.fields_len() + signature.payload_len();
if with_header {
@@ -380,6 +142,8 @@ impl Transaction {
Transaction::Legacy(tx) => tx.nonce = nonce,
Transaction::Eip2930(tx) => tx.nonce = nonce,
Transaction::Eip1559(tx) => tx.nonce = nonce,
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_tx) => { /* noop */ }
}
}
@@ -389,6 +153,8 @@ impl Transaction {
Transaction::Legacy(tx) => tx.value = value,
Transaction::Eip2930(tx) => tx.value = value,
Transaction::Eip1559(tx) => tx.value = value,
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(tx) => tx.value = value,
}
}
@@ -398,6 +164,8 @@ impl Transaction {
Transaction::Legacy(tx) => tx.input = input,
Transaction::Eip2930(tx) => tx.input = input,
Transaction::Eip1559(tx) => tx.input = input,
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(tx) => tx.input = input,
}
}
@@ -408,32 +176,42 @@ impl Transaction {
Transaction::Legacy(tx) => tx.size(),
Transaction::Eip2930(tx) => tx.size(),
Transaction::Eip1559(tx) => tx.size(),
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(tx) => tx.size(),
}
}
}
impl Compact for Transaction {
+ // Serializes the TxType to the buffer if necessary, returning 2 bits of the type as an
+ // identifier instead of the length.
fn to_compact(self, buf: &mut B) -> usize
where
B: bytes::BufMut + AsMut<[u8]>,
{
+ let identifier = self.tx_type().to_compact(buf);
match self {
Transaction::Legacy(tx) => {
tx.to_compact(buf);
- 0
}
Transaction::Eip2930(tx) => {
tx.to_compact(buf);
- 1
}
Transaction::Eip1559(tx) => {
tx.to_compact(buf);
- 2
+ }
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(tx) => {
+ tx.to_compact(buf);
}
}
+ identifier
}
- fn from_compact(buf: &[u8], identifier: usize) -> (Self, &[u8]) {
+ // For backwards compatibility purposes, only 2 bits of the type are encoded in the identifier
+ // parameter. In the case of a 3, the full transaction type is read from the buffer as a
+ // single byte.
+ fn from_compact(mut buf: &[u8], identifier: usize) -> (Self, &[u8]) {
match identifier {
0 => {
let (tx, buf) = TxLegacy::from_compact(buf, buf.len());
@@ -447,6 +225,17 @@ impl Compact for Transaction {
let (tx, buf) = TxEip1559::from_compact(buf, buf.len());
(Transaction::Eip1559(tx), buf)
}
+ 3 => {
+ let identifier = buf.get_u8() as usize;
+ match identifier {
+ #[cfg(feature = "optimism")]
+ 126 => {
+ let (tx, buf) = TxDeposit::from_compact(buf, buf.len());
+ (Transaction::Deposit(tx), buf)
+ }
+ _ => unreachable!("Junk data in database: unknown Transaction variant"),
+ }
+ }
_ => unreachable!("Junk data in database: unknown Transaction variant"),
}
}
@@ -469,6 +258,8 @@ impl Transaction {
Transaction::Legacy(TxLegacy { chain_id, .. }) => *chain_id,
Transaction::Eip2930(TxEip2930 { chain_id, .. }) => Some(*chain_id),
Transaction::Eip1559(TxEip1559 { chain_id, .. }) => Some(*chain_id),
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => None,
}
}
@@ -478,6 +269,8 @@ impl Transaction {
Transaction::Legacy(TxLegacy { chain_id: ref mut c, .. }) => *c = Some(chain_id),
Transaction::Eip2930(TxEip2930 { chain_id: ref mut c, .. }) => *c = chain_id,
Transaction::Eip1559(TxEip1559 { chain_id: ref mut c, .. }) => *c = chain_id,
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => (),
}
}
@@ -488,6 +281,8 @@ impl Transaction {
Transaction::Legacy(TxLegacy { to, .. }) |
Transaction::Eip2930(TxEip2930 { to, .. }) |
Transaction::Eip1559(TxEip1559 { to, .. }) => to,
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(TxDeposit { to, .. }) => to,
}
}
@@ -502,6 +297,8 @@ impl Transaction {
Transaction::Legacy { .. } => TxType::Legacy,
Transaction::Eip2930 { .. } => TxType::EIP2930,
Transaction::Eip1559 { .. } => TxType::EIP1559,
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => TxType::DEPOSIT,
}
}
@@ -511,6 +308,8 @@ impl Transaction {
Transaction::Legacy(TxLegacy { value, .. }) => value,
Transaction::Eip2930(TxEip2930 { value, .. }) => value,
Transaction::Eip1559(TxEip1559 { value, .. }) => value,
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(TxDeposit { value, .. }) => value,
}
}
@@ -520,6 +319,9 @@ impl Transaction {
Transaction::Legacy(TxLegacy { nonce, .. }) => *nonce,
Transaction::Eip2930(TxEip2930 { nonce, .. }) => *nonce,
Transaction::Eip1559(TxEip1559 { nonce, .. }) => *nonce,
+ // Deposit transactions don't have a nonce, so they default to zero.
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => 0,
}
}
@@ -529,6 +331,8 @@ impl Transaction {
Transaction::Legacy(TxLegacy { gas_limit, .. }) |
Transaction::Eip2930(TxEip2930 { gas_limit, .. }) |
Transaction::Eip1559(TxEip1559 { gas_limit, .. }) => *gas_limit,
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(TxDeposit { gas_limit, .. }) => *gas_limit,
}
}
@@ -540,6 +344,10 @@ impl Transaction {
Transaction::Legacy(TxLegacy { gas_price, .. }) |
Transaction::Eip2930(TxEip2930 { gas_price, .. }) => *gas_price,
Transaction::Eip1559(TxEip1559 { max_fee_per_gas, .. }) => *max_fee_per_gas,
+ // Deposit transactions buy their L2 gas on L1 and, as such, the L2 gas is not
+ // refundable.
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => 0,
}
}
@@ -554,6 +362,8 @@ impl Transaction {
Transaction::Eip1559(TxEip1559 { max_priority_fee_per_gas, .. }) => {
Some(*max_priority_fee_per_gas)
}
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => None,
}
}
@@ -571,6 +381,8 @@ impl Transaction {
Transaction::Eip1559(TxEip1559 { max_priority_fee_per_gas, .. }) => {
*max_priority_fee_per_gas
}
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => 0,
}
}
@@ -582,6 +394,8 @@ impl Transaction {
Transaction::Legacy(tx) => tx.gas_price,
Transaction::Eip2930(tx) => tx.gas_price,
Transaction::Eip1559(dynamic_tx) => dynamic_tx.effective_gas_price(base_fee),
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => 0,
}
}
@@ -637,9 +451,47 @@ impl Transaction {
Transaction::Legacy(TxLegacy { input, .. }) => input,
Transaction::Eip2930(TxEip2930 { input, .. }) => input,
Transaction::Eip1559(TxEip1559 { input, .. }) => input,
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(TxDeposit { input, .. }) => input,
+ }
+ }
+
+ /// Returns the source hash of the transaction, which uniquely identifies its source.
+ /// If the transaction is not a deposit transaction, this will always return `H256::zero()`.
+ #[cfg(feature = "optimism")]
+ pub fn source_hash(&self) -> H256 {
+ match self {
+ Transaction::Deposit(TxDeposit { source_hash, .. }) => *source_hash,
+ _ => H256::zero(),
+ }
+ }
+
+ /// Returns the amount of ETH locked up on L1 that will be minted on L2. If the transaction
+ /// is not a deposit transaction, this will always return `None`.
+ #[cfg(feature = "optimism")]
+ pub fn mint(&self) -> Option {
+ match self {
+ Transaction::Deposit(TxDeposit { mint, .. }) => *mint,
+ _ => None,
}
}
+ /// Returns whether or not the transaction is a system transaction. If the transaction
+ /// is not a deposit transaction, this will always return `false`.
+ #[cfg(feature = "optimism")]
+ pub fn is_system_transaction(&self) -> bool {
+ match self {
+ Transaction::Deposit(TxDeposit { is_system_transaction, .. }) => *is_system_transaction,
+ _ => false,
+ }
+ }
+
+ /// Returns whether or not the transaction is an Optimism Deposited transaction.
+ #[cfg(feature = "optimism")]
+ pub fn is_deposit(&self) -> bool {
+ matches!(self, Transaction::Deposit(_))
+ }
+
/// Encodes EIP-155 arguments into the desired buffer. Only encodes values for legacy
/// transactions.
pub(crate) fn encode_eip155_fields(&self, out: &mut dyn bytes::BufMut) {
@@ -733,6 +585,8 @@ impl Transaction {
len += access_list.length();
len
}
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(deposit) => deposit.fields_len(),
}
}
@@ -795,6 +649,8 @@ impl Transaction {
input.0.encode(out);
access_list.encode(out);
}
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(deposit) => deposit.encode_fields(out),
}
}
}
@@ -816,6 +672,13 @@ impl Encodable for Transaction {
self.encode_fields(out);
self.encode_eip155_fields(out);
}
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => {
+ out.put_u8(self.tx_type() as u8);
+ out.put_u8(DEPOSIT_VERSION);
+ Header { list: true, payload_length: self.fields_len() }.encode(out);
+ self.encode_fields(out);
+ }
_ => {
out.put_u8(self.tx_type() as u8);
Header { list: true, payload_length: self.fields_len() }.encode(out);
@@ -831,6 +694,12 @@ impl Encodable for Transaction {
// 'header length' + 'payload length'
length_of_length(payload_length) + payload_length
}
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit { .. } => {
+ let payload_length = self.fields_len();
+ // 'tx type byte length' + 'version byte' + 'header length' + 'payload length'
+ 1 + 1 + length_of_length(payload_length) + payload_length
+ }
_ => {
let payload_length = self.fields_len();
// 'transaction type byte length' + 'header length' + 'payload length'
@@ -848,7 +717,7 @@ impl TxEip1559 {
Some(base_fee) => {
// if the tip is greater than the max priority fee per gas, set it to the max
// priority fee per gas + base fee
- let tip = self.max_fee_per_gas - base_fee as u128;
+ let tip = self.max_fee_per_gas.saturating_sub(base_fee as u128);
if tip > self.max_priority_fee_per_gas {
self.max_priority_fee_per_gas + base_fee as u128
} else {
@@ -1109,6 +978,10 @@ impl TransactionSigned {
///
/// Returns `None` if the transaction's signature is invalid, see also [Self::recover_signer].
pub fn recover_signer(&self) -> Option {
+ #[cfg(feature = "optimism")]
+ if let Transaction::Deposit(TxDeposit { from, .. }) = self.transaction {
+ return Some(from)
+ }
let signature_hash = self.signature_hash();
self.signature.recover_signer(signature_hash)
}
@@ -1173,6 +1046,13 @@ impl TransactionSigned {
// 'header length' + 'payload length'
length_of_length(payload_length) + payload_length
}
+ #[cfg(feature = "optimism")]
+ Transaction::Deposit(_) => {
+ let payload_length = self.transaction.fields_len() + self.signature.payload_len();
+ // 'tx type byte length' + 'version byte' + 'header length' + 'payload length'
+ let len = 1 + 1 + length_of_length(payload_length) + payload_length;
+ length_of_length(len) + len
+ }
_ => {
let payload_length = self.transaction.fields_len() + self.signature.payload_len();
// 'transaction type byte length' + 'header length' + 'payload length'
@@ -1244,6 +1124,18 @@ impl TransactionSigned {
let tx_type = *data.first().ok_or(DecodeError::InputTooShort)?;
data.advance(1);
+
+ // If the transaction is a deposit, we need to first ensure that the version
+ // byte is correct.
+ #[cfg(feature = "optimism")]
+ if tx_type == DEPOSIT_TX_TYPE {
+ let version = *data.first().ok_or(DecodeError::InputTooShort)?;
+ if version != DEPOSIT_VERSION {
+ return Err(DecodeError::Custom("Deposit version mismatch"))
+ }
+ data.advance(1);
+ }
+
// decode the list header for the rest of the transaction
let header = Header::decode(data)?;
if !header.list {
@@ -1252,6 +1144,10 @@ impl TransactionSigned {
// length of tx encoding = tx type byte (size = 1) + length of header + payload length
let tx_length = 1 + header.length() + header.payload_length;
+ // If the transaction is a deposit, we need to add one to the length to account for the
+ // version byte.
+ #[cfg(feature = "optimism")]
+ let tx_length = if tx_type == DEPOSIT_TX_TYPE { tx_length + 1 } else { tx_length };
// decode common fields
let transaction = match tx_type {
@@ -1276,6 +1172,22 @@ impl TransactionSigned {
input: Bytes(Decodable::decode(data)?),
access_list: Decodable::decode(data)?,
}),
+ #[cfg(feature = "optimism")]
+ DEPOSIT_TX_TYPE => Transaction::Deposit(TxDeposit {
+ source_hash: Decodable::decode(data)?,
+ from: Decodable::decode(data)?,
+ to: Decodable::decode(data)?,
+ mint: if *data.first().ok_or(DecodeError::InputTooShort)? == EMPTY_STRING_CODE {
+ data.advance(1);
+ None
+ } else {
+ Some(Decodable::decode(data)?)
+ },
+ value: Decodable::decode(data)?,
+ input: Decodable::decode(data)?,
+ gas_limit: Decodable::decode(data)?,
+ is_system_transaction: Decodable::decode(data)?,
+ }),
_ => return Err(DecodeError::Custom("unsupported typed transaction type")),
};
@@ -1484,9 +1396,8 @@ impl IntoRecoveredTransaction for TransactionSignedEcRecovered {
#[cfg(test)]
mod tests {
use crate::{
- transaction::{signature::Signature, TransactionKind, TxEip1559, TxEip2930, TxLegacy},
- AccessList, Address, Bytes, Transaction, TransactionSigned, TransactionSignedEcRecovered,
- H256, U256,
+ transaction::{signature::Signature, TransactionKind, TxEip1559, TxLegacy},
+ Address, Bytes, Transaction, TransactionSigned, TransactionSignedEcRecovered, H256, U256,
};
use bytes::BytesMut;
use ethers_core::utils::hex;
@@ -1500,30 +1411,6 @@ mod tests {
assert_eq!(DecodeError::InputTooShort, res);
}
- #[test]
- fn test_decode_create() {
- // tests that a contract creation tx encodes and decodes properly
- let request = Transaction::Eip2930(TxEip2930 {
- chain_id: 1u64,
- nonce: 0,
- gas_price: 1,
- gas_limit: 2,
- to: TransactionKind::Create,
- value: 3,
- input: Bytes::from(vec![1, 2]),
- access_list: Default::default(),
- });
- let signature = Signature { odd_y_parity: true, r: U256::default(), s: U256::default() };
- let tx = TransactionSigned::from_transaction_and_signature(request, signature);
-
- let mut encoded = BytesMut::new();
- tx.encode(&mut encoded);
- assert_eq!(encoded.len(), tx.length());
-
- let decoded = TransactionSigned::decode(&mut &*encoded).unwrap();
- assert_eq!(decoded, tx);
- }
-
#[test]
fn test_decode_create_goerli() {
// test that an example create tx from goerli decodes properly
@@ -1540,31 +1427,6 @@ mod tests {
assert_eq!(tx_bytes, encoded);
}
- #[test]
- fn test_decode_call() {
- let request = Transaction::Eip2930(TxEip2930 {
- chain_id: 1u64,
- nonce: 0,
- gas_price: 1,
- gas_limit: 2,
- to: TransactionKind::Call(Address::default()),
- value: 3,
- input: Bytes::from(vec![1, 2]),
- access_list: Default::default(),
- });
-
- let signature = Signature { odd_y_parity: true, r: U256::default(), s: U256::default() };
-
- let tx = TransactionSigned::from_transaction_and_signature(request, signature);
-
- let mut encoded = BytesMut::new();
- tx.encode(&mut encoded);
- assert_eq!(encoded.len(), tx.length());
-
- let decoded = TransactionSigned::decode(&mut &*encoded).unwrap();
- assert_eq!(decoded, tx);
- }
-
#[test]
fn decode_transaction_consumes_buffer() {
let bytes = &mut &hex::decode("b87502f872041a8459682f008459682f0d8252089461815774383099e24810ab832a5b2a5425c154d58829a2241af62c000080c001a059e6b67f48fb32e7e570dfb11e042b5ad2e55e3ce3ce9cd989c7e06e07feeafda0016b83f4f980694ed2eee4d10667242b1f40dc406901b34125b008d334d47469").unwrap()[..];
@@ -1726,72 +1588,6 @@ mod tests {
assert_eq!(tx.recover_signer(), Some(signer), "Recovering signer should pass.");
}
- #[test]
- fn recover_signer_legacy() {
- use crate::hex_literal::hex;
-
- let signer: Address = hex!("398137383b3d25c92898c656696e41950e47316b").into();
- let hash: H256 =
- hex!("bb3a336e3f823ec18197f1e13ee875700f08f03e2cab75f0d0b118dabb44cba0").into();
-
- let tx = Transaction::Legacy(TxLegacy {
- chain_id: Some(1),
- nonce: 0x18,
- gas_price: 0xfa56ea00,
- gas_limit: 119902,
- to: TransactionKind::Call( hex!("06012c8cf97bead5deae237070f9587f8e7a266d").into()),
- value: 0x1c6bf526340000u64.into(),
- input: hex!("f7d8c88300000000000000000000000000000000000000000000000000000000000cee6100000000000000000000000000000000000000000000000000000000000ac3e1").into(),
- });
-
- let sig = Signature {
- r: U256::from_be_bytes(hex!(
- "2a378831cf81d99a3f06a18ae1b6ca366817ab4d88a70053c41d7a8f0368e031"
- )),
- s: U256::from_be_bytes(hex!(
- "450d831a05b6e418724436c05c155e0a1b7b921015d0fbc2f667aed709ac4fb5"
- )),
- odd_y_parity: false,
- };
-
- let signed_tx = TransactionSigned::from_transaction_and_signature(tx, sig);
- assert_eq!(signed_tx.hash(), hash, "Expected same hash");
- assert_eq!(signed_tx.recover_signer(), Some(signer), "Recovering signer should pass.");
- }
-
- #[test]
- fn recover_signer_eip1559() {
- use crate::hex_literal::hex;
-
- let signer: Address = hex!("dd6b8b3dc6b7ad97db52f08a275ff4483e024cea").into();
- let hash: H256 =
- hex!("0ec0b6a2df4d87424e5f6ad2a654e27aaeb7dac20ae9e8385cc09087ad532ee0").into();
-
- let tx = Transaction::Eip1559( TxEip1559 {
- chain_id: 1,
- nonce: 0x42,
- gas_limit: 44386,
- to: TransactionKind::Call( hex!("6069a6c32cf691f5982febae4faf8a6f3ab2f0f6").into()),
- value: 0,
- input: hex!("a22cb4650000000000000000000000005eee75727d804a2b13038928d36f8b188945a57a0000000000000000000000000000000000000000000000000000000000000000").into(),
- max_fee_per_gas: 0x4a817c800,
- max_priority_fee_per_gas: 0x3b9aca00,
- access_list: AccessList::default(),
- });
-
- let sig = Signature {
- r: U256::from_str("0x840cfc572845f5786e702984c2a582528cad4b49b2a10b9db1be7fca90058565")
- .unwrap(),
- s: U256::from_str("0x25e7109ceb98168d95b09b18bbf6b685130e0562f233877d492b94eee0c5b6d1")
- .unwrap(),
- odd_y_parity: false,
- };
-
- let signed_tx = TransactionSigned::from_transaction_and_signature(tx, sig);
- assert_eq!(signed_tx.hash(), hash, "Expected same hash");
- assert_eq!(signed_tx.recover_signer(), Some(signer), "Recovering signer should pass.");
- }
-
#[test]
fn test_envelop_encode() {
// random tx:
diff --git a/crates/primitives/src/transaction/optimism.rs b/crates/primitives/src/transaction/optimism.rs
new file mode 100644
index 00000000000..546a6300b6b
--- /dev/null
+++ b/crates/primitives/src/transaction/optimism.rs
@@ -0,0 +1,84 @@
+use crate::{Address, Bytes, TransactionKind, H256};
+use reth_codecs::{main_codec, Compact};
+use reth_rlp::{Encodable, EMPTY_STRING_CODE};
+use std::mem;
+
+/// EIP-2718 transaction type selector.
+pub const DEPOSIT_TX_TYPE: u8 = 126;
+
+/// A versioned byte sequence to enable the protocol to upgrade the deposit transaction type without
+/// changing the transaction type selector.
+pub const DEPOSIT_VERSION: u8 = 0;
+
+/// Deposited transactions, also known as deposits are transactions which are initiated on L1, and
+/// executed on L2. This document outlines a new transaction type for deposits. It also describes
+/// how deposits are initiated on L1, along with the authorization and validation conditions on L2.
+#[main_codec]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
+pub struct TxDeposit {
+ /// Hash that uniquely identifies the source of the deposit.
+ pub source_hash: H256,
+ /// The address of the sender account.
+ pub from: Address,
+ /// The address of the recipient account, or the null (zero-length) address if the deposited
+ /// transaction is a contract creation.
+ pub to: TransactionKind,
+ /// The ETH value to mint on L2.
+ pub mint: Option,
+ /// The ETH value to send to the recipient account.
+ pub value: u128,
+ /// The gas limit for the L2 transaction.
+ pub gas_limit: u64,
+ /// Field indicating if this transaction is exempt from the L2 gas limit.
+ pub is_system_transaction: bool,
+ /// Input has two uses depending if transaction is Create or Call (if `to` field is None or
+ /// Some).
+ pub input: Bytes,
+}
+
+impl TxDeposit {
+ /// Calculates a heuristic for the in-memory size of the [TxDeposit] transaction.
+ #[inline]
+ pub fn size(&self) -> usize {
+ mem::size_of::() + // source_hash
+ mem::size_of::() + // from
+ self.to.size() + // to
+ mem::size_of::>() + // mint
+ mem::size_of::() + // value
+ mem::size_of::() + // gas_limit
+ mem::size_of::() + // is_system_transaction
+ self.input.len() // input
+ }
+
+ /// Outputs the length of the transaction's fields, without a RLP header or length of the
+ /// eip155 fields.
+ pub(crate) fn fields_len(&self) -> usize {
+ let mut len = 0;
+ len += self.source_hash.length();
+ len += self.from.length();
+ len += self.to.length();
+ len += self.mint.map_or(1, |mint| mint.length());
+ len += self.value.length();
+ len += self.input.0.length();
+ len += self.gas_limit.length();
+ len += self.is_system_transaction.length();
+ len
+ }
+
+ /// Encodes only the transaction's fields into the desired buffer, without a RLP header.
+ ///
+ pub(crate) fn encode_fields(&self, out: &mut dyn bytes::BufMut) {
+ self.source_hash.encode(out);
+ self.from.encode(out);
+ self.to.encode(out);
+ if let Some(mint) = self.mint {
+ mint.encode(out);
+ } else {
+ out.put_u8(EMPTY_STRING_CODE);
+ }
+ self.value.encode(out);
+ self.input.encode(out);
+ self.gas_limit.encode(out);
+ self.is_system_transaction.encode(out);
+ }
+}
diff --git a/crates/primitives/src/transaction/signature.rs b/crates/primitives/src/transaction/signature.rs
index 6977d8c2618..eff0c56b392 100644
--- a/crates/primitives/src/transaction/signature.rs
+++ b/crates/primitives/src/transaction/signature.rs
@@ -61,6 +61,11 @@ impl Signature {
/// Output the `v` of the signature depends on chain_id
#[inline]
pub fn v(&self, chain_id: Option) -> u64 {
+ #[cfg(feature = "optimism")]
+ if self.r == U256::ZERO && self.s == U256::ZERO {
+ return 0
+ }
+
if let Some(chain_id) = chain_id {
// EIP-155: v = {0, 1} + CHAIN_ID * 2 + 35
self.odd_y_parity as u64 + chain_id * 2 + 35
diff --git a/crates/primitives/src/transaction/tx_type.rs b/crates/primitives/src/transaction/tx_type.rs
index 428e06f4534..731eee03c6b 100644
--- a/crates/primitives/src/transaction/tx_type.rs
+++ b/crates/primitives/src/transaction/tx_type.rs
@@ -1,4 +1,5 @@
use crate::U8;
+use bytes::Buf;
use reth_codecs::{derive_arbitrary, Compact};
use serde::{Deserialize, Serialize};
@@ -12,7 +13,21 @@ pub const EIP2930_TX_TYPE_ID: u8 = 1;
/// Identifier for [TxEip1559](crate::TxEip1559) transaction.
pub const EIP1559_TX_TYPE_ID: u8 = 2;
+/// Identifier for [TxEip4844](crate::TxEip4844) transaction.
+#[allow(unused)]
+pub(crate) const EIP4844_TX_TYPE_ID: u8 = 3;
+
+/// Identifier for [TxDeposit](crate::TxDeposit) transaction.
+#[cfg(feature = "optimism")]
+use crate::DEPOSIT_TX_TYPE;
+
/// Transaction Type
+///
+/// Currently being used as 2-bit type when encoding it to [`Compact`] on
+/// [`crate::TransactionSignedNoHash`]. Adding more transaction types will break the codec and
+/// database format.
+///
+/// Other required changes when adding a new type can be seen on [PR#3953](https://github.com/paradigmxyz/reth/pull/3953/files).
#[derive_arbitrary(compact)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Serialize, Deserialize)]
pub enum TxType {
@@ -23,6 +38,11 @@ pub enum TxType {
EIP2930 = 1_isize,
/// Transaction with Priority fee
EIP1559 = 2_isize,
+ /// Shard Blob Transactions - EIP-4844
+ EIP4844 = 3_isize,
+ /// OP Deposit transaction.
+ #[cfg(feature = "optimism")]
+ DEPOSIT = DEPOSIT_TX_TYPE as isize,
}
impl From for u8 {
@@ -31,6 +51,9 @@ impl From for u8 {
TxType::Legacy => LEGACY_TX_TYPE_ID,
TxType::EIP2930 => EIP2930_TX_TYPE_ID,
TxType::EIP1559 => EIP1559_TX_TYPE_ID,
+ TxType::EIP4844 => EIP4844_TX_TYPE_ID,
+ #[cfg(feature = "optimism")]
+ TxType::DEPOSIT => DEPOSIT_TX_TYPE,
}
}
}
@@ -42,7 +65,10 @@ impl From for U8 {
}
impl Compact for TxType {
- fn to_compact(self, _: &mut B) -> usize
+ // For backwards compatibility purposes, 2 bits are reserved for the transaction type in the
+ // `StructFlags`. In the case where the transaction type is at least 3, the full transaction
+ // type is encoded into the buffer as a single byte and a 3 is encoded into the flags.
+ fn to_compact(self, buf: &mut B) -> usize
where
B: bytes::BufMut + AsMut<[u8]>,
{
@@ -50,15 +76,24 @@ impl Compact for TxType {
TxType::Legacy => 0,
TxType::EIP2930 => 1,
TxType::EIP1559 => 2,
+ TxType::EIP4844 => 3,
+ #[cfg(feature = "optimism")]
+ TxType::DEPOSIT => 126,
}
}
- fn from_compact(buf: &[u8], identifier: usize) -> (Self, &[u8]) {
+ // For backwards compatibility purposesm only 2 bits of the type are encoded in the identifier
+ // parameter. In the case of a 3, the full transaction type is read from the buffer as a
+ // single byte.
+ fn from_compact(mut buf: &[u8], identifier: usize) -> (Self, &[u8]) {
(
match identifier {
0 => TxType::Legacy,
1 => TxType::EIP2930,
- _ => TxType::EIP1559,
+ 2 => TxType::EIP1559,
+ #[cfg(feature = "optimism")]
+ 126 => TxType::DEPOSIT,
+ _ => TxType::EIP4844,
},
buf,
)
diff --git a/crates/prune/Cargo.toml b/crates/prune/Cargo.toml
index 13d5ae4f916..99a4901cb13 100644
--- a/crates/prune/Cargo.toml
+++ b/crates/prune/Cargo.toml
@@ -20,8 +20,8 @@ reth-interfaces.workspace = true
# misc
tracing.workspace = true
thiserror.workspace = true
-itertools = "0.10"
-rayon = "1.6.0"
+itertools.workspace = true
+rayon.workspace = true
[dev-dependencies]
# reth
diff --git a/crates/prune/src/error.rs b/crates/prune/src/error.rs
index fdc0af4484a..1a31a039422 100644
--- a/crates/prune/src/error.rs
+++ b/crates/prune/src/error.rs
@@ -4,6 +4,9 @@ use thiserror::Error;
#[derive(Error, Debug)]
pub enum PrunerError {
+ #[error(transparent)]
+ PrunePart(#[from] reth_primitives::PrunePartError),
+
#[error("Inconsistent data: {0}")]
InconsistentData(&'static str),
diff --git a/crates/prune/src/pruner.rs b/crates/prune/src/pruner.rs
index de020dcd272..3dae8bcb04f 100644
--- a/crates/prune/src/pruner.rs
+++ b/crates/prune/src/pruner.rs
@@ -72,13 +72,13 @@ impl Pruner {
let provider = self.provider_factory.provider_rw()?;
if let Some((to_block, prune_mode)) =
- self.modes.prune_target_block_receipts(tip_block_number)
+ self.modes.prune_target_block_receipts(tip_block_number)?
{
self.prune_receipts(&provider, to_block, prune_mode)?;
}
if let Some((to_block, prune_mode)) =
- self.modes.prune_target_block_transaction_lookup(tip_block_number)
+ self.modes.prune_target_block_transaction_lookup(tip_block_number)?
{
self.prune_transaction_lookup(&provider, to_block, prune_mode)?;
}
@@ -160,14 +160,18 @@ impl Pruner