diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 99659760a..4eea49b38 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,6 +1,10 @@
* @danipopes @evalir @mattsse
-crates/anvil/ @evalir @mattsse
-crates/evm/coverage/ @evalir @onbjerg
+crates/anvil/ @danipopes @mattsse @evalir
+crates/cheatcodes/ @danipopes @mattsse @klkvr @evalir
+crates/evm/coverage/ @onbjerg
crates/fmt/ @rkrasiuk
-crates/macros/impls/ @danipopes
+crates/linking/ @klkvr
+crates/macros/ @danipopes
+crates/script/ @danipopes @mattsse @klkvr
+crates/wallets/ @klkvr
diff --git a/.github/scripts/matrices.py b/.github/scripts/matrices.py
index 3fdcea115..a71ff3683 100755
--- a/.github/scripts/matrices.py
+++ b/.github/scripts/matrices.py
@@ -69,7 +69,7 @@ def __init__(
t_linux_x86 = Target("ubuntu-latest", "x86_64-unknown-linux-gnu", "linux-amd64")
# TODO: Figure out how to make this work
# t_linux_arm = Target("ubuntu-latest", "aarch64-unknown-linux-gnu", "linux-aarch64")
-t_macos = Target("macos-latest", "x86_64-apple-darwin", "macosx-amd64")
+t_macos = Target("macos-latest", "aarch64-apple-darwin", "macosx-aarch64")
t_windows = Target("windows-latest", "x86_64-pc-windows-msvc", "windows-amd64")
targets = [t_linux_x86, t_windows] if is_pr else [t_linux_x86, t_macos, t_windows]
diff --git a/.github/workflows/deny.yml b/.github/workflows/deny.yml
index 79a421338..72de0dd7a 100644
--- a/.github/workflows/deny.yml
+++ b/.github/workflows/deny.yml
@@ -1,26 +1,26 @@
name: deny
on:
- push:
- branches: [main]
- paths: [Cargo.lock, deny.toml]
- pull_request:
- branches: [main]
- paths: [Cargo.lock, deny.toml]
+ push:
+ branches: [dev]
+ paths: [Cargo.lock, deny.toml]
+ pull_request:
+ branches: [dev]
+ paths: [Cargo.lock, deny.toml]
env:
- CARGO_TERM_COLOR: always
+ CARGO_TERM_COLOR: always
jobs:
- cargo-deny:
- name: cargo deny check
- runs-on: ubuntu-latest
- timeout-minutes: 30
- steps:
- - uses: actions/checkout@v4
- - uses: EmbarkStudios/cargo-deny-action@v1
- with:
- command: check all
- # Clear out arguments to not pass `--all-features` to `cargo deny`.
- # many crates have an `openssl` feature which enables banned dependencies
- arguments: ""
+ cargo-deny:
+ name: cargo deny check
+ runs-on: ubuntu-latest
+ timeout-minutes: 30
+ steps:
+ - uses: actions/checkout@v4
+ - uses: EmbarkStudios/cargo-deny-action@v1
+ with:
+ command: check all
+ # Clear out arguments to not pass `--all-features` to `cargo deny`.
+ # many crates have an `openssl` feature which enables banned dependencies
+ arguments: ""
diff --git a/.github/workflows/dependencies.yml b/.github/workflows/dependencies.yml
index 725b6aeb4..d8e38b8ff 100644
--- a/.github/workflows/dependencies.yml
+++ b/.github/workflows/dependencies.yml
@@ -1,30 +1,30 @@
-# Automatically run `cargo update` periodically
+# Runs `cargo update` periodically.
name: dependencies
on:
- schedule:
- # Run weekly
- - cron: "0 0 * * SUN"
- workflow_dispatch:
- # Needed so we can run it manually
+ 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.
+ 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
-
+ cargo update log
+
- ```log
- $cargo_update_log
- ```
+ ```log
+ $cargo_update_log
+ ```
-
-
+ - ,
@@ -47,7 +48,7 @@ impl Block {
let ommers_hash =
B256::from_slice(alloy_primitives::utils::keccak256(encoded_ommers).as_slice());
let transactions_root =
- trie::ordered_trie_root(transactions.iter().map(|r| Bytes::from(alloy_rlp::encode(r))));
+ trie::ordered_trie_root(transactions.iter().map(|r| r.encoded_2718()));
Self {
header: Header {
@@ -65,12 +66,13 @@ impl Block {
timestamp: partial_header.timestamp,
extra_data: partial_header.extra_data,
mix_hash: partial_header.mix_hash,
- withdrawals_root: Some(partial_header.mix_hash),
- blob_gas_used: None,
- excess_blob_gas: None,
- parent_beacon_block_root: None,
+ withdrawals_root: None,
+ blob_gas_used: partial_header.blob_gas_used,
+ excess_blob_gas: partial_header.excess_blob_gas,
+ parent_beacon_block_root: partial_header.parent_beacon_block_root,
nonce: partial_header.nonce,
base_fee_per_gas: partial_header.base_fee,
+ requests_root: None,
},
transactions,
ommers,
@@ -88,13 +90,16 @@ pub struct PartialHeader {
pub logs_bloom: Bloom,
pub difficulty: U256,
pub number: u64,
- pub gas_limit: u64,
- pub gas_used: u64,
+ pub gas_limit: u128,
+ pub gas_used: u128,
pub timestamp: u64,
pub extra_data: Bytes,
pub mix_hash: B256,
- pub nonce: u64,
- pub base_fee: Option,
+ pub blob_gas_used: Option,
+ pub excess_blob_gas: Option,
+ pub parent_beacon_block_root: Option,
+ pub nonce: B64,
+ pub base_fee: Option,
}
impl From for PartialHeader {
@@ -114,13 +119,15 @@ impl From for PartialHeader {
mix_hash: value.mix_hash,
nonce: value.nonce,
base_fee: value.base_fee_per_gas,
+ blob_gas_used: value.blob_gas_used,
+ excess_blob_gas: value.excess_blob_gas,
+ parent_beacon_block_root: value.parent_beacon_block_root,
}
}
}
#[cfg(test)]
mod tests {
- use alloy_network::Sealable;
use alloy_primitives::{
b256,
hex::{self, FromHex},
@@ -143,23 +150,24 @@ mod tests {
difficulty: Default::default(),
number: 124u64,
gas_limit: Default::default(),
- gas_used: 1337u64,
+ gas_used: 1337u128,
timestamp: 0,
extra_data: Default::default(),
mix_hash: Default::default(),
- nonce: 99u64,
+ nonce: B64::with_last_byte(99),
withdrawals_root: Default::default(),
blob_gas_used: Default::default(),
excess_blob_gas: Default::default(),
parent_beacon_block_root: Default::default(),
base_fee_per_gas: None,
+ requests_root: None,
};
let encoded = alloy_rlp::encode(&header);
let decoded: Header = Header::decode(&mut encoded.as_ref()).unwrap();
assert_eq!(header, decoded);
- header.base_fee_per_gas = Some(12345u64);
+ header.base_fee_per_gas = Some(12345u128);
let encoded = alloy_rlp::encode(&header);
let decoded: Header = Header::decode(&mut encoded.as_ref()).unwrap();
@@ -182,8 +190,8 @@ mod tests {
logs_bloom: Bloom::from_hex("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap(),
difficulty: U256::from(2222),
number: 0xd05u64,
- gas_limit: 0x115cu64,
- gas_used: 0x15b3u64,
+ gas_limit: 0x115cu128,
+ gas_used: 0x15b3u128,
timestamp: 0x1a0au64,
extra_data: hex::decode("7788").unwrap().into(),
mix_hash: B256::from_str("0000000000000000000000000000000000000000000000000000000000000000").unwrap(),
@@ -191,8 +199,9 @@ mod tests {
blob_gas_used: None,
excess_blob_gas: None,
parent_beacon_block_root: None,
- nonce: 0,
+ nonce: B64::ZERO,
base_fee_per_gas: None,
+ requests_root: None,
};
header.encode(&mut data);
@@ -214,17 +223,18 @@ mod tests {
logs_bloom: <[u8; 256]>::from_hex("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap().into(),
difficulty: U256::from(2222),
number: 0xd05u64,
- gas_limit: 0x115cu64,
- gas_used: 0x15b3u64,
+ gas_limit: 0x115cu128,
+ gas_used: 0x15b3u128,
timestamp: 0x1a0au64,
extra_data: hex::decode("7788").unwrap().into(),
mix_hash: B256::from_str("0000000000000000000000000000000000000000000000000000000000000000").unwrap(),
- nonce: 0,
+ nonce: B64::ZERO,
withdrawals_root: None,
blob_gas_used: None,
excess_blob_gas: None,
parent_beacon_block_root: None,
base_fee_per_gas: None,
+ requests_root: None,
};
let header = Header::decode(&mut data.as_slice()).unwrap();
assert_eq!(header, expected);
@@ -245,19 +255,20 @@ mod tests {
logs_bloom: Bloom::from_hex("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap(),
difficulty: U256::from(0x020000),
number: 1u64,
- gas_limit: U256::from(0x016345785d8a0000u128).to::(),
- gas_used: U256::from(0x015534).to::(),
+ gas_limit: U256::from(0x016345785d8a0000u128).to::(),
+ gas_used: U256::from(0x015534).to::(),
timestamp: 0x079e,
extra_data: hex::decode("42").unwrap().into(),
mix_hash: B256::from_str("0000000000000000000000000000000000000000000000000000000000000000").unwrap(),
- nonce: 0,
+ nonce: B64::ZERO,
base_fee_per_gas: Some(875),
withdrawals_root: None,
blob_gas_used: None,
excess_blob_gas: None,
parent_beacon_block_root: None,
+ requests_root: None,
};
- assert_eq!(header.hash(), expected_hash);
+ assert_eq!(header.hash_slow(), expected_hash);
}
#[test]
diff --git a/crates/anvil/core/src/eth/mod.rs b/crates/anvil/core/src/eth/mod.rs
index 87c02d9b8..d2fa41a7b 100644
--- a/crates/anvil/core/src/eth/mod.rs
+++ b/crates/anvil/core/src/eth/mod.rs
@@ -3,13 +3,14 @@ use crate::{
types::{EvmMineOptions, Forking, Index},
};
use alloy_primitives::{Address, Bytes, TxHash, B256, B64, U256};
-use alloy_rpc_trace_types::geth::{GethDebugTracingOptions, GethDefaultTracingOptions};
use alloy_rpc_types::{
pubsub::{Params as SubscriptionParams, SubscriptionKind},
request::TransactionRequest,
state::StateOverride,
BlockId, BlockNumberOrTag as BlockNumber, Filter,
};
+use alloy_rpc_types_trace::geth::{GethDebugTracingOptions, GethDefaultTracingOptions};
+use alloy_serde::WithOtherFields;
pub mod block;
pub mod proof;
@@ -69,6 +70,9 @@ pub enum EthRequest {
)]
EthMaxPriorityFeePerGas(()),
+ #[cfg_attr(feature = "serde", serde(rename = "eth_blobBaseFee", with = "empty_params"))]
+ EthBlobBaseFee(()),
+
#[cfg_attr(
feature = "serde",
serde(rename = "eth_accounts", alias = "eth_requestAccounts", with = "empty_params")
@@ -139,11 +143,11 @@ pub enum EthRequest {
EthGetProof(Address, Vec, Option),
/// The sign method calculates an Ethereum specific signature with:
- #[cfg_attr(feature = "serde", serde(rename = "eth_sign"))]
+ #[cfg_attr(feature = "serde", serde(rename = "eth_sign", alias = "personal_sign"))]
EthSign(Address, Bytes),
- #[cfg_attr(feature = "serde", serde(rename = "eth_signTransaction"))]
- EthSignTransaction(Box),
+ #[cfg_attr(feature = "serde", serde(rename = "eth_signTransaction", with = "sequence"))]
+ EthSignTransaction(Box>),
/// Signs data via [EIP-712](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md).
#[cfg_attr(feature = "serde", serde(rename = "eth_signTypedData"))]
@@ -158,27 +162,27 @@ pub enum EthRequest {
EthSignTypedDataV4(Address, alloy_dyn_abi::TypedData),
#[cfg_attr(feature = "serde", serde(rename = "eth_sendTransaction", with = "sequence"))]
- EthSendTransaction(Box),
+ EthSendTransaction(Box>),
#[cfg_attr(feature = "serde", serde(rename = "eth_sendRawTransaction", with = "sequence"))]
EthSendRawTransaction(Bytes),
#[cfg_attr(feature = "serde", serde(rename = "eth_call"))]
EthCall(
- TransactionRequest,
+ WithOtherFields,
#[cfg_attr(feature = "serde", serde(default))] Option,
#[cfg_attr(feature = "serde", serde(default))] Option,
),
#[cfg_attr(feature = "serde", serde(rename = "eth_createAccessList"))]
EthCreateAccessList(
- TransactionRequest,
+ WithOtherFields,
#[cfg_attr(feature = "serde", serde(default))] Option,
),
#[cfg_attr(feature = "serde", serde(rename = "eth_estimateGas"))]
EthEstimateGas(
- TransactionRequest,
+ WithOtherFields,
#[cfg_attr(feature = "serde", serde(default))] Option,
#[cfg_attr(feature = "serde", serde(default))] Option,
),
@@ -192,6 +196,18 @@ pub enum EthRequest {
#[cfg_attr(feature = "serde", serde(rename = "eth_getTransactionByBlockNumberAndIndex"))]
EthGetTransactionByBlockNumberAndIndex(BlockNumber, Index),
+ #[cfg_attr(
+ feature = "serde",
+ serde(rename = "eth_getRawTransactionByHash", with = "sequence")
+ )]
+ EthGetRawTransactionByHash(TxHash),
+
+ #[cfg_attr(feature = "serde", serde(rename = "eth_getRawTransactionByBlockHashAndIndex"))]
+ EthGetRawTransactionByBlockHashAndIndex(TxHash, Index),
+
+ #[cfg_attr(feature = "serde", serde(rename = "eth_getRawTransactionByBlockNumberAndIndex"))]
+ EthGetRawTransactionByBlockNumberAndIndex(BlockNumber, Index),
+
#[cfg_attr(feature = "serde", serde(rename = "eth_getTransactionReceipt", with = "sequence"))]
EthGetTransactionReceipt(B256),
@@ -262,6 +278,10 @@ pub enum EthRequest {
#[cfg_attr(feature = "serde", serde(rename = "eth_syncing", with = "empty_params"))]
EthSyncing(()),
+ /// geth's `debug_getRawTransaction` endpoint
+ #[cfg_attr(feature = "serde", serde(rename = "debug_getRawTransaction", with = "sequence"))]
+ DebugGetRawTransaction(TxHash),
+
/// geth's `debug_traceTransaction` endpoint
#[cfg_attr(feature = "serde", serde(rename = "debug_traceTransaction"))]
DebugTraceTransaction(
@@ -272,7 +292,7 @@ pub enum EthRequest {
/// geth's `debug_traceCall` endpoint
#[cfg_attr(feature = "serde", serde(rename = "debug_traceCall"))]
DebugTraceCall(
- TransactionRequest,
+ WithOtherFields,
#[cfg_attr(feature = "serde", serde(default))] Option,
#[cfg_attr(feature = "serde", serde(default))] GethDefaultTracingOptions,
),
@@ -371,6 +391,17 @@ pub enum EthRequest {
)]
DropTransaction(B256),
+ /// Removes transactions from the pool
+ #[cfg_attr(
+ feature = "serde",
+ serde(
+ rename = "anvil_dropAllTransactions",
+ alias = "hardhat_dropAllTransactions",
+ with = "empty_params"
+ )
+ )]
+ DropAllTransactions(),
+
/// Reset the fork to a fresh forked state, and optionally update the fork config
#[cfg_attr(feature = "serde", serde(rename = "anvil_reset", alias = "hardhat_reset"))]
Reset(#[cfg_attr(feature = "serde", serde(default))] Option>>),
@@ -597,7 +628,7 @@ pub enum EthRequest {
feature = "serde",
serde(rename = "eth_sendUnsignedTransaction", with = "sequence")
)]
- EthSendUnsignedTransaction(Box),
+ EthSendUnsignedTransaction(Box>),
/// Turn on call traces for transactions that are returned to the user when they execute a
/// transaction (instead of just txhash/receipt)
@@ -606,26 +637,26 @@ pub enum EthRequest {
/// Returns the number of transactions currently pending for inclusion in the next block(s), as
/// well as the ones that are being scheduled for future execution only.
- /// Ref: [Here](https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_status)
+ /// Ref:
#[cfg_attr(feature = "serde", serde(rename = "txpool_status", with = "empty_params"))]
TxPoolStatus(()),
/// Returns a summary of all the transactions currently pending for inclusion in the next
/// block(s), as well as the ones that are being scheduled for future execution only.
- /// Ref: [Here](https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_inspect)
+ /// Ref:
#[cfg_attr(feature = "serde", serde(rename = "txpool_inspect", with = "empty_params"))]
TxPoolInspect(()),
/// Returns the details of all transactions currently pending for inclusion in the next
/// block(s), as well as the ones that are being scheduled for future execution only.
- /// Ref: [Here](https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_content)
+ /// Ref:
#[cfg_attr(feature = "serde", serde(rename = "txpool_content", with = "empty_params"))]
TxPoolContent(()),
/// Otterscan's `ots_getApiLevel` endpoint
/// Otterscan currently requires this endpoint, even though it's not part of the ots_*
- /// https://github.com/otterscan/otterscan/blob/071d8c55202badf01804f6f8d53ef9311d4a9e47/src/useProvider.ts#L71
- /// Related upstream issue: https://github.com/otterscan/otterscan/issues/1081
+ ///
+ /// Related upstream issue:
#[cfg_attr(feature = "serde", serde(rename = "erigon_getHeaderByNumber"))]
ErigonGetHeaderByNumber(
#[cfg_attr(
@@ -676,7 +707,7 @@ pub enum EthRequest {
OtsGetBlockDetails(
#[cfg_attr(
feature = "serde",
- serde(deserialize_with = "lenient_block_number::lenient_block_number", default)
+ serde(deserialize_with = "lenient_block_number::lenient_block_number_seq", default)
)]
BlockNumber,
),
@@ -717,6 +748,13 @@ pub enum EthRequest {
/// contract.
#[cfg_attr(feature = "serde", serde(rename = "ots_getContractCreator", with = "sequence"))]
OtsGetContractCreator(Address),
+
+ /// Removes transactions from the pool by sender origin.
+ #[cfg_attr(
+ feature = "serde",
+ serde(rename = "anvil_removePoolTransactions", with = "sequence")
+ )]
+ RemovePoolTransactions(Address),
}
/// Represents ethereum JSON-RPC API
@@ -1399,6 +1437,25 @@ mod tests {
let _req = serde_json::from_value::(value).unwrap();
}
+ #[test]
+ fn test_serde_debug_raw_transaction() {
+ let s = r#"{"jsonrpc":"2.0","method":"debug_getRawTransaction","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
+ let value: serde_json::Value = serde_json::from_str(s).unwrap();
+ let _req = serde_json::from_value::(value).unwrap();
+
+ let s = r#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByHash","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
+ let value: serde_json::Value = serde_json::from_str(s).unwrap();
+ let _req = serde_json::from_value::(value).unwrap();
+
+ let s = r#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByBlockHashAndIndex","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c",1],"id":1}"#;
+ let value: serde_json::Value = serde_json::from_str(s).unwrap();
+ let _req = serde_json::from_value::(value).unwrap();
+
+ let s = r#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByBlockNumberAndIndex","params":["0x3ed3a89b",0],"id":1}"#;
+ let value: serde_json::Value = serde_json::from_str(s).unwrap();
+ let _req = serde_json::from_value::(value).unwrap();
+ }
+
#[test]
fn test_serde_debug_trace_transaction() {
let s = r#"{"method": "debug_traceTransaction", "params":
@@ -1500,10 +1557,29 @@ true}]}"#;
let _req = serde_json::from_value::(value).unwrap();
}
+ #[test]
+ fn test_eth_sign() {
+ let s = r#"{"method": "eth_sign", "params":
+["0xd84de507f3fada7df80908082d3239466db55a71", "0x00"]}"#;
+ let value: serde_json::Value = serde_json::from_str(s).unwrap();
+ let _req = serde_json::from_value::(value).unwrap();
+ let s = r#"{"method": "personal_sign", "params":
+["0xd84de507f3fada7df80908082d3239466db55a71", "0x00"]}"#;
+ let value: serde_json::Value = serde_json::from_str(s).unwrap();
+ let _req = serde_json::from_value::(value).unwrap();
+ }
+
#[test]
fn test_eth_sign_typed_data() {
let s = r#"{"method":"eth_signTypedData_v4","params":["0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826", {"types":{"EIP712Domain":[{"name":"name","type":"string"},{"name":"version","type":"string"},{"name":"chainId","type":"uint256"},{"name":"verifyingContract","type":"address"}],"Person":[{"name":"name","type":"string"},{"name":"wallet","type":"address"}],"Mail":[{"name":"from","type":"Person"},{"name":"to","type":"Person"},{"name":"contents","type":"string"}]},"primaryType":"Mail","domain":{"name":"Ether Mail","version":"1","chainId":1,"verifyingContract":"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"},"message":{"from":{"name":"Cow","wallet":"0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"},"to":{"name":"Bob","wallet":"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"},"contents":"Hello, Bob!"}}]}"#;
let value: serde_json::Value = serde_json::from_str(s).unwrap();
let _req = serde_json::from_value::(value).unwrap();
}
+
+ #[test]
+ fn test_remove_pool_transactions() {
+ let s = r#"{"method": "anvil_removePoolTransactions", "params":["0x364d6D0333432C3Ac016Ca832fb8594A8cE43Ca6"]}"#;
+ let value: serde_json::Value = serde_json::from_str(s).unwrap();
+ let _req = serde_json::from_value::(value).unwrap();
+ }
}
diff --git a/crates/anvil/core/src/eth/proof.rs b/crates/anvil/core/src/eth/proof.rs
index ba2357bff..450e53e47 100644
--- a/crates/anvil/core/src/eth/proof.rs
+++ b/crates/anvil/core/src/eth/proof.rs
@@ -14,7 +14,7 @@ pub struct BasicAccount {
impl Default for BasicAccount {
fn default() -> Self {
- BasicAccount {
+ Self {
balance: U256::ZERO,
nonce: U256::ZERO,
code_hash: KECCAK_EMPTY,
diff --git a/crates/anvil/core/src/eth/serde_helpers.rs b/crates/anvil/core/src/eth/serde_helpers.rs
index 311b3a9f2..f7d5bd46d 100644
--- a/crates/anvil/core/src/eth/serde_helpers.rs
+++ b/crates/anvil/core/src/eth/serde_helpers.rs
@@ -33,35 +33,6 @@ pub mod sequence {
}
}
-pub mod numeric {
- use alloy_primitives::U256;
- use serde::{Deserialize, Deserializer};
- /// Supports parsing u64
- ///
- /// See
- pub fn deserialize_stringified_u64_opt<'de, D>(deserializer: D) -> Result, D::Error>
- where
- D: Deserializer<'de>,
- {
- if let Some(num) = Option::::deserialize(deserializer)? {
- num.try_into().map(Some).map_err(serde::de::Error::custom)
- } else {
- Ok(None)
- }
- }
-
- /// Supports parsing u64
- ///
- /// See
- pub fn deserialize_stringified_u64<'de, D>(deserializer: D) -> Result
- where
- D: Deserializer<'de>,
- {
- let num = U256::deserialize(deserializer)?;
- num.try_into().map_err(serde::de::Error::custom)
- }
-}
-
/// A module that deserializes `[]` optionally
pub mod empty_params {
use serde::{Deserialize, Deserializer};
diff --git a/crates/anvil/core/src/eth/subscription.rs b/crates/anvil/core/src/eth/subscription.rs
index cc162cc4d..9d347e9a6 100644
--- a/crates/anvil/core/src/eth/subscription.rs
+++ b/crates/anvil/core/src/eth/subscription.rs
@@ -14,20 +14,18 @@ pub enum SubscriptionId {
String(String),
}
-// === impl SubscriptionId ===
-
impl SubscriptionId {
/// Generates a new random hex identifier
pub fn random_hex() -> Self {
- SubscriptionId::String(hex_id())
+ Self::String(hex_id())
}
}
impl fmt::Display for SubscriptionId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
- SubscriptionId::Number(num) => num.fmt(f),
- SubscriptionId::String(s) => s.fmt(f),
+ Self::Number(num) => num.fmt(f),
+ Self::String(s) => s.fmt(f),
}
}
}
@@ -35,8 +33,8 @@ impl fmt::Display for SubscriptionId {
impl fmt::Debug for SubscriptionId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
- SubscriptionId::Number(num) => num.fmt(f),
- SubscriptionId::String(s) => s.fmt(f),
+ Self::Number(num) => num.fmt(f),
+ Self::String(s) => s.fmt(f),
}
}
}
@@ -47,8 +45,6 @@ pub struct HexIdProvider {
len: usize,
}
-// === impl HexIdProvider ===
-
impl HexIdProvider {
/// Generates a random hex encoded Id
pub fn gen(&self) -> String {
diff --git a/crates/anvil/core/src/eth/transaction/mod.rs b/crates/anvil/core/src/eth/transaction/mod.rs
index afc16b928..83db64465 100644
--- a/crates/anvil/core/src/eth/transaction/mod.rs
+++ b/crates/anvil/core/src/eth/transaction/mod.rs
@@ -1,25 +1,27 @@
//! Transaction related types
-use crate::eth::{
- transaction::optimism::{DepositTransaction, DepositTransactionRequest},
- utils::eip_to_revm_access_list,
+use crate::eth::transaction::optimism::{DepositTransaction, DepositTransactionRequest};
+use alloy_consensus::{
+ transaction::eip4844::{TxEip4844, TxEip4844Variant, TxEip4844WithSidecar},
+ AnyReceiptEnvelope, Receipt, ReceiptEnvelope, ReceiptWithBloom, Signed, TxEip1559, TxEip2930,
+ TxEnvelope, TxLegacy, TxReceipt,
};
-use alloy_consensus::{ReceiptWithBloom, TxEip1559, TxEip2930, TxLegacy};
-use alloy_network::{Signed, Transaction, TxKind};
-use alloy_primitives::{Address, Bloom, Bytes, Log, Signature, TxHash, B256, U128, U256, U64};
-use alloy_rlp::{Decodable, Encodable};
+use alloy_eips::eip2718::{Decodable2718, Eip2718Error, Encodable2718};
+use alloy_primitives::{Address, Bloom, Bytes, Log, Signature, TxHash, TxKind, B256, U256, U64};
+use alloy_rlp::{length_of_length, Decodable, Encodable, Header};
use alloy_rpc_types::{
- request::TransactionRequest, AccessList, Signature as RpcSignature,
- Transaction as RpcTransaction,
+ request::TransactionRequest, AccessList, AnyTransactionReceipt, Signature as RpcSignature,
+ Transaction as RpcTransaction, TransactionReceipt,
};
+use alloy_serde::{OtherFields, WithOtherFields};
+use bytes::BufMut;
use foundry_evm::traces::CallTraceNode;
use revm::{
interpreter::InstructionResult,
- primitives::{CreateScheme, OptimismFields, TransactTo, TxEnv},
+ primitives::{OptimismFields, TransactTo, TxEnv},
};
-use std::ops::Deref;
-
-use super::utils::from_eip_to_alloy_access_list;
+use serde::{Deserialize, Serialize};
+use std::ops::{Deref, Mul};
pub mod optimism;
@@ -32,30 +34,37 @@ pub fn impersonated_signature() -> Signature {
/// Converts a [TransactionRequest] into a [TypedTransactionRequest].
/// Should be removed once the call builder abstraction for providers is in place.
-pub fn transaction_request_to_typed(tx: TransactionRequest) -> Option {
- let TransactionRequest {
- from,
- to,
- gas_price,
- max_fee_per_gas,
- max_priority_fee_per_gas,
- gas,
- value,
- input,
- nonce,
- mut access_list,
- transaction_type,
+pub fn transaction_request_to_typed(
+ tx: WithOtherFields,
+) -> Option {
+ let WithOtherFields:: {
+ inner:
+ TransactionRequest {
+ from,
+ to,
+ gas_price,
+ max_fee_per_gas,
+ max_priority_fee_per_gas,
+ max_fee_per_blob_gas,
+ blob_versioned_hashes,
+ gas,
+ value,
+ input,
+ nonce,
+ access_list,
+ sidecar,
+ transaction_type,
+ ..
+ },
other,
- ..
} = tx;
- let transaction_type = transaction_type.map(|id| id.to::());
// Special case: OP-stack deposit tx
- if transaction_type == Some(126) {
+ if transaction_type == Some(0x7E) || has_optimism_fields(&other) {
return Some(TypedTransactionRequest::Deposit(DepositTransactionRequest {
from: from.unwrap_or_default(),
source_hash: other.get_deserialized::("sourceHash")?.ok()?,
- kind: to.into(),
+ kind: to.unwrap_or_default(),
mint: other.get_deserialized::("mint")?.ok()?,
value: value.unwrap_or_default(),
gas_limit: gas.unwrap_or_default(),
@@ -69,69 +78,95 @@ pub fn transaction_request_to_typed(tx: TransactionRequest) -> Option {
+ (Some(0), _, None, None, None, None, None, None, _) |
+ (None, Some(_), None, None, None, None, None, None, _) => {
Some(TypedTransactionRequest::Legacy(TxLegacy {
- nonce: nonce.unwrap_or_default().to::(),
- gas_price: gas_price.unwrap_or_default().to::(),
- gas_limit: gas.unwrap_or_default().to::(),
+ nonce: nonce.unwrap_or_default(),
+ gas_price: gas_price.unwrap_or_default(),
+ gas_limit: gas.unwrap_or_default(),
value: value.unwrap_or(U256::ZERO),
input: input.into_input().unwrap_or_default(),
- to: match to {
- Some(to) => TxKind::Call(to),
- None => TxKind::Create,
- },
+ to: to.unwrap_or_default(),
chain_id: None,
}))
}
// EIP2930
- (Some(1), _, None, None, _) | (None, _, None, None, Some(_)) => {
+ (Some(1), _, None, None, _, None, None, None, _) |
+ (None, _, None, None, Some(_), None, None, None, _) => {
Some(TypedTransactionRequest::EIP2930(TxEip2930 {
- nonce: nonce.unwrap_or_default().to::(),
- gas_price: gas_price.unwrap_or_default().to(),
- gas_limit: gas.unwrap_or_default().to::(),
+ nonce: nonce.unwrap_or_default(),
+ gas_price: gas_price.unwrap_or_default(),
+ gas_limit: gas.unwrap_or_default(),
value: value.unwrap_or(U256::ZERO),
input: input.into_input().unwrap_or_default(),
- to: match to {
- Some(to) => TxKind::Call(to),
- None => TxKind::Create,
- },
+ to: to.unwrap_or_default(),
chain_id: 0,
- access_list: to_eip_access_list(access_list.unwrap_or_default()),
+ access_list: access_list.unwrap_or_default(),
}))
}
// EIP1559
- (Some(2), None, _, _, _) |
- (None, None, Some(_), _, _) |
- (None, None, _, Some(_), _) |
- (None, None, None, None, None) => {
+ (Some(2), None, _, _, _, _, None, None, _) |
+ (None, None, Some(_), _, _, _, None, None, _) |
+ (None, None, _, Some(_), _, _, None, None, _) |
+ (None, None, None, None, None, _, None, None, _) => {
// Empty fields fall back to the canonical transaction schema.
Some(TypedTransactionRequest::EIP1559(TxEip1559 {
- nonce: nonce.unwrap_or_default().to::(),
- max_fee_per_gas: max_fee_per_gas.unwrap_or_default().to::(),
- max_priority_fee_per_gas: max_priority_fee_per_gas.unwrap_or_default().to::(),
- gas_limit: gas.unwrap_or_default().to::(),
+ nonce: nonce.unwrap_or_default(),
+ max_fee_per_gas: max_fee_per_gas.unwrap_or_default(),
+ max_priority_fee_per_gas: max_priority_fee_per_gas.unwrap_or_default(),
+ gas_limit: gas.unwrap_or_default(),
value: value.unwrap_or(U256::ZERO),
input: input.into_input().unwrap_or_default(),
- to: match to {
- Some(to) => TxKind::Call(to),
- None => TxKind::Create,
- },
+ to: to.unwrap_or_default(),
chain_id: 0,
- access_list: to_eip_access_list(access_list.unwrap_or_default()),
+ access_list: access_list.unwrap_or_default(),
}))
}
+ // EIP4844
+ (Some(3), None, _, _, _, Some(_), Some(_), Some(sidecar), to) => {
+ let tx = TxEip4844 {
+ nonce: nonce.unwrap_or_default(),
+ max_fee_per_gas: max_fee_per_gas.unwrap_or_default(),
+ max_priority_fee_per_gas: max_priority_fee_per_gas.unwrap_or_default(),
+ max_fee_per_blob_gas: max_fee_per_blob_gas.unwrap_or_default(),
+ gas_limit: gas.unwrap_or_default(),
+ value: value.unwrap_or(U256::ZERO),
+ input: input.into_input().unwrap_or_default(),
+ to: match to.unwrap_or(TxKind::Create) {
+ TxKind::Call(to) => to,
+ TxKind::Create => Address::ZERO,
+ },
+ chain_id: 0,
+ access_list: access_list.unwrap_or_default(),
+ blob_versioned_hashes: blob_versioned_hashes.unwrap_or_default(),
+ };
+ Some(TypedTransactionRequest::EIP4844(TxEip4844Variant::TxEip4844WithSidecar(
+ TxEip4844WithSidecar::from_tx_and_sidecar(tx, sidecar),
+ )))
+ }
_ => None,
}
}
+fn has_optimism_fields(other: &OtherFields) -> bool {
+ other.contains_key("sourceHash") &&
+ other.contains_key("mint") &&
+ other.contains_key("isSystemTx")
+}
+
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TypedTransactionRequest {
Legacy(TxLegacy),
EIP2930(TxEip2930),
EIP1559(TxEip1559),
+ EIP4844(TxEip4844Variant),
Deposit(DepositTransactionRequest),
}
@@ -197,13 +232,13 @@ impl From for TypedTransaction {
impl From for MaybeImpersonatedTransaction {
fn from(value: TypedTransaction) -> Self {
- MaybeImpersonatedTransaction::new(value)
+ Self::new(value)
}
}
impl Decodable for MaybeImpersonatedTransaction {
fn decode(buf: &mut &[u8]) -> alloy_rlp::Result {
- TypedTransaction::decode(buf).map(MaybeImpersonatedTransaction::new)
+ TypedTransaction::decode(buf).map(Self::new)
}
}
@@ -237,19 +272,19 @@ pub fn to_alloy_transaction_with_hash_and_sender(
match transaction {
TypedTransaction::Legacy(t) => RpcTransaction {
hash,
- nonce: U64::from(t.nonce),
+ nonce: t.tx().nonce,
block_hash: None,
block_number: None,
transaction_index: None,
from,
to: None,
- value: t.value,
- gas_price: Some(U128::from(t.gas_price)),
- max_fee_per_gas: Some(U128::from(t.gas_price)),
- max_priority_fee_per_gas: Some(U128::from(t.gas_price)),
- gas: U256::from(t.gas_limit),
- input: t.input.clone(),
- chain_id: t.chain_id.map(U64::from),
+ value: t.tx().value,
+ gas_price: Some(t.tx().gas_price),
+ max_fee_per_gas: Some(t.tx().gas_price),
+ max_priority_fee_per_gas: Some(t.tx().gas_price),
+ gas: t.tx().gas_limit,
+ input: t.tx().input.clone(),
+ chain_id: t.tx().chain_id,
signature: Some(RpcSignature {
r: t.signature().r(),
s: t.signature().s(),
@@ -259,66 +294,93 @@ pub fn to_alloy_transaction_with_hash_and_sender(
access_list: None,
transaction_type: None,
max_fee_per_blob_gas: None,
- blob_versioned_hashes: vec![],
+ blob_versioned_hashes: None,
other: Default::default(),
},
TypedTransaction::EIP2930(t) => RpcTransaction {
hash,
- nonce: U64::from(t.nonce),
+ nonce: t.tx().nonce,
block_hash: None,
block_number: None,
transaction_index: None,
from,
to: None,
- value: t.value,
- gas_price: Some(U128::from(t.gas_price)),
- max_fee_per_gas: Some(U128::from(t.gas_price)),
- max_priority_fee_per_gas: Some(U128::from(t.gas_price)),
- gas: U256::from(t.gas_limit),
- input: t.input.clone(),
- chain_id: Some(U64::from(t.chain_id)),
+ value: t.tx().value,
+ gas_price: Some(t.tx().gas_price),
+ max_fee_per_gas: Some(t.tx().gas_price),
+ max_priority_fee_per_gas: Some(t.tx().gas_price),
+ gas: t.tx().gas_limit,
+ input: t.tx().input.clone(),
+ chain_id: Some(t.tx().chain_id),
signature: Some(RpcSignature {
r: t.signature().r(),
s: t.signature().s(),
v: U256::from(t.signature().v().y_parity_byte()),
y_parity: Some(alloy_rpc_types::Parity::from(t.signature().v().y_parity())),
}),
- access_list: Some(from_eip_to_alloy_access_list(t.access_list.clone()).0),
- transaction_type: Some(U64::from(1)),
+ access_list: Some(t.tx().access_list.clone()),
+ transaction_type: Some(1),
max_fee_per_blob_gas: None,
- blob_versioned_hashes: vec![],
+ blob_versioned_hashes: None,
other: Default::default(),
},
TypedTransaction::EIP1559(t) => RpcTransaction {
hash,
- nonce: U64::from(t.nonce),
+ nonce: t.tx().nonce,
block_hash: None,
block_number: None,
transaction_index: None,
from,
to: None,
- value: t.value,
+ value: t.tx().value,
gas_price: None,
- max_fee_per_gas: Some(U128::from(t.max_fee_per_gas)),
- max_priority_fee_per_gas: Some(U128::from(t.max_priority_fee_per_gas)),
- gas: U256::from(t.gas_limit),
- input: t.input.clone(),
- chain_id: Some(U64::from(t.chain_id)),
+ max_fee_per_gas: Some(t.tx().max_fee_per_gas),
+ max_priority_fee_per_gas: Some(t.tx().max_priority_fee_per_gas),
+ gas: t.tx().gas_limit,
+ input: t.tx().input.clone(),
+ chain_id: Some(t.tx().chain_id),
signature: Some(RpcSignature {
r: t.signature().r(),
s: t.signature().s(),
v: U256::from(t.signature().v().y_parity_byte()),
y_parity: Some(alloy_rpc_types::Parity::from(t.signature().v().y_parity())),
}),
- access_list: Some(from_eip_to_alloy_access_list(t.access_list.clone()).0),
- transaction_type: Some(U64::from(2)),
+ access_list: Some(t.tx().access_list.clone()),
+ transaction_type: Some(2),
max_fee_per_blob_gas: None,
- blob_versioned_hashes: vec![],
+ blob_versioned_hashes: None,
+ other: Default::default(),
+ },
+ TypedTransaction::EIP4844(t) => RpcTransaction {
+ hash,
+ nonce: t.tx().tx().nonce,
+ block_hash: None,
+ block_number: None,
+ transaction_index: None,
+ from,
+ to: None,
+ value: t.tx().tx().value,
+ gas_price: Some(t.tx().tx().max_fee_per_gas),
+ max_fee_per_gas: Some(t.tx().tx().max_fee_per_gas),
+ max_priority_fee_per_gas: Some(t.tx().tx().max_priority_fee_per_gas),
+ gas: t.tx().tx().gas_limit,
+ input: t.tx().tx().input.clone(),
+ chain_id: Some(t.tx().tx().chain_id),
+ signature: Some(RpcSignature {
+ r: t.signature().r(),
+ s: t.signature().s(),
+ v: U256::from(t.signature().v().y_parity_byte()),
+ y_parity: Some(alloy_rpc_types::Parity::from(t.signature().v().y_parity())),
+ }),
+ access_list: Some(t.tx().tx().access_list.clone()),
+ transaction_type: Some(3),
+ max_fee_per_blob_gas: Some(t.tx().tx().max_fee_per_blob_gas),
+ blob_versioned_hashes: Some(t.tx().tx().blob_versioned_hashes.clone()),
other: Default::default(),
},
TypedTransaction::Deposit(t) => RpcTransaction {
hash,
- nonce: U64::from(t.nonce),
+ nonce: t.nonce,
block_hash: None,
block_number: None,
transaction_index: None,
@@ -328,14 +390,14 @@ pub fn to_alloy_transaction_with_hash_and_sender(
gas_price: None,
max_fee_per_gas: None,
max_priority_fee_per_gas: None,
- gas: U256::from(t.gas_limit),
+ gas: t.gas_limit,
input: t.input.clone().0.into(),
- chain_id: t.chain_id().map(U64::from),
+ chain_id: t.chain_id().map(u64::from),
signature: None,
access_list: None,
transaction_type: None,
max_fee_per_blob_gas: None,
- blob_versioned_hashes: vec![],
+ blob_versioned_hashes: None,
other: Default::default(),
},
}
@@ -369,7 +431,7 @@ impl PendingTransaction {
}
}
- pub fn nonce(&self) -> U256 {
+ pub fn nonce(&self) -> u64 {
self.transaction.nonce()
}
@@ -387,25 +449,25 @@ impl PendingTransaction {
fn transact_to(kind: &TxKind) -> TransactTo {
match kind {
TxKind::Call(c) => TransactTo::Call(*c),
- TxKind::Create => TransactTo::Create(CreateScheme::Create),
+ TxKind::Create => TransactTo::Create,
}
}
let caller = *self.sender();
match &self.transaction.transaction {
TypedTransaction::Legacy(tx) => {
- let chain_id = tx.chain_id();
+ let chain_id = tx.tx().chain_id;
let TxLegacy { nonce, gas_price, gas_limit, value, to, input, .. } = tx.tx();
TxEnv {
caller,
transact_to: transact_to(to),
- data: alloy_primitives::Bytes(input.0.clone()),
+ data: input.clone(),
chain_id,
nonce: Some(*nonce),
value: (*value),
gas_price: U256::from(*gas_price),
gas_priority_fee: None,
- gas_limit: *gas_limit,
+ gas_limit: *gas_limit as u64,
access_list: vec![],
..Default::default()
}
@@ -425,14 +487,14 @@ impl PendingTransaction {
TxEnv {
caller,
transact_to: transact_to(to),
- data: alloy_primitives::Bytes(input.0.clone()),
+ data: input.clone(),
chain_id: Some(*chain_id),
nonce: Some(*nonce),
value: *value,
gas_price: U256::from(*gas_price),
gas_priority_fee: None,
- gas_limit: *gas_limit,
- access_list: eip_to_revm_access_list(access_list.0.clone()),
+ gas_limit: *gas_limit as u64,
+ access_list: access_list.flattened(),
..Default::default()
}
}
@@ -452,14 +514,45 @@ impl PendingTransaction {
TxEnv {
caller,
transact_to: transact_to(to),
- data: alloy_primitives::Bytes(input.0.clone()),
+ data: input.clone(),
chain_id: Some(*chain_id),
nonce: Some(*nonce),
value: *value,
gas_price: U256::from(*max_fee_per_gas),
gas_priority_fee: Some(U256::from(*max_priority_fee_per_gas)),
- gas_limit: *gas_limit,
- access_list: eip_to_revm_access_list(access_list.0.clone()),
+ gas_limit: *gas_limit as u64,
+ access_list: access_list.flattened(),
+ ..Default::default()
+ }
+ }
+ TypedTransaction::EIP4844(tx) => {
+ let TxEip4844 {
+ chain_id,
+ nonce,
+ max_fee_per_blob_gas,
+ max_fee_per_gas,
+ max_priority_fee_per_gas,
+ gas_limit,
+ to,
+ value,
+ input,
+ access_list,
+ blob_versioned_hashes,
+ ..
+ } = tx.tx().tx();
+ TxEnv {
+ caller,
+ transact_to: TransactTo::call(*to),
+ data: input.clone(),
+ chain_id: Some(*chain_id),
+ nonce: Some(*nonce),
+ value: *value,
+ gas_price: U256::from(*max_fee_per_gas),
+ gas_priority_fee: Some(U256::from(*max_priority_fee_per_gas)),
+ max_fee_per_blob_gas: Some(U256::from(*max_fee_per_blob_gas)),
+ blob_hashes: blob_versioned_hashes.clone(),
+ gas_limit: *gas_limit as u64,
+ access_list: access_list.flattened(),
..Default::default()
}
}
@@ -479,13 +572,13 @@ impl PendingTransaction {
TxEnv {
caller,
transact_to: transact_to(kind),
- data: alloy_primitives::Bytes(input.0.clone()),
+ data: input.clone(),
chain_id,
- nonce: Some(nonce.to::()),
+ nonce: Some(*nonce),
value: *value,
gas_price: U256::ZERO,
gas_priority_fee: None,
- gas_limit: gas_limit.to::(),
+ gas_limit: *gas_limit as u64,
access_list: vec![],
optimism: OptimismFields {
source_hash: Some(*source_hash),
@@ -501,7 +594,7 @@ impl PendingTransaction {
}
/// Container type for signed, typed transactions.
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum TypedTransaction {
/// Legacy transaction type
Legacy(Signed),
@@ -509,107 +602,159 @@ pub enum TypedTransaction {
EIP2930(Signed),
/// EIP-1559 transaction
EIP1559(Signed),
+ /// EIP-4844 transaction
+ EIP4844(Signed),
/// op-stack deposit transaction
Deposit(DepositTransaction),
}
impl TypedTransaction {
- /// Returns true if the transaction uses dynamic fees: EIP1559
+ /// Returns true if the transaction uses dynamic fees: EIP1559 or EIP4844
pub fn is_dynamic_fee(&self) -> bool {
- matches!(self, TypedTransaction::EIP1559(_))
+ matches!(self, Self::EIP1559(_)) || matches!(self, Self::EIP4844(_))
}
- pub fn gas_price(&self) -> U256 {
- U256::from(match self {
- TypedTransaction::Legacy(tx) => tx.gas_price,
- TypedTransaction::EIP2930(tx) => tx.gas_price,
- TypedTransaction::EIP1559(tx) => tx.max_fee_per_gas,
- TypedTransaction::Deposit(_) => 0,
- })
+ pub fn gas_price(&self) -> u128 {
+ match self {
+ Self::Legacy(tx) => tx.tx().gas_price,
+ Self::EIP2930(tx) => tx.tx().gas_price,
+ Self::EIP1559(tx) => tx.tx().max_fee_per_gas,
+ Self::EIP4844(tx) => tx.tx().tx().max_fee_per_gas,
+ Self::Deposit(_) => 0,
+ }
}
- pub fn gas_limit(&self) -> U256 {
- U256::from(match self {
- TypedTransaction::Legacy(tx) => tx.gas_limit,
- TypedTransaction::EIP2930(tx) => tx.gas_limit,
- TypedTransaction::EIP1559(tx) => tx.gas_limit,
- TypedTransaction::Deposit(tx) => tx.gas_limit.to::(),
- })
+ pub fn gas_limit(&self) -> u128 {
+ match self {
+ Self::Legacy(tx) => tx.tx().gas_limit,
+ Self::EIP2930(tx) => tx.tx().gas_limit,
+ Self::EIP1559(tx) => tx.tx().gas_limit,
+ Self::EIP4844(tx) => tx.tx().tx().gas_limit,
+ Self::Deposit(tx) => tx.gas_limit,
+ }
}
pub fn value(&self) -> U256 {
U256::from(match self {
- TypedTransaction::Legacy(tx) => tx.value,
- TypedTransaction::EIP2930(tx) => tx.value,
- TypedTransaction::EIP1559(tx) => tx.value,
- TypedTransaction::Deposit(tx) => tx.value,
+ Self::Legacy(tx) => tx.tx().value,
+ Self::EIP2930(tx) => tx.tx().value,
+ Self::EIP1559(tx) => tx.tx().value,
+ Self::EIP4844(tx) => tx.tx().tx().value,
+ Self::Deposit(tx) => tx.value,
})
}
pub fn data(&self) -> &Bytes {
match self {
- TypedTransaction::Legacy(tx) => &tx.input,
- TypedTransaction::EIP2930(tx) => &tx.input,
- TypedTransaction::EIP1559(tx) => &tx.input,
- TypedTransaction::Deposit(tx) => &tx.input,
+ Self::Legacy(tx) => &tx.tx().input,
+ Self::EIP2930(tx) => &tx.tx().input,
+ Self::EIP1559(tx) => &tx.tx().input,
+ Self::EIP4844(tx) => &tx.tx().tx().input,
+ Self::Deposit(tx) => &tx.input,
}
}
/// Returns the transaction type
pub fn r#type(&self) -> Option {
match self {
- TypedTransaction::Legacy(_) => None,
- TypedTransaction::EIP2930(_) => Some(1),
- TypedTransaction::EIP1559(_) => Some(2),
- TypedTransaction::Deposit(_) => Some(0x7E),
+ Self::Legacy(_) => None,
+ Self::EIP2930(_) => Some(1),
+ Self::EIP1559(_) => Some(2),
+ Self::EIP4844(_) => Some(3),
+ Self::Deposit(_) => Some(0x7E),
}
}
/// Max cost of the transaction
- pub fn max_cost(&self) -> U256 {
- self.gas_limit().saturating_mul(self.gas_price())
+ /// It is the gas limit multiplied by the gas price,
+ /// and if the transaction is EIP-4844, the result of (total blob gas cost * max fee per blob
+ /// gas) is also added
+ pub fn max_cost(&self) -> u128 {
+ let mut max_cost = self.gas_limit().saturating_mul(self.gas_price());
+
+ if self.is_eip4844() {
+ max_cost = max_cost.saturating_add(
+ self.blob_gas().unwrap_or(0).mul(self.max_fee_per_blob_gas().unwrap_or(0)),
+ )
+ }
+
+ max_cost
+ }
+
+ pub fn blob_gas(&self) -> Option {
+ match self {
+ Self::EIP4844(tx) => Some(tx.tx().tx().blob_gas() as u128),
+ _ => None,
+ }
+ }
+
+ pub fn max_fee_per_blob_gas(&self) -> Option {
+ match self {
+ Self::EIP4844(tx) => Some(tx.tx().tx().max_fee_per_blob_gas),
+ _ => None,
+ }
}
/// Returns a helper type that contains commonly used values as fields
pub fn essentials(&self) -> TransactionEssentials {
match self {
- TypedTransaction::Legacy(t) => TransactionEssentials {
+ Self::Legacy(t) => TransactionEssentials {
kind: t.tx().to,
- input: t.input.clone(),
- nonce: U256::from(t.tx().nonce),
- gas_limit: U256::from(t.tx().gas_limit),
+ input: t.tx().input.clone(),
+ nonce: t.tx().nonce,
+ gas_limit: t.tx().gas_limit,
gas_price: Some(U256::from(t.tx().gas_price)),
max_fee_per_gas: None,
max_priority_fee_per_gas: None,
- value: t.value,
+ max_fee_per_blob_gas: None,
+ blob_versioned_hashes: None,
+ value: t.tx().value,
chain_id: t.tx().chain_id,
access_list: Default::default(),
},
- TypedTransaction::EIP2930(t) => TransactionEssentials {
+ Self::EIP2930(t) => TransactionEssentials {
kind: t.tx().to,
- input: t.input.clone(),
- nonce: U256::from(t.tx().nonce),
- gas_limit: U256::from(t.tx().gas_limit),
+ input: t.tx().input.clone(),
+ nonce: t.tx().nonce,
+ gas_limit: t.tx().gas_limit,
gas_price: Some(U256::from(t.tx().gas_price)),
max_fee_per_gas: None,
max_priority_fee_per_gas: None,
- value: t.value,
- chain_id: Some(t.chain_id),
- access_list: to_alloy_access_list(t.access_list.clone()),
+ max_fee_per_blob_gas: None,
+ blob_versioned_hashes: None,
+ value: t.tx().value,
+ chain_id: Some(t.tx().chain_id),
+ access_list: t.tx().access_list.clone(),
},
- TypedTransaction::EIP1559(t) => TransactionEssentials {
- kind: t.to,
- input: t.input.clone(),
- nonce: U256::from(t.nonce),
- gas_limit: U256::from(t.gas_limit),
+ Self::EIP1559(t) => TransactionEssentials {
+ kind: t.tx().to,
+ input: t.tx().input.clone(),
+ nonce: t.tx().nonce,
+ gas_limit: t.tx().gas_limit,
gas_price: None,
- max_fee_per_gas: Some(U256::from(t.max_fee_per_gas)),
- max_priority_fee_per_gas: Some(U256::from(t.max_priority_fee_per_gas)),
- value: t.value,
- chain_id: Some(t.chain_id),
- access_list: to_alloy_access_list(t.access_list.clone()),
+ max_fee_per_gas: Some(U256::from(t.tx().max_fee_per_gas)),
+ max_priority_fee_per_gas: Some(U256::from(t.tx().max_priority_fee_per_gas)),
+ max_fee_per_blob_gas: None,
+ blob_versioned_hashes: None,
+ value: t.tx().value,
+ chain_id: Some(t.tx().chain_id),
+ access_list: t.tx().access_list.clone(),
+ },
+ Self::EIP4844(t) => TransactionEssentials {
+ kind: TxKind::Call(t.tx().tx().to),
+ input: t.tx().tx().input.clone(),
+ nonce: t.tx().tx().nonce,
+ gas_limit: t.tx().tx().gas_limit,
+ gas_price: Some(U256::from(t.tx().tx().max_fee_per_blob_gas)),
+ max_fee_per_gas: Some(U256::from(t.tx().tx().max_fee_per_gas)),
+ max_priority_fee_per_gas: Some(U256::from(t.tx().tx().max_priority_fee_per_gas)),
+ max_fee_per_blob_gas: Some(U256::from(t.tx().tx().max_fee_per_blob_gas)),
+ blob_versioned_hashes: Some(t.tx().tx().blob_versioned_hashes.clone()),
+ value: t.tx().tx().value,
+ chain_id: Some(t.tx().tx().chain_id),
+ access_list: t.tx().tx().access_list.clone(),
},
- TypedTransaction::Deposit(t) => TransactionEssentials {
+ Self::Deposit(t) => TransactionEssentials {
kind: t.kind,
input: t.input.clone(),
nonce: t.nonce,
@@ -617,6 +762,8 @@ impl TypedTransaction {
gas_price: Some(U256::from(0)),
max_fee_per_gas: None,
max_priority_fee_per_gas: None,
+ max_fee_per_blob_gas: None,
+ blob_versioned_hashes: None,
value: t.value,
chain_id: t.chain_id(),
access_list: Default::default(),
@@ -624,39 +771,51 @@ impl TypedTransaction {
}
}
- pub fn nonce(&self) -> U256 {
+ pub fn nonce(&self) -> u64 {
match self {
- TypedTransaction::Legacy(t) => U256::from(t.nonce),
- TypedTransaction::EIP2930(t) => U256::from(t.nonce),
- TypedTransaction::EIP1559(t) => U256::from(t.nonce),
- TypedTransaction::Deposit(t) => U256::from(t.nonce),
+ Self::Legacy(t) => t.tx().nonce,
+ Self::EIP2930(t) => t.tx().nonce,
+ Self::EIP1559(t) => t.tx().nonce,
+ Self::EIP4844(t) => t.tx().tx().nonce,
+ Self::Deposit(t) => t.nonce,
}
}
pub fn chain_id(&self) -> Option {
match self {
- TypedTransaction::Legacy(t) => t.chain_id,
- TypedTransaction::EIP2930(t) => Some(t.chain_id),
- TypedTransaction::EIP1559(t) => Some(t.chain_id),
- TypedTransaction::Deposit(t) => t.chain_id(),
+ Self::Legacy(t) => t.tx().chain_id,
+ Self::EIP2930(t) => Some(t.tx().chain_id),
+ Self::EIP1559(t) => Some(t.tx().chain_id),
+ Self::EIP4844(t) => Some(t.tx().tx().chain_id),
+ Self::Deposit(t) => t.chain_id(),
}
}
pub fn as_legacy(&self) -> Option<&Signed> {
match self {
- TypedTransaction::Legacy(tx) => Some(tx),
+ Self::Legacy(tx) => Some(tx),
_ => None,
}
}
/// Returns true whether this tx is a legacy transaction
pub fn is_legacy(&self) -> bool {
- matches!(self, TypedTransaction::Legacy(_))
+ matches!(self, Self::Legacy(_))
}
/// Returns true whether this tx is a EIP1559 transaction
pub fn is_eip1559(&self) -> bool {
- matches!(self, TypedTransaction::EIP1559(_))
+ matches!(self, Self::EIP1559(_))
+ }
+
+ /// Returns true whether this tx is a EIP2930 transaction
+ pub fn is_eip2930(&self) -> bool {
+ matches!(self, Self::EIP2930(_))
+ }
+
+ /// Returns true whether this tx is a EIP4844 transaction
+ pub fn is_eip4844(&self) -> bool {
+ matches!(self, Self::EIP4844(_))
}
/// Returns the hash of the transaction.
@@ -665,10 +824,11 @@ impl TypedTransaction {
/// hash. This allows us to treat impersonated transactions as unique.
pub fn hash(&self) -> B256 {
match self {
- TypedTransaction::Legacy(t) => *t.hash(),
- TypedTransaction::EIP2930(t) => *t.hash(),
- TypedTransaction::EIP1559(t) => *t.hash(),
- TypedTransaction::Deposit(t) => t.hash(),
+ Self::Legacy(t) => *t.hash(),
+ Self::EIP2930(t) => *t.hash(),
+ Self::EIP1559(t) => *t.hash(),
+ Self::EIP4844(t) => *t.hash(),
+ Self::Deposit(t) => t.hash(),
}
}
@@ -692,35 +852,38 @@ impl TypedTransaction {
/// Recovers the Ethereum address which was used to sign the transaction.
pub fn recover(&self) -> Result {
match self {
- TypedTransaction::Legacy(tx) => tx.recover_signer(),
- TypedTransaction::EIP2930(tx) => tx.recover_signer(),
- TypedTransaction::EIP1559(tx) => tx.recover_signer(),
- TypedTransaction::Deposit(tx) => tx.recover(),
+ Self::Legacy(tx) => tx.recover_signer(),
+ Self::EIP2930(tx) => tx.recover_signer(),
+ Self::EIP1559(tx) => tx.recover_signer(),
+ Self::EIP4844(tx) => tx.recover_signer(),
+ Self::Deposit(tx) => tx.recover(),
}
}
/// Returns what kind of transaction this is
- pub fn kind(&self) -> &TxKind {
+ pub fn kind(&self) -> TxKind {
match self {
- TypedTransaction::Legacy(tx) => &tx.to,
- TypedTransaction::EIP2930(tx) => &tx.to,
- TypedTransaction::EIP1559(tx) => &tx.to,
- TypedTransaction::Deposit(tx) => &tx.kind,
+ Self::Legacy(tx) => tx.tx().to,
+ Self::EIP2930(tx) => tx.tx().to,
+ Self::EIP1559(tx) => tx.tx().to,
+ Self::EIP4844(tx) => TxKind::Call(tx.tx().tx().to),
+ Self::Deposit(tx) => tx.kind,
}
}
/// Returns the callee if this transaction is a call
pub fn to(&self) -> Option {
- self.kind().to()
+ self.kind().to().copied()
}
/// Returns the Signature of the transaction
pub fn signature(&self) -> Signature {
match self {
- TypedTransaction::Legacy(tx) => *tx.signature(),
- TypedTransaction::EIP2930(tx) => *tx.signature(),
- TypedTransaction::EIP1559(tx) => *tx.signature(),
- TypedTransaction::Deposit(_) => Signature::from_scalars_and_parity(
+ Self::Legacy(tx) => *tx.signature(),
+ Self::EIP2930(tx) => *tx.signature(),
+ Self::EIP1559(tx) => *tx.signature(),
+ Self::EIP4844(tx) => *tx.signature(),
+ Self::Deposit(_) => Signature::from_scalars_and_parity(
B256::with_last_byte(1),
B256::with_last_byte(1),
false,
@@ -733,73 +896,116 @@ impl TypedTransaction {
impl Encodable for TypedTransaction {
fn encode(&self, out: &mut dyn bytes::BufMut) {
match self {
- TypedTransaction::Legacy(tx) => tx.encode(out),
- TypedTransaction::EIP2930(tx) => tx.encode(out),
- TypedTransaction::EIP1559(tx) => tx.encode(out),
- TypedTransaction::Deposit(tx) => tx.encode(out),
+ Self::Legacy(tx) => TxEnvelope::from(tx.clone()).encode(out),
+ Self::EIP2930(tx) => TxEnvelope::from(tx.clone()).encode(out),
+ Self::EIP1559(tx) => TxEnvelope::from(tx.clone()).encode(out),
+ Self::EIP4844(tx) => TxEnvelope::from(tx.clone()).encode(out),
+ Self::Deposit(tx) => {
+ let tx_payload_len = tx.fields_len();
+ let tx_header_len = Header { list: false, payload_length: tx_payload_len }.length();
+ Header { list: false, payload_length: 1 + tx_payload_len + tx_header_len }
+ .encode(out);
+ out.put_u8(0x7E);
+ tx.encode(out);
+ }
}
}
}
impl Decodable for TypedTransaction {
fn decode(buf: &mut &[u8]) -> alloy_rlp::Result {
- use bytes::Buf;
- use std::cmp::Ordering;
+ let mut h_decode_copy = *buf;
+ let header = alloy_rlp::Header::decode(&mut h_decode_copy)?;
- let first = *buf.first().ok_or(alloy_rlp::Error::Custom("empty slice"))?;
+ // Legacy TX
+ if header.list {
+ return Ok(TxEnvelope::decode(buf)?.into())
+ }
- // a signed transaction is either encoded as a string (non legacy) or a list (legacy).
- // We should not consume the buffer if we are decoding a legacy transaction, so let's
- // check if the first byte is between 0x80 and 0xbf.
- match first.cmp(&alloy_rlp::EMPTY_LIST_CODE) {
- Ordering::Less => {
- // strip out the string header
- // NOTE: typed transaction encodings either contain a "rlp header" which contains
- // the type of the payload and its length, or they do not contain a header and
- // start with the tx type byte.
- //
- // This line works for both types of encodings because byte slices starting with
- // 0x01 and 0x02 return a Header { list: false, payload_length: 1 } when input to
- // Header::decode.
- // If the encoding includes a header, the header will be properly decoded and
- // consumed.
- // Otherwise, header decoding will succeed but nothing is consumed.
- let _header = alloy_rlp::Header::decode(buf)?;
- let tx_type = *buf.first().ok_or(alloy_rlp::Error::Custom(
- "typed tx cannot be decoded from an empty slice",
- ))?;
- if tx_type == 0x01 {
- buf.advance(1);
- as Decodable>::decode(buf).map(TypedTransaction::EIP2930)
- } else if tx_type == 0x02 {
- buf.advance(1);
- as Decodable>::decode(buf).map(TypedTransaction::EIP1559)
- } else if tx_type == 0x7E {
- buf.advance(1);
- ::decode(buf).map(TypedTransaction::Deposit)
- } else {
- Err(alloy_rlp::Error::Custom("invalid tx type"))
- }
- }
- Ordering::Equal => {
- Err(alloy_rlp::Error::Custom("an empty list is not a valid transaction encoding"))
- }
- Ordering::Greater => {
- as Decodable>::decode(buf).map(TypedTransaction::Legacy)
+ // Check byte after header
+ let ty = *h_decode_copy.first().ok_or(alloy_rlp::Error::Custom("empty slice"))?;
+
+ if ty != 0x7E {
+ Ok(TxEnvelope::decode(buf)?.into())
+ } else {
+ Ok(Self::Deposit(DepositTransaction::decode(&mut h_decode_copy)?))
+ }
+ }
+}
+
+impl Encodable2718 for TypedTransaction {
+ fn type_flag(&self) -> Option {
+ self.r#type()
+ }
+
+ fn encode_2718_len(&self) -> usize {
+ match self {
+ Self::Legacy(tx) => TxEnvelope::from(tx.clone()).encode_2718_len(),
+ Self::EIP2930(tx) => TxEnvelope::from(tx.clone()).encode_2718_len(),
+ Self::EIP1559(tx) => TxEnvelope::from(tx.clone()).encode_2718_len(),
+ Self::EIP4844(tx) => TxEnvelope::from(tx.clone()).encode_2718_len(),
+ Self::Deposit(tx) => 1 + tx.length(),
+ }
+ }
+
+ fn encode_2718(&self, out: &mut dyn BufMut) {
+ match self {
+ Self::Legacy(tx) => TxEnvelope::from(tx.clone()).encode_2718(out),
+ Self::EIP2930(tx) => TxEnvelope::from(tx.clone()).encode_2718(out),
+ Self::EIP1559(tx) => TxEnvelope::from(tx.clone()).encode_2718(out),
+ Self::EIP4844(tx) => TxEnvelope::from(tx.clone()).encode_2718(out),
+ Self::Deposit(tx) => {
+ out.put_u8(0x7E);
+ tx.encode(out);
}
}
}
}
+impl Decodable2718 for TypedTransaction {
+ fn typed_decode(ty: u8, buf: &mut &[u8]) -> Result {
+ if ty == 0x7E {
+ return Ok(Self::Deposit(DepositTransaction::decode(buf)?))
+ }
+ match TxEnvelope::typed_decode(ty, buf)? {
+ TxEnvelope::Eip2930(tx) => Ok(Self::EIP2930(tx)),
+ TxEnvelope::Eip1559(tx) => Ok(Self::EIP1559(tx)),
+ TxEnvelope::Eip4844(tx) => Ok(Self::EIP4844(tx)),
+ _ => unreachable!(),
+ }
+ }
+
+ fn fallback_decode(buf: &mut &[u8]) -> Result {
+ match TxEnvelope::fallback_decode(buf)? {
+ TxEnvelope::Legacy(tx) => Ok(Self::Legacy(tx)),
+ _ => unreachable!(),
+ }
+ }
+}
+
+impl From for TypedTransaction {
+ fn from(value: TxEnvelope) -> Self {
+ match value {
+ TxEnvelope::Legacy(tx) => Self::Legacy(tx),
+ TxEnvelope::Eip2930(tx) => Self::EIP2930(tx),
+ TxEnvelope::Eip1559(tx) => Self::EIP1559(tx),
+ TxEnvelope::Eip4844(tx) => Self::EIP4844(tx),
+ _ => unreachable!(),
+ }
+ }
+}
+
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TransactionEssentials {
pub kind: TxKind,
pub input: Bytes,
- pub nonce: U256,
- pub gas_limit: U256,
+ pub nonce: u64,
+ pub gas_limit: u128,
pub gas_price: Option,
pub max_fee_per_gas: Option,
pub max_priority_fee_per_gas: Option,
+ pub max_fee_per_blob_gas: Option,
+ pub blob_versioned_hashes: Option>,
pub value: U256,
pub chain_id: Option,
pub access_list: AccessList,
@@ -809,83 +1015,195 @@ pub struct TransactionEssentials {
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TransactionInfo {
pub transaction_hash: B256,
- pub transaction_index: u32,
+ pub transaction_index: u64,
pub from: Address,
pub to: Option,
pub contract_address: Option,
- pub logs: Vec,
- pub logs_bloom: Bloom,
pub traces: Vec,
pub exit: InstructionResult,
pub out: Option,
pub nonce: u64,
+ pub gas_used: u128,
}
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum TypedReceipt {
- Legacy(ReceiptWithBloom),
- EIP2930(ReceiptWithBloom),
- EIP1559(ReceiptWithBloom),
- Deposit(ReceiptWithBloom),
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct DepositReceipt {
+ #[serde(flatten)]
+ pub inner: ReceiptWithBloom,
+ #[serde(default, with = "alloy_serde::num::u64_opt_via_ruint")]
+ pub deposit_nonce: Option,
+ #[serde(default, with = "alloy_serde::num::u64_opt_via_ruint")]
+ pub deposit_receipt_version: Option,
}
-impl TypedReceipt {
- pub fn gas_used(&self) -> U256 {
- match self {
- TypedReceipt::Legacy(r) |
- TypedReceipt::EIP1559(r) |
- TypedReceipt::EIP2930(r) |
- TypedReceipt::Deposit(r) => U256::from(r.receipt.cumulative_gas_used),
+impl DepositReceipt {
+ fn payload_len(&self) -> usize {
+ self.inner.receipt.status.length() +
+ self.inner.receipt.cumulative_gas_used.length() +
+ self.inner.logs_bloom.length() +
+ self.inner.receipt.logs.length() +
+ self.deposit_nonce.map_or(0, |n| n.length()) +
+ self.deposit_receipt_version.map_or(0, |n| n.length())
+ }
+
+ /// Returns the rlp header for the receipt payload.
+ fn receipt_rlp_header(&self) -> alloy_rlp::Header {
+ alloy_rlp::Header { list: true, payload_length: self.payload_len() }
+ }
+
+ /// Encodes the receipt data.
+ fn encode_fields(&self, out: &mut dyn BufMut) {
+ self.receipt_rlp_header().encode(out);
+ self.inner.receipt.status.encode(out);
+ self.inner.receipt.cumulative_gas_used.encode(out);
+ self.inner.logs_bloom.encode(out);
+ self.inner.receipt.logs.encode(out);
+ if let Some(n) = self.deposit_nonce {
+ n.encode(out);
+ }
+ if let Some(n) = self.deposit_receipt_version {
+ n.encode(out);
}
}
- pub fn logs_bloom(&self) -> &Bloom {
+ /// Decodes the receipt payload
+ fn decode_receipt(buf: &mut &[u8]) -> alloy_rlp::Result {
+ let b: &mut &[u8] = &mut &**buf;
+ let rlp_head = alloy_rlp::Header::decode(b)?;
+ if !rlp_head.list {
+ return Err(alloy_rlp::Error::UnexpectedString);
+ }
+ let started_len = b.len();
+ let remaining = |b: &[u8]| rlp_head.payload_length - (started_len - b.len()) > 0;
+
+ let status = Decodable::decode(b)?;
+ let cumulative_gas_used = Decodable::decode(b)?;
+ let logs_bloom = Decodable::decode(b)?;
+ let logs = Decodable::decode(b)?;
+ let deposit_nonce = remaining(b).then(|| alloy_rlp::Decodable::decode(b)).transpose()?;
+ let deposit_nonce_version =
+ remaining(b).then(|| alloy_rlp::Decodable::decode(b)).transpose()?;
+
+ let this = Self {
+ inner: ReceiptWithBloom {
+ receipt: Receipt { status, cumulative_gas_used, logs },
+ logs_bloom,
+ },
+ deposit_nonce,
+ deposit_receipt_version: deposit_nonce_version,
+ };
+
+ let consumed = started_len - b.len();
+ if consumed != rlp_head.payload_length {
+ return Err(alloy_rlp::Error::ListLengthMismatch {
+ expected: rlp_head.payload_length,
+ got: consumed,
+ });
+ }
+
+ *buf = *b;
+ Ok(this)
+ }
+}
+
+impl alloy_rlp::Encodable for DepositReceipt {
+ fn encode(&self, out: &mut dyn BufMut) {
+ self.encode_fields(out);
+ }
+
+ fn length(&self) -> usize {
+ let payload_length = self.payload_len();
+ payload_length + length_of_length(payload_length)
+ }
+}
+
+impl alloy_rlp::Decodable for DepositReceipt {
+ fn decode(buf: &mut &[u8]) -> alloy_rlp::Result {
+ Self::decode_receipt(buf)
+ }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum TypedReceipt {
+ #[serde(rename = "0x0", alias = "0x00")]
+ Legacy(ReceiptWithBloom),
+ #[serde(rename = "0x1", alias = "0x01")]
+ EIP2930(ReceiptWithBloom),
+ #[serde(rename = "0x2", alias = "0x02")]
+ EIP1559(ReceiptWithBloom),
+ #[serde(rename = "0x3", alias = "0x03")]
+ EIP4844(ReceiptWithBloom),
+ #[serde(rename = "0x7E", alias = "0x7e")]
+ Deposit(DepositReceipt),
+}
+
+impl TypedReceipt {
+ pub fn as_receipt_with_bloom(&self) -> &ReceiptWithBloom {
match self {
- TypedReceipt::Legacy(r) |
- TypedReceipt::EIP1559(r) |
- TypedReceipt::EIP2930(r) |
- TypedReceipt::Deposit(r) => &r.bloom,
+ Self::Legacy(r) | Self::EIP1559(r) | Self::EIP2930(r) | Self::EIP4844(r) => r,
+ Self::Deposit(r) => &r.inner,
}
}
}
-impl From for ReceiptWithBloom {
- fn from(val: TypedReceipt) -> Self {
- match val {
- TypedReceipt::Legacy(r) |
- TypedReceipt::EIP1559(r) |
- TypedReceipt::EIP2930(r) |
- TypedReceipt::Deposit(r) => r,
+impl TypedReceipt {
+ pub fn cumulative_gas_used(&self) -> u128 {
+ self.as_receipt_with_bloom().cumulative_gas_used()
+ }
+
+ pub fn logs_bloom(&self) -> &Bloom {
+ &self.as_receipt_with_bloom().logs_bloom
+ }
+
+ pub fn logs(&self) -> &[Log] {
+ self.as_receipt_with_bloom().logs()
+ }
+}
+
+impl From> for TypedReceipt {
+ fn from(value: ReceiptEnvelope) -> Self {
+ match value {
+ ReceiptEnvelope::Legacy(r) => Self::Legacy(r),
+ ReceiptEnvelope::Eip2930(r) => Self::EIP2930(r),
+ ReceiptEnvelope::Eip1559(r) => Self::EIP1559(r),
+ ReceiptEnvelope::Eip4844(r) => Self::EIP4844(r),
+ _ => unreachable!(),
}
}
}
impl Encodable for TypedReceipt {
fn encode(&self, out: &mut dyn bytes::BufMut) {
- use alloy_rlp::Header;
-
match self {
- TypedReceipt::Legacy(r) => r.encode(out),
+ Self::Legacy(r) => r.encode(out),
receipt => {
let payload_len = match receipt {
- TypedReceipt::EIP2930(r) => r.length() + 1,
- TypedReceipt::EIP1559(r) => r.length() + 1,
- TypedReceipt::Deposit(r) => r.length() + 1,
+ Self::EIP2930(r) => r.length() + 1,
+ Self::EIP1559(r) => r.length() + 1,
+ Self::EIP4844(r) => r.length() + 1,
+ Self::Deposit(r) => r.length() + 1,
_ => unreachable!("receipt already matched"),
};
match receipt {
- TypedReceipt::EIP2930(r) => {
+ Self::EIP2930(r) => {
Header { list: true, payload_length: payload_len }.encode(out);
1u8.encode(out);
r.encode(out);
}
- TypedReceipt::EIP1559(r) => {
+ Self::EIP1559(r) => {
Header { list: true, payload_length: payload_len }.encode(out);
2u8.encode(out);
r.encode(out);
}
- TypedReceipt::Deposit(r) => {
+ Self::EIP4844(r) => {
+ Header { list: true, payload_length: payload_len }.encode(out);
+ 3u8.encode(out);
+ r.encode(out);
+ }
+ Self::Deposit(r) => {
Header { list: true, payload_length: payload_len }.encode(out);
0x7Eu8.encode(out);
r.encode(out);
@@ -899,7 +1217,6 @@ impl Encodable for TypedReceipt {
impl Decodable for TypedReceipt {
fn decode(buf: &mut &[u8]) -> alloy_rlp::Result {
- use alloy_rlp::Header;
use bytes::Buf;
use std::cmp::Ordering;
@@ -923,9 +1240,12 @@ impl Decodable for TypedReceipt {
} else if receipt_type == 0x02 {
buf.advance(1);
::decode(buf).map(TypedReceipt::EIP1559)
+ } else if receipt_type == 0x03 {
+ buf.advance(1);
+ ::decode(buf).map(TypedReceipt::EIP4844)
} else if receipt_type == 0x7E {
buf.advance(1);
- ::decode(buf).map(TypedReceipt::Deposit)
+ ::decode(buf).map(TypedReceipt::Deposit)
} else {
Err(alloy_rlp::Error::Custom("invalid receipt type"))
}
@@ -940,41 +1260,123 @@ impl Decodable for TypedReceipt {
}
}
-/// Translates an EIP-2930 access list to an alloy-rpc-types access list.
-pub fn to_alloy_access_list(
- access_list: alloy_eips::eip2930::AccessList,
-) -> alloy_rpc_types::AccessList {
- alloy_rpc_types::AccessList(
- access_list
- .0
- .into_iter()
- .map(|item| alloy_rpc_types::AccessListItem {
- address: item.address,
- storage_keys: item.storage_keys,
- })
- .collect(),
- )
+impl Encodable2718 for TypedReceipt {
+ fn type_flag(&self) -> Option {
+ match self {
+ Self::Legacy(_) => None,
+ Self::EIP2930(_) => Some(1),
+ Self::EIP1559(_) => Some(2),
+ Self::EIP4844(_) => Some(3),
+ Self::Deposit(_) => Some(0x7E),
+ }
+ }
+
+ fn encode_2718_len(&self) -> usize {
+ match self {
+ Self::Legacy(r) => ReceiptEnvelope::Legacy(r.clone()).encode_2718_len(),
+ Self::EIP2930(r) => ReceiptEnvelope::Eip2930(r.clone()).encode_2718_len(),
+ Self::EIP1559(r) => ReceiptEnvelope::Eip1559(r.clone()).encode_2718_len(),
+ Self::EIP4844(r) => ReceiptEnvelope::Eip4844(r.clone()).encode_2718_len(),
+ Self::Deposit(r) => 1 + r.length(),
+ }
+ }
+
+ fn encode_2718(&self, out: &mut dyn BufMut) {
+ match self {
+ Self::Legacy(r) => ReceiptEnvelope::Legacy(r.clone()).encode_2718(out),
+ Self::EIP2930(r) => ReceiptEnvelope::Eip2930(r.clone()).encode_2718(out),
+ Self::EIP1559(r) => ReceiptEnvelope::Eip1559(r.clone()).encode_2718(out),
+ Self::EIP4844(r) => ReceiptEnvelope::Eip4844(r.clone()).encode_2718(out),
+ Self::Deposit(r) => {
+ out.put_u8(0x7E);
+ r.encode(out);
+ }
+ }
+ }
+}
+
+impl Decodable2718 for TypedReceipt {
+ fn typed_decode(ty: u8, buf: &mut &[u8]) -> Result {
+ if ty == 0x7E {
+ return Ok(Self::Deposit(DepositReceipt::decode(buf)?))
+ }
+ match ReceiptEnvelope::typed_decode(ty, buf)? {
+ ReceiptEnvelope::Eip2930(tx) => Ok(Self::EIP2930(tx)),
+ ReceiptEnvelope::Eip1559(tx) => Ok(Self::EIP1559(tx)),
+ ReceiptEnvelope::Eip4844(tx) => Ok(Self::EIP4844(tx)),
+ _ => unreachable!(),
+ }
+ }
+
+ fn fallback_decode(buf: &mut &[u8]) -> Result {
+ match ReceiptEnvelope::fallback_decode(buf)? {
+ ReceiptEnvelope::Legacy(tx) => Ok(Self::Legacy(tx)),
+ _ => unreachable!(),
+ }
+ }
}
-/// Translates an alloy-rpc-types access list to an EIP-2930 access list.
-pub fn to_eip_access_list(
- access_list: alloy_rpc_types::AccessList,
-) -> alloy_eips::eip2930::AccessList {
- alloy_eips::eip2930::AccessList(
- access_list
- .0
- .into_iter()
- .map(|item| alloy_eips::eip2930::AccessListItem {
- address: item.address,
- storage_keys: item.storage_keys,
- })
- .collect(),
- )
+pub type ReceiptResponse = TransactionReceipt>;
+
+pub fn convert_to_anvil_receipt(receipt: AnyTransactionReceipt) -> Option {
+ let WithOtherFields {
+ inner:
+ TransactionReceipt {
+ transaction_hash,
+ transaction_index,
+ block_hash,
+ block_number,
+ gas_used,
+ contract_address,
+ effective_gas_price,
+ from,
+ to,
+ blob_gas_price,
+ blob_gas_used,
+ state_root,
+ inner: AnyReceiptEnvelope { inner: receipt_with_bloom, r#type },
+ },
+ other,
+ } = receipt;
+
+ Some(TransactionReceipt {
+ transaction_hash,
+ transaction_index,
+ block_hash,
+ block_number,
+ gas_used,
+ contract_address,
+ effective_gas_price,
+ from,
+ to,
+ blob_gas_price,
+ blob_gas_used,
+ state_root,
+ inner: match r#type {
+ 0x00 => TypedReceipt::Legacy(receipt_with_bloom),
+ 0x01 => TypedReceipt::EIP2930(receipt_with_bloom),
+ 0x02 => TypedReceipt::EIP1559(receipt_with_bloom),
+ 0x03 => TypedReceipt::EIP4844(receipt_with_bloom),
+ 0x7E => TypedReceipt::Deposit(DepositReceipt {
+ inner: receipt_with_bloom,
+ deposit_nonce: other
+ .get_deserialized::("depositNonce")
+ .transpose()
+ .ok()?
+ .map(|v| v.to()),
+ deposit_receipt_version: other
+ .get_deserialized::("depositReceiptVersion")
+ .transpose()
+ .ok()?
+ .map(|v| v.to()),
+ }),
+ _ => return None,
+ },
+ })
}
#[cfg(test)]
mod tests {
- use alloy_consensus::Receipt;
use alloy_primitives::{b256, hex, LogData};
use std::str::FromStr;
@@ -987,8 +1389,8 @@ mod tests {
let tx = TxLegacy {
nonce: 2u64,
- gas_price: 1000000000u64.into(),
- gas_limit: 100000u64,
+ gas_price: 1000000000u128,
+ gas_limit: 100000u128,
to: TxKind::Call(Address::from_slice(
&hex::decode("d3e8763675e4c425df46cc3b5c0f6cbdac396046").unwrap()[..],
)),
@@ -1038,6 +1440,39 @@ mod tests {
);
}
+ // Test vector from https://sepolia.etherscan.io/tx/0x9a22ccb0029bc8b0ddd073be1a1d923b7ae2b2ea52100bae0db4424f9107e9c0
+ // Blobscan: https://sepolia.blobscan.com/tx/0x9a22ccb0029bc8b0ddd073be1a1d923b7ae2b2ea52100bae0db4424f9107e9c0
+ #[test]
+ fn test_decode_live_4844_tx() {
+ use alloy_primitives::{address, b256};
+
+ // https://sepolia.etherscan.io/getRawTx?tx=0x9a22ccb0029bc8b0ddd073be1a1d923b7ae2b2ea52100bae0db4424f9107e9c0
+ let raw_tx = alloy_primitives::hex::decode("0x03f9011d83aa36a7820fa28477359400852e90edd0008252089411e9ca82a3a762b4b5bd264d4173a242e7a770648080c08504a817c800f8a5a0012ec3d6f66766bedb002a190126b3549fce0047de0d4c25cffce0dc1c57921aa00152d8e24762ff22b1cfd9f8c0683786a7ca63ba49973818b3d1e9512cd2cec4a0013b98c6c83e066d5b14af2b85199e3d4fc7d1e778dd53130d180f5077e2d1c7a001148b495d6e859114e670ca54fb6e2657f0cbae5b08063605093a4b3dc9f8f1a0011ac212f13c5dff2b2c6b600a79635103d6f580a4221079951181b25c7e654901a0c8de4cced43169f9aa3d36506363b2d2c44f6c49fc1fd91ea114c86f3757077ea01e11fdd0d1934eda0492606ee0bb80a7bf8f35cc5f86ec60fe5031ba48bfd544").unwrap();
+ let res = TypedTransaction::decode(&mut raw_tx.as_slice()).unwrap();
+ assert_eq!(res.r#type(), Some(3));
+
+ let tx = match res {
+ TypedTransaction::EIP4844(tx) => tx,
+ _ => unreachable!(),
+ };
+
+ assert_eq!(tx.tx().tx().to, address!("11E9CA82A3a762b4B5bd264d4173a242e7a77064"));
+
+ assert_eq!(
+ tx.tx().tx().blob_versioned_hashes,
+ vec![
+ b256!("012ec3d6f66766bedb002a190126b3549fce0047de0d4c25cffce0dc1c57921a"),
+ b256!("0152d8e24762ff22b1cfd9f8c0683786a7ca63ba49973818b3d1e9512cd2cec4"),
+ b256!("013b98c6c83e066d5b14af2b85199e3d4fc7d1e778dd53130d180f5077e2d1c7"),
+ b256!("01148b495d6e859114e670ca54fb6e2657f0cbae5b08063605093a4b3dc9f8f1"),
+ b256!("011ac212f13c5dff2b2c6b600a79635103d6f580a4221079951181b25c7e6549")
+ ]
+ );
+
+ let from = tx.recover_signer().unwrap();
+ assert_eq!(from, address!("A83C816D4f9b2783761a22BA6FADB0eB0606D7B2"));
+ }
+
#[test]
fn can_recover_sender_not_normalized() {
let bytes = hex::decode("f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap();
@@ -1046,11 +1481,11 @@ mod tests {
panic!("decoding TypedTransaction failed");
};
- assert_eq!(tx.input, Bytes::from(b""));
- assert_eq!(tx.gas_price, 1);
- assert_eq!(tx.gas_limit, 21000);
- assert_eq!(tx.nonce, 0);
- if let TxKind::Call(to) = tx.to {
+ assert_eq!(tx.tx().input, Bytes::from(b""));
+ assert_eq!(tx.tx().gas_price, 1);
+ assert_eq!(tx.tx().gas_limit, 21000);
+ assert_eq!(tx.tx().nonce, 0);
+ if let TxKind::Call(to) = tx.tx().to {
assert_eq!(
to,
"0x095e7baea6a6c7c4c2dfeb977efac326af552d87".parse::().unwrap()
@@ -1058,7 +1493,7 @@ mod tests {
} else {
panic!("expected a call transaction");
}
- assert_eq!(tx.value, U256::from(0x0au64));
+ assert_eq!(tx.tx().value, U256::from(0x0au64));
assert_eq!(
tx.recover_signer().unwrap(),
"0f65fe9276bc9a24ae7083ae28e2660ef72df99e".parse::().unwrap()
@@ -1072,8 +1507,8 @@ mod tests {
let mut data = vec![];
let receipt = TypedReceipt::Legacy(ReceiptWithBloom {
receipt: Receipt {
- success: false,
- cumulative_gas_used: 0x1u64,
+ status: false.into(),
+ cumulative_gas_used: 0x1u128,
logs: vec![Log {
address: Address::from_str("0000000000000000000000000000000000000011").unwrap(),
data: LogData::new_unchecked(
@@ -1091,7 +1526,7 @@ mod tests {
),
}],
},
- bloom: [0; 256].into(),
+ logs_bloom: [0; 256].into(),
});
receipt.encode(&mut data);
@@ -1107,8 +1542,8 @@ mod tests {
let expected = TypedReceipt::Legacy(ReceiptWithBloom {
receipt: Receipt {
- success: false,
- cumulative_gas_used: 0x1u64,
+ status: false.into(),
+ cumulative_gas_used: 0x1u128,
logs: vec![Log {
address: Address::from_str("0000000000000000000000000000000000000011").unwrap(),
data: LogData::new_unchecked(
@@ -1126,7 +1561,7 @@ mod tests {
),
}],
},
- bloom: [0; 256].into(),
+ logs_bloom: [0; 256].into(),
});
let receipt = TypedReceipt::decode(&mut &data[..]).unwrap();
diff --git a/crates/anvil/core/src/eth/transaction/optimism.rs b/crates/anvil/core/src/eth/transaction/optimism.rs
index 86edc810a..4a147297b 100644
--- a/crates/anvil/core/src/eth/transaction/optimism.rs
+++ b/crates/anvil/core/src/eth/transaction/optimism.rs
@@ -1,9 +1,9 @@
-use alloy_consensus::TxType;
-use alloy_network::{Transaction, TxKind};
-use alloy_primitives::{Address, Bytes, ChainId, Signature, B256, U256};
+use alloy_consensus::{SignableTransaction, Signed, Transaction, TxType};
+use alloy_primitives::{keccak256, Address, Bytes, ChainId, Signature, TxKind, B256, U256};
use alloy_rlp::{
length_of_length, Decodable, Encodable, Error as DecodeError, Header as RlpHeader,
};
+use serde::{Deserialize, Serialize};
use std::mem;
#[derive(Clone, Debug, PartialEq, Eq)]
@@ -13,7 +13,7 @@ pub struct DepositTransactionRequest {
pub kind: TxKind,
pub mint: U256,
pub value: U256,
- pub gas_limit: U256,
+ pub gas_limit: u128,
pub is_system_tx: bool,
pub input: Bytes,
}
@@ -134,108 +134,74 @@ impl DepositTransactionRequest {
1 + length_of_length(payload_length) + payload_length
}
- /// Outputs the signature hash of the transaction by first encoding without a signature, then
- /// hashing.
- pub(crate) fn signature_hash(&self) -> B256 {
- let mut buf = Vec::with_capacity(self.payload_len_for_signature());
- self.encode_for_signing(&mut buf);
- alloy_primitives::utils::keccak256(&buf)
+ fn encoded_len_with_signature(&self, signature: &Signature) -> usize {
+ // this counts the tx fields and signature fields
+ let payload_length = self.fields_len() + signature.rlp_vrs_len();
+
+ // this counts:
+ // * tx type byte
+ // * inner header length
+ // * inner payload length
+ 1 + alloy_rlp::Header { list: true, payload_length }.length() + payload_length
}
}
impl Transaction for DepositTransactionRequest {
- type Signature = Signature;
-
- fn chain_id(&self) -> Option {
- None
- }
-
- fn gas_limit(&self) -> u64 {
- self.gas_limit.to::()
- }
-
- fn nonce(&self) -> u64 {
- u64::MAX
+ fn input(&self) -> &[u8] {
+ &self.input
}
- fn decode_signed(buf: &mut &[u8]) -> alloy_rlp::Result>
- where
- Self: Sized,
- {
- let header = alloy_rlp::Header::decode(buf)?;
- if !header.list {
- return Err(alloy_rlp::Error::UnexpectedString);
- }
-
- let tx = Self::decode_inner(buf)?;
- let signature = Signature::decode_rlp_vrs(buf)?;
-
- Ok(tx.into_signed(signature))
+ /// Get `to`.
+ fn to(&self) -> TxKind {
+ self.kind
}
- fn encode_signed(&self, signature: &Signature, out: &mut dyn bytes::BufMut) {
- self.encode_with_signature(signature, out)
+ /// Get `value`.
+ fn value(&self) -> U256 {
+ self.value
}
- fn gas_price(&self) -> Option {
+ /// Get `chain_id`.
+ fn chain_id(&self) -> Option {
None
}
- fn input(&self) -> &[u8] {
- &self.input
+ /// Get `nonce`.
+ fn nonce(&self) -> u64 {
+ u64::MAX
}
- fn input_mut(&mut self) -> &mut Bytes {
- &mut self.input
+ /// Get `gas_limit`.
+ fn gas_limit(&self) -> u128 {
+ self.gas_limit
}
- fn into_signed(self, signature: Signature) -> alloy_network::Signed
- where
- Self: Sized,
- {
- alloy_network::Signed::new_unchecked(self.clone(), signature, self.signature_hash())
+ /// Get `gas_price`.
+ fn gas_price(&self) -> Option {
+ None
}
+}
+impl SignableTransaction for DepositTransactionRequest {
fn set_chain_id(&mut self, _chain_id: ChainId) {}
- fn set_gas_limit(&mut self, limit: u64) {
- self.gas_limit = U256::from(limit);
- }
-
- fn set_gas_price(&mut self, _price: U256) {}
-
- fn set_input(&mut self, data: Bytes) {
- self.input = data;
- }
-
- fn set_nonce(&mut self, _nonce: u64) {}
-
- fn set_to(&mut self, to: TxKind) {
- self.kind = to;
- }
-
- fn set_value(&mut self, value: U256) {
- self.value = value;
- }
-
- fn signature_hash(&self) -> B256 {
- self.signature_hash()
+ fn payload_len_for_signature(&self) -> usize {
+ self.payload_len_for_signature()
}
- fn to(&self) -> TxKind {
- self.kind
- }
+ fn into_signed(self, signature: Signature) -> Signed {
+ let mut buf = Vec::with_capacity(self.encoded_len_with_signature(&signature));
+ self.encode_with_signature(&signature, &mut buf);
+ let hash = keccak256(&buf);
- fn value(&self) -> U256 {
- self.value
+ // Drop any v chain id value to ensure the signature format is correct at the time of
+ // combination for an EIP-4844 transaction. V should indicate the y-parity of the
+ // signature.
+ Signed::new_unchecked(self, signature.with_parity_bool(), hash)
}
fn encode_for_signing(&self, out: &mut dyn alloy_rlp::BufMut) {
- self.encode_for_signing(out)
- }
-
- fn payload_len_for_signature(&self) -> usize {
- self.payload_len_for_signature()
+ self.encode_for_signing(out);
}
}
@@ -263,21 +229,21 @@ impl Encodable for DepositTransactionRequest {
/// An op-stack deposit transaction.
/// See
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct DepositTransaction {
- pub nonce: U256,
+ pub nonce: u64,
pub source_hash: B256,
pub from: Address,
pub kind: TxKind,
pub mint: U256,
pub value: U256,
- pub gas_limit: U256,
+ pub gas_limit: u128,
pub is_system_tx: bool,
pub input: Bytes,
}
impl DepositTransaction {
- pub fn nonce(&self) -> &U256 {
+ pub fn nonce(&self) -> &u64 {
&self.nonce
}
@@ -321,7 +287,7 @@ impl DepositTransaction {
len
}
- /// Decodes the inner [TxDeposit] fields from RLP bytes.
+ /// Decodes the inner fields from RLP bytes
///
/// NOTE: This assumes a RLP header has already been decoded, and _just_ decodes the following
/// RLP fields in the following order:
@@ -336,7 +302,7 @@ impl DepositTransaction {
/// - `input`
pub fn decode_inner(buf: &mut &[u8]) -> Result {
Ok(Self {
- nonce: U256::ZERO,
+ nonce: 0,
source_hash: Decodable::decode(buf)?,
from: Decodable::decode(buf)?,
kind: Decodable::decode(buf)?,
diff --git a/crates/anvil/core/src/eth/trie.rs b/crates/anvil/core/src/eth/trie.rs
index 5d144a5db..59c5cd910 100644
--- a/crates/anvil/core/src/eth/trie.rs
+++ b/crates/anvil/core/src/eth/trie.rs
@@ -1,36 +1,12 @@
-//! Utility functions for Ethereum adapted from https://github.dev/rust-blockchain/ethereum/blob/755dffaa4903fbec1269f50cde9863cf86269a14/src/util.rs
-use alloy_primitives::B256;
+//! Utility functions for Ethereum adapted from
-pub use keccak_hasher::KeccakHasher;
-
-// reexport some trie types
-pub use reference_trie::*;
+use alloy_primitives::{fixed_bytes, B256};
+use alloy_trie::{HashBuilder, Nibbles};
+use std::collections::BTreeMap;
/// The KECCAK of the RLP encoding of empty data.
-pub const KECCAK_NULL_RLP: B256 = B256::new([
- 0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e,
- 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x01, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21,
-]);
-
-/// Generates a trie root hash for a vector of key-value tuples
-pub fn trie_root(input: I) -> B256
-where
- I: IntoIterator
- ,
- K: AsRef<[u8]> + Ord,
- V: AsRef<[u8]>,
-{
- B256::from(triehash::trie_root::(input))
-}
-
-/// Generates a key-hashed (secure) trie root hash for a vector of key-value tuples.
-pub fn sec_trie_root(input: I) -> B256
-where
- I: IntoIterator
- ,
- K: AsRef<[u8]>,
- V: AsRef<[u8]>,
-{
- B256::from(triehash::sec_trie_root::(input))
-}
+pub const KECCAK_NULL_RLP: B256 =
+ fixed_bytes!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421");
/// Generates a trie root hash for a vector of values
pub fn ordered_trie_root(input: I) -> B256
@@ -38,5 +14,17 @@ where
I: IntoIterator
- ,
V: AsRef<[u8]>,
{
- B256::from(triehash::ordered_trie_root::(input))
+ let mut builder = HashBuilder::default();
+
+ let input = input
+ .into_iter()
+ .enumerate()
+ .map(|(i, v)| (alloy_rlp::encode(i), v))
+ .collect::>();
+
+ for (key, value) in input {
+ builder.add_leaf(Nibbles::unpack(key), value.as_ref());
+ }
+
+ builder.root()
}
diff --git a/crates/anvil/core/src/eth/utils.rs b/crates/anvil/core/src/eth/utils.rs
index 27bb46523..a60439280 100644
--- a/crates/anvil/core/src/eth/utils.rs
+++ b/crates/anvil/core/src/eth/utils.rs
@@ -1,35 +1,4 @@
-use alloy_eips::eip2930::{
- AccessList as AlloyEipAccessList, AccessListItem as AlloyEipAccessListItem,
-};
-use alloy_primitives::{Address, Parity, U256};
-use alloy_rpc_types::{AccessList as AlloyAccessList, AccessListItem as AlloyAccessListItem};
-
-pub fn alloy_to_revm_access_list(list: Vec) -> Vec<(Address, Vec)> {
- list.into_iter()
- .map(|item| (item.address, item.storage_keys.into_iter().map(|k| k.into()).collect()))
- .collect()
-}
-
-/// Translates a vec of [AlloyEipAccessListItem] to a [AlloyAccessList], translating from internal
-/// type to rpc type.
-pub fn from_eip_to_alloy_access_list(list: AlloyEipAccessList) -> AlloyAccessList {
- AlloyAccessList(
- list.0
- .into_iter()
- .map(|item| AlloyAccessListItem {
- address: item.address,
- storage_keys: item.storage_keys.into_iter().collect(),
- })
- .collect(),
- )
-}
-
-/// Translates a vec of [AlloyEipAccessListItem] to a revm style Access List.
-pub fn eip_to_revm_access_list(list: Vec) -> Vec<(Address, Vec)> {
- list.into_iter()
- .map(|item| (item.address, item.storage_keys.into_iter().map(|k| k.into()).collect()))
- .collect()
-}
+use alloy_primitives::Parity;
/// See
/// > If you do, then the v of the signature MUST be set to {0,1} + CHAIN_ID * 2 + 35 where
diff --git a/crates/anvil/core/src/lib.rs b/crates/anvil/core/src/lib.rs
index a09e7cd68..5d51d4691 100644
--- a/crates/anvil/core/src/lib.rs
+++ b/crates/anvil/core/src/lib.rs
@@ -1,3 +1,10 @@
+//! # anvil-core
+//!
+//! Core Ethereum types for Anvil.
+
+#![cfg_attr(not(test), warn(unused_crate_dependencies))]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
/// Various Ethereum types
pub mod eth;
diff --git a/crates/anvil/core/src/types.rs b/crates/anvil/core/src/types.rs
index db966d956..79a6c7a2c 100644
--- a/crates/anvil/core/src/types.rs
+++ b/crates/anvil/core/src/types.rs
@@ -24,10 +24,7 @@ impl<'de> serde::Deserialize<'de> for Forking {
#[serde(rename_all = "camelCase")]
struct ForkOpts {
pub json_rpc_url: Option,
- #[serde(
- default,
- deserialize_with = "crate::eth::serde_helpers::numeric::deserialize_stringified_u64_opt"
- )]
+ #[serde(default, with = "alloy_serde::num::u64_opt_via_ruint")]
pub block_number: Option,
}
@@ -43,12 +40,11 @@ impl<'de> serde::Deserialize<'de> for Forking {
}
let f = match ForkingVariants::deserialize(deserializer)? {
ForkingVariants::Fork(ForkOpts { json_rpc_url, block_number }) => {
- Forking { json_rpc_url, block_number }
+ Self { json_rpc_url, block_number }
+ }
+ ForkingVariants::Tagged(f) => {
+ Self { json_rpc_url: f.forking.json_rpc_url, block_number: f.forking.block_number }
}
- ForkingVariants::Tagged(f) => Forking {
- json_rpc_url: f.forking.json_rpc_url,
- block_number: f.forking.block_number,
- },
};
Ok(f)
}
@@ -60,30 +56,20 @@ impl<'de> serde::Deserialize<'de> for Forking {
#[cfg_attr(feature = "serde", serde(untagged))]
pub enum EvmMineOptions {
Options {
- #[cfg_attr(
- feature = "serde",
- serde(
- deserialize_with = "crate::eth::serde_helpers::numeric::deserialize_stringified_u64_opt"
- )
- )]
+ #[cfg_attr(feature = "serde", serde(with = "alloy_serde::num::u64_opt_via_ruint"))]
timestamp: Option,
// If `blocks` is given, it will mine exactly blocks number of blocks, regardless of any
// other blocks mined or reverted during it's operation
blocks: Option,
},
/// The timestamp the block should be mined with
- #[cfg_attr(
- feature = "serde",
- serde(
- deserialize_with = "crate::eth::serde_helpers::numeric::deserialize_stringified_u64_opt"
- )
- )]
+ #[cfg_attr(feature = "serde", serde(with = "alloy_serde::num::u64_opt_via_ruint"))]
Timestamp(Option),
}
impl Default for EvmMineOptions {
fn default() -> Self {
- EvmMineOptions::Options { timestamp: None, blocks: None }
+ Self::Options { timestamp: None, blocks: None }
}
}
@@ -123,7 +109,7 @@ impl From for usize {
#[cfg(feature = "serde")]
impl<'a> serde::Deserialize<'a> for Index {
- fn deserialize(deserializer: D) -> Result
+ fn deserialize(deserializer: D) -> Result
where
D: serde::Deserializer<'a>,
{
@@ -190,10 +176,10 @@ pub struct NodeInfo {
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
pub struct NodeEnvironment {
- pub base_fee: U256,
+ pub base_fee: u128,
pub chain_id: u64,
- pub gas_limit: U256,
- pub gas_price: U256,
+ pub gas_limit: u128,
+ pub gas_price: u128,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
diff --git a/crates/anvil/rpc/Cargo.toml b/crates/anvil/rpc/Cargo.toml
index 6d4e76540..46a148ea4 100644
--- a/crates/anvil/rpc/Cargo.toml
+++ b/crates/anvil/rpc/Cargo.toml
@@ -9,9 +9,9 @@ license.workspace = true
homepage.workspace = true
repository.workspace = true
+[lints]
+workspace = true
+
[dependencies]
serde.workspace = true
serde_json.workspace = true
-
-[dev-dependencies]
-rand = "0.8"
diff --git a/crates/anvil/rpc/src/error.rs b/crates/anvil/rpc/src/error.rs
index b1929818f..4eec040ac 100644
--- a/crates/anvil/rpc/src/error.rs
+++ b/crates/anvil/rpc/src/error.rs
@@ -14,57 +14,53 @@ pub struct RpcError {
}
impl RpcError {
- /// New [Error] with the given [ErrorCode]
+ /// New [`RpcError`] with the given [`ErrorCode`].
pub const fn new(code: ErrorCode) -> Self {
- RpcError { message: Cow::Borrowed(code.message()), code, data: None }
+ Self { message: Cow::Borrowed(code.message()), code, data: None }
}
- /// Creates a new `ParseError`
+ /// Creates a new `ParseError` error.
pub const fn parse_error() -> Self {
Self::new(ErrorCode::ParseError)
}
- /// Creates a new `MethodNotFound`
+ /// Creates a new `MethodNotFound` error.
pub const fn method_not_found() -> Self {
Self::new(ErrorCode::MethodNotFound)
}
- /// Creates a new `InvalidRequest`
+ /// Creates a new `InvalidRequest` error.
pub const fn invalid_request() -> Self {
Self::new(ErrorCode::InvalidRequest)
}
- /// Creates a new `InternalError`
+ /// Creates a new `InternalError` error.
pub const fn internal_error() -> Self {
Self::new(ErrorCode::InternalError)
}
- /// Creates a new `InvalidParams`
+ /// Creates a new `InvalidParams` error.
pub fn invalid_params(message: M) -> Self
where
M: Into,
{
- RpcError { code: ErrorCode::InvalidParams, message: message.into().into(), data: None }
+ Self { code: ErrorCode::InvalidParams, message: message.into().into(), data: None }
}
- /// Creates a new `InternalError` with a message
+ /// Creates a new `InternalError` error with a message.
pub fn internal_error_with(message: M) -> Self
where
M: Into,
{
- RpcError { code: ErrorCode::InternalError, message: message.into().into(), data: None }
+ Self { code: ErrorCode::InternalError, message: message.into().into(), data: None }
}
- /// Creates a new rpc error for when a transaction was rejected
+ /// Creates a new RPC error for when a transaction was rejected.
pub fn transaction_rejected(message: M) -> Self
where
M: Into,
{
- RpcError {
- code: ErrorCode::TransactionRejected,
- message: message.into().into(),
- data: None,
- }
+ Self { code: ErrorCode::TransactionRejected, message: message.into().into(), data: None }
}
}
@@ -100,28 +96,28 @@ impl ErrorCode {
/// Returns the error code as `i64`
pub fn code(&self) -> i64 {
match *self {
- ErrorCode::ParseError => -32700,
- ErrorCode::InvalidRequest => -32600,
- ErrorCode::MethodNotFound => -32601,
- ErrorCode::InvalidParams => -32602,
- ErrorCode::InternalError => -32603,
- ErrorCode::TransactionRejected => -32003,
- ErrorCode::ExecutionError => 3,
- ErrorCode::ServerError(c) => c,
+ Self::ParseError => -32700,
+ Self::InvalidRequest => -32600,
+ Self::MethodNotFound => -32601,
+ Self::InvalidParams => -32602,
+ Self::InternalError => -32603,
+ Self::TransactionRejected => -32003,
+ Self::ExecutionError => 3,
+ Self::ServerError(c) => c,
}
}
/// Returns the message associated with the error
pub const fn message(&self) -> &'static str {
match *self {
- ErrorCode::ParseError => "Parse error",
- ErrorCode::InvalidRequest => "Invalid request",
- ErrorCode::MethodNotFound => "Method not found",
- ErrorCode::InvalidParams => "Invalid params",
- ErrorCode::InternalError => "Internal error",
- ErrorCode::TransactionRejected => "Transaction rejected",
- ErrorCode::ServerError(_) => "Server error",
- ErrorCode::ExecutionError => "Execution error",
+ Self::ParseError => "Parse error",
+ Self::InvalidRequest => "Invalid request",
+ Self::MethodNotFound => "Method not found",
+ Self::InvalidParams => "Invalid params",
+ Self::InternalError => "Internal error",
+ Self::TransactionRejected => "Transaction rejected",
+ Self::ServerError(_) => "Server error",
+ Self::ExecutionError => "Execution error",
}
}
}
@@ -136,7 +132,7 @@ impl Serialize for ErrorCode {
}
impl<'a> Deserialize<'a> for ErrorCode {
- fn deserialize(deserializer: D) -> Result
+ fn deserialize(deserializer: D) -> Result
where
D: Deserializer<'a>,
{
@@ -147,14 +143,14 @@ impl<'a> Deserialize<'a> for ErrorCode {
impl From for ErrorCode {
fn from(code: i64) -> Self {
match code {
- -32700 => ErrorCode::ParseError,
- -32600 => ErrorCode::InvalidRequest,
- -32601 => ErrorCode::MethodNotFound,
- -32602 => ErrorCode::InvalidParams,
- -32603 => ErrorCode::InternalError,
- -32003 => ErrorCode::TransactionRejected,
- 3 => ErrorCode::ExecutionError,
- _ => ErrorCode::ServerError(code),
+ -32700 => Self::ParseError,
+ -32600 => Self::InvalidRequest,
+ -32601 => Self::MethodNotFound,
+ -32602 => Self::InvalidParams,
+ -32603 => Self::InternalError,
+ -32003 => Self::TransactionRejected,
+ 3 => Self::ExecutionError,
+ _ => Self::ServerError(code),
}
}
}
diff --git a/crates/anvil/rpc/src/lib.rs b/crates/anvil/rpc/src/lib.rs
index 939fbff16..bd5382cee 100644
--- a/crates/anvil/rpc/src/lib.rs
+++ b/crates/anvil/rpc/src/lib.rs
@@ -1,3 +1,10 @@
+//! # anvil-rpc
+//!
+//! JSON-RPC types.
+
+#![cfg_attr(not(test), warn(unused_crate_dependencies))]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
/// JSON-RPC request bindings
pub mod request;
diff --git a/crates/anvil/rpc/src/request.rs b/crates/anvil/rpc/src/request.rs
index 8630f4a4c..5cb8510b8 100644
--- a/crates/anvil/rpc/src/request.rs
+++ b/crates/anvil/rpc/src/request.rs
@@ -77,7 +77,7 @@ pub enum RequestParams {
impl From for serde_json::Value {
fn from(params: RequestParams) -> Self {
match params {
- RequestParams::None => serde_json::Value::Null,
+ RequestParams::None => Self::Null,
RequestParams::Array(arr) => arr.into(),
RequestParams::Object(obj) => obj.into(),
}
@@ -106,9 +106,9 @@ pub enum Id {
impl fmt::Display for Id {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
- Id::String(s) => s.fmt(f),
- Id::Number(n) => n.fmt(f),
- Id::Null => f.write_str("null"),
+ Self::String(s) => s.fmt(f),
+ Self::Number(n) => n.fmt(f),
+ Self::Null => f.write_str("null"),
}
}
}
diff --git a/crates/anvil/rpc/src/response.rs b/crates/anvil/rpc/src/response.rs
index c7649dbe3..2fd01327d 100644
--- a/crates/anvil/rpc/src/response.rs
+++ b/crates/anvil/rpc/src/response.rs
@@ -24,7 +24,7 @@ impl From for RpcResponse {
impl RpcResponse {
pub fn new(id: Id, content: impl Into) -> Self {
- RpcResponse { jsonrpc: Version::V2, id: Some(id), result: content.into() }
+ Self { jsonrpc: Version::V2, id: Some(id), result: content.into() }
}
pub fn invalid_request(id: Id) -> Self {
@@ -47,17 +47,17 @@ impl ResponseResult {
where
S: Serialize + 'static,
{
- ResponseResult::Success(serde_json::to_value(&content).unwrap())
+ Self::Success(serde_json::to_value(&content).unwrap())
}
pub fn error(error: RpcError) -> Self {
- ResponseResult::Error(error)
+ Self::Error(error)
}
}
impl From for ResponseResult {
fn from(err: RpcError) -> Self {
- ResponseResult::error(err)
+ Self::error(err)
}
}
/// Synchronous response
@@ -72,7 +72,7 @@ pub enum Response {
}
impl Response {
- /// Creates new [Response] with the given [Error]
+ /// Creates new [`Response`] with the given [`RpcError`].
pub fn error(error: RpcError) -> Self {
RpcResponse::new(Id::Null, ResponseResult::Error(error)).into()
}
@@ -80,12 +80,12 @@ impl Response {
impl From for Response {
fn from(err: RpcError) -> Self {
- Response::error(err)
+ Self::error(err)
}
}
impl From for Response {
fn from(resp: RpcResponse) -> Self {
- Response::Single(resp)
+ Self::Single(resp)
}
}
diff --git a/crates/anvil/server/Cargo.toml b/crates/anvil/server/Cargo.toml
index fb880a422..282e09013 100644
--- a/crates/anvil/server/Cargo.toml
+++ b/crates/anvil/server/Cargo.toml
@@ -10,35 +10,37 @@ license.workspace = true
homepage.workspace = true
repository.workspace = true
+[lints]
+workspace = true
+
[dependencies]
anvil-rpc = { path = "../rpc" }
# axum related
axum = { workspace = true, features = ["ws"] }
-hyper.workspace = true
tower-http = { workspace = true, features = ["trace", "cors"] }
# tracing
tracing.workspace = true
# async
-parking_lot = "0.12"
-futures = "0.3"
+parking_lot.workspace = true
+futures.workspace = true
# ipc
-parity-tokio-ipc = { version = "0.9", optional = true }
+interprocess = { version = "2", optional = true, features = ["tokio"] }
bytes = { version = "1.4", optional = true }
tokio-util = { version = "0.7", features = ["codec"], optional = true }
# misc
serde_json.workspace = true
serde.workspace = true
-async-trait = "0.1"
-thiserror = "1"
+async-trait.workspace = true
+thiserror.workspace = true
clap = { version = "4", features = ["derive", "env"], optional = true }
pin-project = "1"
[features]
default = ["ipc"]
-ipc = ["parity-tokio-ipc", "bytes", "tokio-util"]
+ipc = ["dep:interprocess", "dep:bytes", "dep:tokio-util"]
diff --git a/crates/anvil/server/src/config.rs b/crates/anvil/server/src/config.rs
index 7e2352831..ea97d24cd 100644
--- a/crates/anvil/server/src/config.rs
+++ b/crates/anvil/server/src/config.rs
@@ -4,16 +4,15 @@ use std::str::FromStr;
/// Additional server options.
#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "clap", derive(clap::Parser), clap(next_help_heading = "Server options"))]
+#[cfg_attr(feature = "clap", derive(clap::Parser), command(next_help_heading = "Server options"))]
pub struct ServerConfig {
/// The cors `allow_origin` header
#[cfg_attr(
feature = "clap",
- clap(
+ arg(
long,
help = "Set the CORS allow_origin",
default_value = "*",
- name = "allow-origin",
value_name = "ALLOW_ORIGIN"
)
)]
@@ -21,13 +20,11 @@ pub struct ServerConfig {
/// Whether to enable CORS
#[cfg_attr(
feature = "clap",
- clap(long, help = "Disable CORS", conflicts_with = "allow-origin")
+ arg(long, help = "Disable CORS", conflicts_with = "allow_origin")
)]
pub no_cors: bool,
}
-// === impl ServerConfig ===
-
impl ServerConfig {
/// Sets the "allow origin" header for cors
pub fn with_allow_origin(mut self, allow_origin: impl Into) -> Self {
@@ -55,7 +52,7 @@ impl FromStr for HeaderValueWrapper {
type Err = ::Err;
fn from_str(s: &str) -> Result {
- Ok(HeaderValueWrapper(s.parse()?))
+ Ok(Self(s.parse()?))
}
}
@@ -94,6 +91,6 @@ impl From for HeaderValue {
impl From for HeaderValueWrapper {
fn from(header: HeaderValue) -> Self {
- HeaderValueWrapper(header)
+ Self(header)
}
}
diff --git a/crates/anvil/server/src/ipc.rs b/crates/anvil/server/src/ipc.rs
index 97ec07098..8743f0642 100644
--- a/crates/anvil/server/src/ipc.rs
+++ b/crates/anvil/server/src/ipc.rs
@@ -4,7 +4,7 @@ use crate::{error::RequestError, pubsub::PubSubConnection, PubSubRpcHandler};
use anvil_rpc::request::Request;
use bytes::BytesMut;
use futures::{ready, Sink, Stream, StreamExt};
-use parity_tokio_ipc::Endpoint;
+use interprocess::local_socket::{self as ls, tokio::prelude::*};
use std::{
future::Future,
io,
@@ -18,55 +18,58 @@ use std::{
pub struct IpcEndpoint {
/// the handler for the websocket connection
handler: Handler,
- /// The endpoint we listen for incoming transactions
- endpoint: Endpoint,
+ /// The path to the socket
+ path: String,
}
impl IpcEndpoint {
/// Creates a new endpoint with the given handler
- pub fn new(handler: Handler, endpoint: impl Into) -> Self {
- Self { handler, endpoint: Endpoint::new(endpoint.into()) }
+ pub fn new(handler: Handler, path: String) -> Self {
+ Self { handler, path }
}
- /// Returns a stream of incoming connection handlers
+ /// Returns a stream of incoming connection handlers.
///
- /// This establishes the ipc endpoint, converts the incoming connections into handled eth
- /// connections, See [`PubSubConnection`] that should be spawned
+ /// This establishes the IPC endpoint, converts the incoming connections into handled
+ /// connections.
#[instrument(target = "ipc", skip_all)]
pub fn incoming(self) -> io::Result>> {
- let IpcEndpoint { handler, endpoint } = self;
- trace!(endpoint=?endpoint.path(), "starting IPC server" );
+ let Self { handler, path } = self;
+
+ trace!(%path, "starting IPC server");
if cfg!(unix) {
// ensure the file does not exist
- if std::fs::remove_file(endpoint.path()).is_ok() {
- warn!(endpoint=?endpoint.path(), "removed existing file");
+ if std::fs::remove_file(&path).is_ok() {
+ warn!(%path, "removed existing file");
}
}
- let connections = match endpoint.incoming() {
- Ok(connections) => connections,
- Err(err) => {
- error!(%err, "Failed to create IPC listener");
- return Err(err)
- }
- };
+ let name = to_name(path.as_ref())?;
+ let listener = ls::ListenerOptions::new().name(name).create_tokio()?;
+ let connections = futures::stream::unfold(listener, |listener| async move {
+ let conn = listener.accept().await;
+ Some((conn, listener))
+ });
trace!("established connection listener");
- let connections = connections.filter_map(move |stream| {
+ Ok(connections.filter_map(move |stream| {
let handler = handler.clone();
- Box::pin(async move {
- if let Ok(stream) = stream {
- trace!("successful incoming IPC connection");
- let framed = tokio_util::codec::Decoder::framed(JsonRpcCodec, stream);
- Some(PubSubConnection::new(IpcConn(framed), handler))
- } else {
- None
+ async move {
+ match stream {
+ Ok(stream) => {
+ trace!("successful incoming IPC connection");
+ let framed = tokio_util::codec::Decoder::framed(JsonRpcCodec, stream);
+ Some(PubSubConnection::new(IpcConn(framed), handler))
+ }
+ Err(err) => {
+ trace!(%err, "unsuccessful incoming IPC connection");
+ None
+ }
}
- })
- });
- Ok(connections)
+ }
+ }))
}
}
@@ -118,7 +121,7 @@ where
struct JsonRpcCodec;
-// Adapted from
+// Adapted from
impl tokio_util::codec::Decoder for JsonRpcCodec {
type Item = String;
type Error = io::Error;
@@ -171,3 +174,11 @@ impl tokio_util::codec::Encoder for JsonRpcCodec {
Ok(())
}
}
+
+fn to_name(path: &std::ffi::OsStr) -> io::Result> {
+ if cfg!(windows) && !path.as_encoded_bytes().starts_with(br"\\.\pipe\") {
+ ls::ToNsName::to_ns_name::(path)
+ } else {
+ ls::ToFsName::to_fs_name::(path)
+ }
+}
diff --git a/crates/anvil/server/src/lib.rs b/crates/anvil/server/src/lib.rs
index 5ff287c96..b60182505 100644
--- a/crates/anvil/server/src/lib.rs
+++ b/crates/anvil/server/src/lib.rs
@@ -1,6 +1,7 @@
-//! Bootstrap [axum] RPC servers
+//! Bootstrap [axum] RPC servers.
-#![warn(missing_docs, unused_crate_dependencies)]
+#![cfg_attr(not(test), warn(unused_crate_dependencies))]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
#[macro_use]
extern crate tracing;
@@ -12,91 +13,66 @@ use anvil_rpc::{
};
use axum::{
http::{header, HeaderValue, Method},
- routing::{post, IntoMakeService},
- Router, Server,
+ routing::{post, MethodRouter},
+ Router,
};
-use hyper::server::conn::AddrIncoming;
use serde::de::DeserializeOwned;
-use std::{fmt, net::SocketAddr};
+use std::fmt;
use tower_http::{cors::CorsLayer, trace::TraceLayer};
mod config;
+pub use config::ServerConfig;
mod error;
-/// handlers for axum server
mod handler;
-#[cfg(feature = "ipc")]
-pub mod ipc;
+
mod pubsub;
-mod ws;
+pub use pubsub::{PubSubContext, PubSubRpcHandler};
-pub use crate::pubsub::{PubSubContext, PubSubRpcHandler};
-pub use config::ServerConfig;
+mod ws;
-/// Type alias for the configured axum server
-pub type AnvilServer = Server>;
+#[cfg(feature = "ipc")]
+pub mod ipc;
-/// Configures an [axum::Server] that handles RPC-Calls, both HTTP requests and requests via
-/// websocket
-pub fn serve_http_ws(
- addr: SocketAddr,
- config: ServerConfig,
- http: Http,
- ws: Ws,
-) -> AnvilServer
+/// Configures an [`axum::Router`] that handles JSON-RPC calls via both HTTP and WS.
+pub fn http_ws_router(config: ServerConfig, http: Http, ws: Ws) -> Router
where
Http: RpcHandler,
Ws: PubSubRpcHandler,
{
- let ServerConfig { allow_origin, no_cors } = config;
-
- let svc = Router::new()
- .route("/", post(handler::handle).get(ws::handle_ws))
- .with_state((http, ws))
- .layer(TraceLayer::new_for_http());
-
- let svc = if no_cors {
- svc
- } else {
- svc.layer(
- // see https://docs.rs/tower-http/latest/tower_http/cors/index.html
- // for more details
- CorsLayer::new()
- .allow_origin(allow_origin.0)
- .allow_headers(vec![header::CONTENT_TYPE])
- .allow_methods(vec![Method::GET, Method::POST]),
- )
- }
- .into_make_service();
- Server::bind(&addr).serve(svc)
+ router_inner(config, post(handler::handle).get(ws::handle_ws), (http, ws))
}
-/// Configures an [axum::Server] that handles RPC-Calls listing for POST on `/`
-pub fn serve_http(addr: SocketAddr, config: ServerConfig, http: Http) -> AnvilServer
+/// Configures an [`axum::Router`] that handles JSON-RPC calls via HTTP.
+pub fn http_router(config: ServerConfig, http: Http) -> Router
where
Http: RpcHandler,
{
+ router_inner(config, post(handler::handle), (http, ()))
+}
+
+fn router_inner(
+ config: ServerConfig,
+ root_method_router: MethodRouter
,
+ state: S,
+) -> Router {
let ServerConfig { allow_origin, no_cors } = config;
- let svc = Router::new()
- .route("/", post(handler::handle))
- .with_state((http, ()))
+ let mut router = Router::new()
+ .route("/", root_method_router)
+ .with_state(state)
.layer(TraceLayer::new_for_http());
- let svc = if no_cors {
- svc
- } else {
- svc.layer(
- // see https://docs.rs/tower-http/latest/tower_http/cors/index.html
- // for more details
+ if !no_cors {
+ // See [`tower_http::cors`](https://docs.rs/tower-http/latest/tower_http/cors/index.html)
+ // for more details.
+ router = router.layer(
CorsLayer::new()
.allow_origin(allow_origin.0)
- .allow_headers(vec![header::CONTENT_TYPE])
- .allow_methods(vec![Method::GET, Method::POST]),
- )
+ .allow_headers([header::CONTENT_TYPE])
+ .allow_methods([Method::GET, Method::POST]),
+ );
}
- .into_make_service();
-
- Server::bind(&addr).serve(svc)
+ router
}
/// Helper trait that is used to execute ethereum rpc calls
diff --git a/crates/anvil/server/src/pubsub.rs b/crates/anvil/server/src/pubsub.rs
index 3c9be85bc..2fe4358ef 100644
--- a/crates/anvil/server/src/pubsub.rs
+++ b/crates/anvil/server/src/pubsub.rs
@@ -40,8 +40,6 @@ pub struct PubSubContext {
subscriptions: Subscriptions,
}
-// === impl PubSubContext ===
-
impl PubSubContext {
/// Adds new active subscription
///
@@ -125,8 +123,6 @@ pub struct PubSubConnection {
pending: VecDeque,
}
-// === impl PubSubConnection ===
-
impl PubSubConnection {
pub fn new(connection: Connection, handler: Handler) -> Self {
Self {
diff --git a/crates/anvil/src/anvil.rs b/crates/anvil/src/anvil.rs
index 5ff939482..1aa204587 100644
--- a/crates/anvil/src/anvil.rs
+++ b/crates/anvil/src/anvil.rs
@@ -1,34 +1,42 @@
//! The `anvil` cli
+
use anvil::cmd::NodeArgs;
use clap::{CommandFactory, Parser, Subcommand};
+use foundry_cli::utils;
+
+#[cfg(all(feature = "jemalloc", unix))]
+#[global_allocator]
+static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
/// A fast local Ethereum development node.
#[derive(Parser)]
-#[clap(name = "anvil", version = anvil::VERSION_MESSAGE, next_display_order = None)]
+#[command(name = "anvil", version = anvil::VERSION_MESSAGE, next_display_order = None)]
pub struct Anvil {
- #[clap(flatten)]
+ #[command(flatten)]
pub node: NodeArgs,
- #[clap(subcommand)]
+ #[command(subcommand)]
pub cmd: Option,
}
#[derive(Subcommand)]
pub enum AnvilSubcommand {
/// Generate shell completions script.
- #[clap(visible_alias = "com")]
+ #[command(visible_alias = "com")]
Completions {
- #[clap(value_enum)]
+ #[arg(value_enum)]
shell: clap_complete::Shell,
},
/// Generate Fig autocompletion spec.
- #[clap(visible_alias = "fig")]
+ #[command(visible_alias = "fig")]
GenerateFigSpec,
}
#[tokio::main]
-async fn main() -> Result<(), Box> {
+async fn main() -> eyre::Result<()> {
+ utils::load_dotenv();
+
let mut app = Anvil::parse();
app.node.evm_opts.resolve_rpc_alias();
diff --git a/crates/anvil/src/cmd.rs b/crates/anvil/src/cmd.rs
index b87da3557..ca86a06e1 100644
--- a/crates/anvil/src/cmd.rs
+++ b/crates/anvil/src/cmd.rs
@@ -5,11 +5,11 @@ use crate::{
};
use alloy_genesis::Genesis;
use alloy_primitives::{utils::Unit, U256};
-use alloy_signer::coins_bip39::{English, Mnemonic};
+use alloy_signer_local::coins_bip39::{English, Mnemonic};
use anvil_server::ServerConfig;
use clap::Parser;
use core::fmt;
-use foundry_config::{Chain, Config};
+use foundry_config::{Chain, Config, FigmentProviders};
use futures::FutureExt;
use rand::{rngs::StdRng, SeedableRng};
use std::{
@@ -30,72 +30,76 @@ use tokio::time::{Instant, Interval};
#[derive(Clone, Debug, Parser)]
pub struct NodeArgs {
/// Port number to listen on.
- #[clap(long, short, default_value = "8545", value_name = "NUM")]
+ #[arg(long, short, default_value = "8545", value_name = "NUM")]
pub port: u16,
/// Number of dev accounts to generate and configure.
- #[clap(long, short, default_value = "10", value_name = "NUM")]
+ #[arg(long, short, default_value = "10", value_name = "NUM")]
pub accounts: u64,
/// The balance of every dev account in Ether.
- #[clap(long, default_value = "10000", value_name = "NUM")]
+ #[arg(long, default_value = "10000", value_name = "NUM")]
pub balance: u64,
/// The timestamp of the genesis block.
- #[clap(long, value_name = "NUM")]
+ #[arg(long, value_name = "NUM")]
pub timestamp: Option,
/// BIP39 mnemonic phrase used for generating accounts.
- /// Cannot be used if `mnemonic_random` or `mnemonic_seed` are used
- #[clap(long, short, conflicts_with_all = &["mnemonic_seed", "mnemonic_random"])]
+ /// Cannot be used if `mnemonic_random` or `mnemonic_seed` are used.
+ #[arg(long, short, conflicts_with_all = &["mnemonic_seed", "mnemonic_random"])]
pub mnemonic: Option,
/// Automatically generates a BIP39 mnemonic phrase, and derives accounts from it.
- /// Cannot be used with other `mnemonic` options
+ /// Cannot be used with other `mnemonic` options.
/// You can specify the number of words you want in the mnemonic.
/// [default: 12]
- #[clap(long, conflicts_with_all = &["mnemonic", "mnemonic_seed"], default_missing_value = "12", num_args(0..=1))]
+ #[arg(long, conflicts_with_all = &["mnemonic", "mnemonic_seed"], default_missing_value = "12", num_args(0..=1))]
pub mnemonic_random: Option,
/// Generates a BIP39 mnemonic phrase from a given seed
- /// Cannot be used with other `mnemonic` options
+ /// Cannot be used with other `mnemonic` options.
///
- /// CAREFUL: this is NOT SAFE and should only be used for testing.
+ /// CAREFUL: This is NOT SAFE and should only be used for testing.
/// Never use the private keys generated in production.
- #[clap(long = "mnemonic-seed-unsafe", conflicts_with_all = &["mnemonic", "mnemonic_random"])]
+ #[arg(long = "mnemonic-seed-unsafe", conflicts_with_all = &["mnemonic", "mnemonic_random"])]
pub mnemonic_seed: Option,
/// Sets the derivation path of the child key to be derived.
///
/// [default: m/44'/60'/0'/0/]
- #[clap(long)]
+ #[arg(long)]
pub derivation_path: Option,
/// Don't print anything on startup and don't print logs
- #[clap(long)]
+ #[arg(long)]
pub silent: bool,
/// The EVM hardfork to use.
///
/// Choose the hardfork by name, e.g. `shanghai`, `paris`, `london`, etc...
/// [default: latest]
- #[clap(long, value_parser = Hardfork::from_str)]
+ #[arg(long, value_parser = Hardfork::from_str)]
pub hardfork: Option,
/// Block time in seconds for interval mining.
- #[clap(short, long, visible_alias = "blockTime", name = "block-time", value_name = "SECONDS")]
- pub block_time: Option,
+ #[arg(short, long, visible_alias = "blockTime", value_name = "SECONDS", value_parser = duration_from_secs_f64)]
+ pub block_time: Option,
+
+ /// Slots in an epoch
+ #[arg(long, value_name = "SLOTS_IN_AN_EPOCH", default_value_t = 32)]
+ pub slots_in_an_epoch: u64,
/// Writes output of `anvil` as json to user-specified file.
- #[clap(long, value_name = "OUT_FILE")]
+ #[arg(long, value_name = "OUT_FILE")]
pub config_out: Option,
/// Disable auto and interval mining, and mine on demand instead.
- #[clap(long, visible_alias = "no-mine", conflicts_with = "block-time")]
+ #[arg(long, visible_alias = "no-mine", conflicts_with = "block_time")]
pub no_mining: bool,
/// The hosts the server will listen on.
- #[clap(
+ #[arg(
long,
value_name = "IP_ADDR",
env = "ANVIL_IP_ADDR",
@@ -106,18 +110,18 @@ pub struct NodeArgs {
pub host: Vec,
/// How transactions are sorted in the mempool.
- #[clap(long, default_value = "fees")]
+ #[arg(long, default_value = "fees")]
pub order: TransactionOrder,
/// Initialize the genesis block with the given `genesis.json` file.
- #[clap(long, value_name = "PATH", value_parser= read_genesis_file)]
+ #[arg(long, value_name = "PATH", value_parser= read_genesis_file)]
pub init: Option,
/// This is an alias for both --load-state and --dump-state.
///
/// It initializes the chain with the state and block environment stored at the file, if it
/// exists, and dumps the chain's state on exit.
- #[clap(
+ #[arg(
long,
value_name = "PATH",
value_parser = StateFile::parse,
@@ -132,17 +136,17 @@ pub struct NodeArgs {
/// Interval in seconds at which the state and block environment is to be dumped to disk.
///
/// See --state and --dump-state
- #[clap(short, long, value_name = "SECONDS")]
+ #[arg(short, long, value_name = "SECONDS")]
pub state_interval: Option,
/// Dump the state and block environment of chain on exit to the given file.
///
/// If the value is a directory, the state will be written to `/state.json`.
- #[clap(long, value_name = "PATH", conflicts_with = "init")]
+ #[arg(long, value_name = "PATH", conflicts_with = "init")]
pub dump_state: Option,
/// Initialize the chain from a previously saved state snapshot.
- #[clap(
+ #[arg(
long,
value_name = "PATH",
value_parser = SerializableState::parse,
@@ -150,22 +154,22 @@ pub struct NodeArgs {
)]
pub load_state: Option,
- #[clap(long, help = IPC_HELP, value_name = "PATH", visible_alias = "ipcpath")]
+ #[arg(long, help = IPC_HELP, value_name = "PATH", visible_alias = "ipcpath")]
pub ipc: Option>,
/// Don't keep full chain history.
/// If a number argument is specified, at most this number of states is kept in memory.
- #[clap(long)]
+ #[arg(long)]
pub prune_history: Option>,
/// Number of blocks with transactions to keep in memory.
- #[clap(long)]
+ #[arg(long)]
pub transaction_block_keeper: Option,
- #[clap(flatten)]
+ #[command(flatten)]
pub evm_opts: AnvilEvmArgs,
- #[clap(flatten)]
+ #[command(flatten)]
pub server_config: ServerConfig,
}
@@ -190,11 +194,11 @@ impl NodeArgs {
};
NodeConfig::default()
- .with_gas_limit(self.evm_opts.gas_limit.map(U256::from))
+ .with_gas_limit(self.evm_opts.gas_limit)
.disable_block_gas_limit(self.evm_opts.disable_block_gas_limit)
- .with_gas_price(self.evm_opts.gas_price.map(U256::from))
+ .with_gas_price(self.evm_opts.gas_price)
.with_hardfork(self.hardfork)
- .with_blocktime(self.block_time.map(Duration::from_secs))
+ .with_blocktime(self.block_time)
.with_no_mining(self.no_mining)
.with_account_generator(self.account_generator())
.with_genesis_balance(genesis_balance)
@@ -212,7 +216,7 @@ impl NodeArgs {
.fork_retry_backoff(self.evm_opts.fork_retry_backoff.map(Duration::from_millis))
.fork_compute_units_per_second(compute_units_per_second)
.with_eth_rpc_url(self.evm_opts.fork_url.map(|fork| fork.url))
- .with_base_fee(self.evm_opts.block_base_fee_per_gas.map(U256::from))
+ .with_base_fee(self.evm_opts.block_base_fee_per_gas)
.with_storage_caching(self.evm_opts.no_storage_caching)
.with_server_config(self.server_config)
.with_host(self.host)
@@ -229,6 +233,9 @@ impl NodeArgs {
.with_init_state(self.load_state.or_else(|| self.state.and_then(|s| s.state)))
.with_transaction_block_keeper(self.transaction_block_keeper)
.with_optimism(self.evm_opts.optimism)
+ .with_disable_default_create2_deployer(self.evm_opts.disable_default_create2_deployer)
+ .with_slots_in_an_epoch(self.slots_in_an_epoch)
+ .with_memory_limit(self.evm_opts.memory_limit)
}
fn account_generator(&self) -> AccountGenerator {
@@ -263,12 +270,12 @@ impl NodeArgs {
/// Starts the node
///
/// See also [crate::spawn()]
- pub async fn run(self) -> Result<(), Box