jleony/nanoreth
1
0
Fork 0
mirror of https://github.com/hl-archive-node/nanoreth.git synced 2025-12-06 10:59:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #80 from hl-archive-node/chore/v1.8.2

Browse Source 
chore: Upgrade to reth v1.8.2
This commit is contained in:
sprites0
2025-10-05 04:38:54 -04:00
committed by GitHub
parent c93ff90f94 b55ddc54ad
commit 24f2460337
53 changed files with 685 additions and 630 deletions
Download Patch File Download Diff File Expand all files Collapse all files

653
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

110
Cargo.toml
View File

@ -1,7 +1,7 @@
[package] [package]
name = "reth_hl" name = "reth_hl"
version = "0.1.0" version = "0.1.0"
edition = "2021" edition = "2024"
build = "build.rs" build = "build.rs"
[lib] [lib]
@ -26,67 +26,67 @@ lto = "fat"
codegen-units = 1 codegen-units = 1
[dependencies] [dependencies]
reth = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-cli = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-cli = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-cli-commands = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-cli-commands = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-basic-payload-builder = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-basic-payload-builder = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-db = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-db = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-db-api = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-db-api = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-chainspec = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-chainspec = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-cli-util = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-cli-util = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-discv4 = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-discv4 = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-engine-primitives = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-engine-primitives = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-ethereum-forks = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-ethereum-forks = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-ethereum-payload-builder = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-ethereum-payload-builder = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-ethereum-primitives = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-ethereum-primitives = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-eth-wire = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-eth-wire = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-eth-wire-types = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-eth-wire-types = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-evm = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-evm = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-evm-ethereum = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-evm-ethereum = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-node-core = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-node-core = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-revm = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-revm = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-network = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-network = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-network-p2p = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-network-p2p = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-network-api = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-network-api = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-node-ethereum = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-node-ethereum = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-network-peers = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-network-peers = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-payload-primitives = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-payload-primitives = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-primitives = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-primitives = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-primitives-traits = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-primitives-traits = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-provider = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34", features = ["test-utils"] } reth-provider = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88", features = ["test-utils"] }
reth-rpc = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-rpc = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-rpc-eth-api = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-rpc-eth-api = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-rpc-engine-api = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-rpc-engine-api = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-tracing = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-tracing = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-trie-common = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-trie-common = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-trie-db = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-trie-db = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-codecs = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-codecs = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-transaction-pool = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-transaction-pool = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-stages-types = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-stages-types = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-storage-api = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-storage-api = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-errors = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-errors = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-rpc-convert = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-rpc-convert = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-rpc-eth-types = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-rpc-eth-types = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-rpc-server-types = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-rpc-server-types = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
reth-metrics = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" } reth-metrics = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
revm = { version = "29.0.0", default-features = false } revm = { version = "29.0.1", default-features = false }
# alloy dependencies # alloy dependencies
alloy-genesis = { version = "1.0.30", default-features = false } alloy-genesis = { version = "1.0.37", default-features = false }
alloy-consensus = { version = "1.0.30", default-features = false } alloy-consensus = { version = "1.0.37", default-features = false }
alloy-chains = { version = "0.2.5", default-features = false } alloy-chains = { version = "0.2.5", default-features = false }
alloy-eips = { version = "1.0.30", default-features = false } alloy-eips = { version = "1.0.37", default-features = false }
alloy-evm = { version = "0.20.1", default-features = false } alloy-evm = { version = "0.21.0", default-features = false }
alloy-json-abi = { version = "1.3.1", default-features = false } alloy-json-abi = { version = "1.3.1", default-features = false }
alloy-json-rpc = { version = "1.0.30", default-features = false } alloy-json-rpc = { version = "1.0.37", default-features = false }
alloy-dyn-abi = "1.3.1" alloy-dyn-abi = "1.3.1"
alloy-network = { version = "1.0.30", default-features = false } alloy-network = { version = "1.0.37", default-features = false }
alloy-primitives = { version = "1.3.1", default-features = false, features = ["map-foldhash"] } alloy-primitives = { version = "1.3.1", default-features = false, features = ["map-foldhash"] }
alloy-rlp = { version = "0.3.10", default-features = false, features = ["core-net"] } alloy-rlp = { version = "0.3.10", default-features = false, features = ["core-net"] }
alloy-rpc-types = { version = "1.0.30", features = ["eth"], default-features = false } alloy-rpc-types = { version = "1.0.37", features = ["eth"], default-features = false }
alloy-rpc-types-eth = { version = "1.0.30", default-features = false } alloy-rpc-types-eth = { version = "1.0.37", default-features = false }
alloy-rpc-types-engine = { version = "1.0.30", default-features = false } alloy-rpc-types-engine = { version = "1.0.37", default-features = false }
alloy-signer = { version = "1.0.30", default-features = false } alloy-signer = { version = "1.0.37", default-features = false }
alloy-sol-macro = "1.3.1" alloy-sol-macro = "1.3.1"
alloy-sol-types = { version = "1.3.1", default-features = false } alloy-sol-types = { version = "1.3.1", default-features = false }

8
src/addons/call_forwarder.rs
View File

@ -2,18 +2,18 @@ use alloy_eips::BlockId;
use alloy_json_rpc::RpcObject; use alloy_json_rpc::RpcObject;
use alloy_primitives::{Bytes, U256}; use alloy_primitives::{Bytes, U256};
use alloy_rpc_types_eth::{ use alloy_rpc_types_eth::{
state::{EvmOverrides, StateOverride},
BlockOverrides, BlockOverrides,
state::{EvmOverrides, StateOverride},
}; };
use jsonrpsee::{ use jsonrpsee::{
http_client::{HttpClient, HttpClientBuilder}, http_client::{HttpClient, HttpClientBuilder},
proc_macros::rpc, proc_macros::rpc,
rpc_params, rpc_params,
types::{error::INTERNAL_ERROR_CODE, ErrorObject}, types::{ErrorObject, error::INTERNAL_ERROR_CODE},
}; };
use jsonrpsee_core::{async_trait, client::ClientT, ClientError, RpcResult}; use jsonrpsee_core::{ClientError, RpcResult, async_trait, client::ClientT};
use reth_rpc::eth::EthApiTypes; use reth_rpc::eth::EthApiTypes;
use reth_rpc_eth_api::{helpers::EthCall, RpcTxReq}; use reth_rpc_eth_api::{RpcTxReq, helpers::EthCall};
#[rpc(server, namespace = "eth")] #[rpc(server, namespace = "eth")]
pub(crate) trait CallForwarderApi<TxReq: RpcObject> { pub(crate) trait CallForwarderApi<TxReq: RpcObject> {

34
src/addons/hl_node_compliance.rs
View File

@ -7,34 +7,37 @@
//! For non-system transactions, we can just return the log as is, and the client will //! For non-system transactions, we can just return the log as is, and the client will
//! adjust the transaction index accordingly. //! adjust the transaction index accordingly.
use alloy_consensus::{transaction::TransactionMeta, BlockHeader, TxReceipt}; use alloy_consensus::{
BlockHeader, TxReceipt,
transaction::{TransactionMeta, TxHashRef},
};
use alloy_eips::{BlockId, BlockNumberOrTag}; use alloy_eips::{BlockId, BlockNumberOrTag};
use alloy_json_rpc::RpcObject; use alloy_json_rpc::RpcObject;
use alloy_primitives::{B256, U256}; use alloy_primitives::{B256, U256};
use alloy_rpc_types::{ use alloy_rpc_types::{
pubsub::{Params, SubscriptionKind},
BlockTransactions, Filter, FilterChanges, FilterId, Log, PendingTransactionFilterKind, BlockTransactions, Filter, FilterChanges, FilterId, Log, PendingTransactionFilterKind,
TransactionInfo, TransactionInfo,
pubsub::{Params, SubscriptionKind},
}; };
use jsonrpsee::{proc_macros::rpc, PendingSubscriptionSink, SubscriptionMessage, SubscriptionSink}; use jsonrpsee::{PendingSubscriptionSink, SubscriptionMessage, SubscriptionSink, proc_macros::rpc};
use jsonrpsee_core::{async_trait, RpcResult}; use jsonrpsee_core::{RpcResult, async_trait};
use jsonrpsee_types::{error::INTERNAL_ERROR_CODE, ErrorObject}; use jsonrpsee_types::{ErrorObject, error::INTERNAL_ERROR_CODE};
use reth::{api::FullNodeComponents, builder::rpc::RpcContext, tasks::TaskSpawner}; use reth::{api::FullNodeComponents, builder::rpc::RpcContext, tasks::TaskSpawner};
use reth_primitives_traits::{BlockBody as _, SignedTransaction}; use reth_primitives_traits::{BlockBody as _, SignedTransaction};
use reth_provider::{BlockIdReader, BlockReader, BlockReaderIdExt, ReceiptProvider}; use reth_provider::{BlockIdReader, BlockReader, BlockReaderIdExt, ReceiptProvider};
use reth_rpc::{eth::pubsub::SubscriptionSerializeError, EthFilter, EthPubSub, RpcTypes}; use reth_rpc::{EthFilter, EthPubSub, RpcTypes, eth::pubsub::SubscriptionSerializeError};
use reth_rpc_eth_api::{ use reth_rpc_eth_api::{
helpers::{EthBlocks, EthTransactions, LoadReceipt},
transaction::ConvertReceiptInput,
EthApiServer, EthApiTypes, EthFilterApiServer, EthPubSubApiServer, FullEthApiTypes, RpcBlock, EthApiServer, EthApiTypes, EthFilterApiServer, EthPubSubApiServer, FullEthApiTypes, RpcBlock,
RpcConvert, RpcHeader, RpcNodeCoreExt, RpcReceipt, RpcTransaction, RpcTxReq, RpcConvert, RpcHeader, RpcNodeCoreExt, RpcReceipt, RpcTransaction, RpcTxReq,
helpers::{EthBlocks, EthTransactions, LoadReceipt},
transaction::ConvertReceiptInput,
}; };
use serde::Serialize; use serde::Serialize;
use std::{borrow::Cow, marker::PhantomData, sync::Arc}; use std::{marker::PhantomData, sync::Arc};
use tokio_stream::{Stream, StreamExt}; use tokio_stream::{Stream, StreamExt};
use tracing::{trace, Instrument}; use tracing::{Instrument, trace};
use crate::{node::primitives::HlPrimitives, HlBlock}; use crate::{HlBlock, node::primitives::HlPrimitives};
pub trait EthWrapper: pub trait EthWrapper:
EthApiServer< EthApiServer<
@ -182,7 +185,7 @@ impl<Eth: EthWrapper> HlSystemTransactionExt<Eth> {
}; };
let input = ConvertReceiptInput { let input = ConvertReceiptInput {
receipt: Cow::Borrowed(receipt), receipt: receipt.clone(),
tx, tx,
gas_used: receipt.cumulative_gas_used() - gas_used, gas_used: receipt.cumulative_gas_used() - gas_used,
next_log_index, next_log_index,
@ -530,7 +533,7 @@ async fn adjust_block_receipts<Eth: EthWrapper>(
}; };
let input = ConvertReceiptInput { let input = ConvertReceiptInput {
receipt: Cow::Borrowed(receipt), receipt: receipt.clone(),
tx, tx,
gas_used: receipt.cumulative_gas_used() - gas_used, gas_used: receipt.cumulative_gas_used() - gas_used,
next_log_index, next_log_index,
@ -576,9 +579,8 @@ async fn adjust_transaction_receipt<Eth: EthWrapper>(
fn system_tx_count_for_block<Eth: EthWrapper>(eth_api: &Eth, block_id: BlockId) -> usize { fn system_tx_count_for_block<Eth: EthWrapper>(eth_api: &Eth, block_id: BlockId) -> usize {
let provider = eth_api.provider(); let provider = eth_api.provider();
let block = provider.block_by_id(block_id).unwrap().unwrap(); let block = provider.block_by_id(block_id).unwrap().unwrap();
let system_tx_count =
block.body.transactions().iter().filter(|tx| tx.is_system_transaction()).count(); block.body.transactions().iter().filter(|tx| tx.is_system_transaction()).count()
system_tx_count
} }
#[async_trait] #[async_trait]

6
src/addons/tx_forwarder.rs
View File

@ -2,14 +2,14 @@ use std::time::Duration;
use alloy_json_rpc::RpcObject; use alloy_json_rpc::RpcObject;
use alloy_network::Ethereum; use alloy_network::Ethereum;
use alloy_primitives::{Bytes, B256}; use alloy_primitives::{B256, Bytes};
use alloy_rpc_types::TransactionRequest; use alloy_rpc_types::TransactionRequest;
use jsonrpsee::{ use jsonrpsee::{
http_client::{HttpClient, HttpClientBuilder}, http_client::{HttpClient, HttpClientBuilder},
proc_macros::rpc, proc_macros::rpc,
types::{error::INTERNAL_ERROR_CODE, ErrorObject}, types::{ErrorObject, error::INTERNAL_ERROR_CODE},
}; };
use jsonrpsee_core::{async_trait, client::ClientT, ClientError, RpcResult}; use jsonrpsee_core::{ClientError, RpcResult, async_trait, client::ClientT};
use reth::rpc::{result::internal_rpc_err, server_types::eth::EthApiError}; use reth::rpc::{result::internal_rpc_err, server_types::eth::EthApiError};
use reth_rpc_eth_api::RpcReceipt; use reth_rpc_eth_api::RpcReceipt;

2
src/chainspec/hl.rs
View File

@ -1,5 +1,5 @@
use alloy_chains::{Chain, NamedChain}; use alloy_chains::{Chain, NamedChain};
use alloy_primitives::{b256, Address, Bytes, B256, B64, U256}; use alloy_primitives::{Address, B64, B256, Bytes, U256, b256};
use reth_chainspec::{ChainHardforks, ChainSpec, EthereumHardfork, ForkCondition, Hardfork}; use reth_chainspec::{ChainHardforks, ChainSpec, EthereumHardfork, ForkCondition, Hardfork};
use reth_primitives::{Header, SealedHeader}; use reth_primitives::{Header, SealedHeader};
use std::sync::LazyLock; use std::sync::LazyLock;

2
src/chainspec/parser.rs
View File

@ -1,4 +1,4 @@
use crate::chainspec::{hl::hl_testnet, HlChainSpec}; use crate::chainspec::{HlChainSpec, hl::hl_testnet};
use super::hl::hl_mainnet; use super::hl::hl_mainnet;
use reth_cli::chainspec::ChainSpecParser; use reth_cli::chainspec::ChainSpecParser;

2
src/consensus.rs
View File

@ -1,4 +1,4 @@
use alloy_primitives::{BlockNumber, B256}; use alloy_primitives::{B256, BlockNumber};
use reth_provider::{BlockNumReader, ProviderError}; use reth_provider::{BlockNumReader, ProviderError};
use std::cmp::Ordering; use std::cmp::Ordering;

4
src/evm/api/builder.rs
View File

@ -2,8 +2,8 @@ use super::HlEvmInner;
use crate::evm::{spec::HlSpecId, transaction::HlTxTr}; use crate::evm::{spec::HlSpecId, transaction::HlTxTr};
use reth_revm::context::ContextTr; use reth_revm::context::ContextTr;
use revm::{ use revm::{
context::Cfg, context_interface::Block, handler::instructions::EthInstructions, Context, Database, context::Cfg, context_interface::Block,
interpreter::interpreter::EthInterpreter, Context, Database, handler::instructions::EthInstructions, interpreter::interpreter::EthInterpreter,
}; };
/// Trait that allows for hl HlEvm to be built. /// Trait that allows for hl HlEvm to be built.

2
src/evm/api/ctx.rs
View File

@ -1,8 +1,8 @@
use crate::evm::{spec::HlSpecId, transaction::HlTxEnv}; use crate::evm::{spec::HlSpecId, transaction::HlTxEnv};
use revm::{ use revm::{
Context, Journal, MainContext,
context::{BlockEnv, CfgEnv, TxEnv}, context::{BlockEnv, CfgEnv, TxEnv},
database_interface::EmptyDB, database_interface::EmptyDB,
Context, Journal, MainContext,
}; };
/// Type alias for the default context type of the HlEvm. /// Type alias for the default context type of the HlEvm.

18
src/evm/api/exec.rs
View File

@ -1,16 +1,16 @@
use super::HlEvmInner; use super::HlEvmInner;
use crate::evm::{spec::HlSpecId, transaction::HlTxTr}; use crate::evm::{spec::HlSpecId, transaction::HlTxTr};
use revm::{ use revm::{
context::{result::HaltReason, ContextSetters},
context_interface::{
result::{EVMError, ExecutionResult, ResultAndState},
Cfg, ContextTr, Database, JournalTr,
},
handler::{instructions::EthInstructions, PrecompileProvider},
inspector::{InspectCommitEvm, InspectEvm, Inspector, JournalExt},
interpreter::{interpreter::EthInterpreter, InterpreterResult},
state::EvmState,
DatabaseCommit, ExecuteCommitEvm, ExecuteEvm, DatabaseCommit, ExecuteCommitEvm, ExecuteEvm,
context::{ContextSetters, result::HaltReason},
context_interface::{
Cfg, ContextTr, Database, JournalTr,
result::{EVMError, ExecutionResult, ResultAndState},
},
handler::{PrecompileProvider, instructions::EthInstructions},
inspector::{InspectCommitEvm, InspectEvm, Inspector, JournalExt},
interpreter::{InterpreterResult, interpreter::EthInterpreter},
state::EvmState,
}; };
// Type alias for HL context // Type alias for HL context

6
src/evm/api/mod.rs
View File

@ -1,15 +1,15 @@
use revm::{ use revm::{
Inspector,
bytecode::opcode::BLOCKHASH, bytecode::opcode::BLOCKHASH,
context::{ContextSetters, Evm, FrameStack}, context::{ContextSetters, Evm, FrameStack},
context_interface::ContextTr, context_interface::ContextTr,
handler::{ handler::{
EthFrame, EthPrecompiles, EvmTr, FrameInitOrResult, FrameTr, PrecompileProvider,
evm::{ContextDbError, FrameInitResult}, evm::{ContextDbError, FrameInitResult},
instructions::{EthInstructions, InstructionProvider}, instructions::{EthInstructions, InstructionProvider},
EthFrame, EthPrecompiles, EvmTr, FrameInitOrResult, FrameTr, PrecompileProvider,
}, },
inspector::{InspectorEvmTr, JournalExt}, inspector::{InspectorEvmTr, JournalExt},
interpreter::{interpreter::EthInterpreter, Instruction, InterpreterResult}, interpreter::{Instruction, InterpreterResult, interpreter::EthInterpreter},
Inspector,
}; };
use crate::chainspec::MAINNET_CHAIN_ID; use crate::chainspec::MAINNET_CHAIN_ID;

4
src/evm/api/patch.rs
View File

@ -7,8 +7,8 @@ use alloy_primitives::keccak256;
use revm::{ use revm::{
context::Host, context::Host,
interpreter::{ interpreter::{
as_u64_saturated, interpreter_types::StackTr, popn_top, InstructionContext, InstructionContext, InterpreterTypes, as_u64_saturated, interpreter_types::StackTr,
InterpreterTypes, popn_top,
}, },
primitives::{BLOCK_HASH_HISTORY, U256}, primitives::{BLOCK_HASH_HISTORY, U256},
}; };

2
src/evm/transaction.rs
View File

@ -7,7 +7,7 @@ use reth_primitives_traits::SignerRecoverable;
use revm::{ use revm::{
context::TxEnv, context::TxEnv,
context_interface::transaction::Transaction, context_interface::transaction::Transaction,
primitives::{Address, Bytes, TxKind, B256, U256}, primitives::{Address, B256, Bytes, TxKind, U256},
}; };
#[auto_impl(&, &mut, Box, Arc)] #[auto_impl(&, &mut, Box, Arc)]

2
src/hardforks/hl.rs
View File

@ -2,7 +2,7 @@
use alloy_chains::{Chain, NamedChain}; use alloy_chains::{Chain, NamedChain};
use core::any::Any; use core::any::Any;
use reth_chainspec::ForkCondition; use reth_chainspec::ForkCondition;
use reth_ethereum_forks::{hardfork, ChainHardforks, EthereumHardfork, Hardfork}; use reth_ethereum_forks::{ChainHardforks, EthereumHardfork, Hardfork, hardfork};
hardfork!( hardfork!(
/// The name of a hl hardfork. /// The name of a hl hardfork.

13
src/main.rs
View File

@ -9,12 +9,12 @@ use reth_hl::{
hl_node_compliance::install_hl_node_compliance, hl_node_compliance::install_hl_node_compliance,
tx_forwarder::{self, EthForwarderApiServer}, tx_forwarder::{self, EthForwarderApiServer},
}, },
chainspec::{parser::HlChainSpecParser, HlChainSpec}, chainspec::{HlChainSpec, parser::HlChainSpecParser},
node::{ node::{
HlNode,
cli::{Cli, HlNodeArgs}, cli::{Cli, HlNodeArgs},
rpc::precompile::{HlBlockPrecompileApiServer, HlBlockPrecompileExt}, rpc::precompile::{HlBlockPrecompileApiServer, HlBlockPrecompileExt},
storage::tables::Tables, storage::tables::Tables,
HlNode,
}, },
}; };
use tracing::info; use tracing::info;
@ -27,11 +27,6 @@ static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
fn main() -> eyre::Result<()> { fn main() -> eyre::Result<()> {
reth_cli_util::sigsegv_handler::install(); reth_cli_util::sigsegv_handler::install();
// Enable backtraces unless a RUST_BACKTRACE value has already been explicitly provided.
if std::env::var_os("RUST_BACKTRACE").is_none() {
std::env::set_var("RUST_BACKTRACE", "1");
}
// Initialize custom version metadata before parsing CLI so --version uses reth-hl values // Initialize custom version metadata before parsing CLI so --version uses reth-hl values
reth_hl::version::init_reth_hl_version(); reth_hl::version::init_reth_hl_version();
@ -80,8 +75,8 @@ fn main() -> eyre::Result<()> {
Ok(()) Ok(())
}) })
.apply(|builder| { .apply(|mut builder| {
builder.db().create_tables_for::<Tables>().expect("create tables"); builder.db_mut().create_tables_for::<Tables>().expect("create tables");
builder builder
}) })
.launch() .launch()

16
src/node/cli.rs
View File

@ -1,21 +1,21 @@
use crate::{ use crate::{
chainspec::{parser::HlChainSpecParser, HlChainSpec}, chainspec::{HlChainSpec, parser::HlChainSpecParser},
node::{consensus::HlConsensus, evm::config::HlEvmConfig, storage::tables::Tables, HlNode}, node::{HlNode, consensus::HlConsensus, evm::config::HlEvmConfig, storage::tables::Tables},
pseudo_peer::BlockSourceArgs, pseudo_peer::BlockSourceArgs,
}; };
use clap::{Args, Parser}; use clap::{Args, Parser};
use reth::{ use reth::{
CliRunner,
args::LogArgs, args::LogArgs,
builder::{NodeBuilder, WithLaunchContext}, builder::{NodeBuilder, WithLaunchContext},
cli::Commands, cli::Commands,
prometheus_exporter::install_prometheus_recorder, prometheus_exporter::install_prometheus_recorder,
version::version_metadata, version::version_metadata,
CliRunner,
}; };
use reth_chainspec::EthChainSpec; use reth_chainspec::EthChainSpec;
use reth_cli::chainspec::ChainSpecParser; use reth_cli::chainspec::ChainSpecParser;
use reth_cli_commands::{common::EnvironmentArgs, launcher::FnLauncher}; use reth_cli_commands::{common::EnvironmentArgs, launcher::FnLauncher};
use reth_db::{init_db, mdbx::init_db_for, DatabaseEnv}; use reth_db::{DatabaseEnv, init_db, mdbx::init_db_for};
use reth_tracing::FileWorkerGuard; use reth_tracing::FileWorkerGuard;
use std::{ use std::{
fmt::{self}, fmt::{self},
@ -136,8 +136,9 @@ where
// Install the prometheus recorder to be sure to record all metrics // Install the prometheus recorder to be sure to record all metrics
let _ = install_prometheus_recorder(); let _ = install_prometheus_recorder();
let components = let components = |spec: Arc<C::ChainSpec>| {
|spec: Arc<C::ChainSpec>| (HlEvmConfig::new(spec.clone()), HlConsensus::new(spec)); (HlEvmConfig::new(spec.clone()), Arc::new(HlConsensus::new(spec)))
};
match self.command { match self.command {
Commands::Node(command) => runner.run_command_until_exit(|ctx| { Commands::Node(command) => runner.run_command_until_exit(|ctx| {
@ -157,9 +158,6 @@ where
runner.run_command_until_exit(|ctx| command.execute::<HlNode, _>(ctx, components)) runner.run_command_until_exit(|ctx| command.execute::<HlNode, _>(ctx, components))
} }
Commands::Config(command) => runner.run_until_ctrl_c(command.execute()), Commands::Config(command) => runner.run_until_ctrl_c(command.execute()),
Commands::Recover(command) => {
runner.run_command_until_exit(|ctx| command.execute::<HlNode>(ctx))
}
Commands::Prune(command) => runner.run_until_ctrl_c(command.execute::<HlNode>()), Commands::Prune(command) => runner.run_until_ctrl_c(command.execute::<HlNode>()),
Commands::Import(command) => { Commands::Import(command) => {
runner.run_blocking_until_ctrl_c(command.execute::<HlNode, _>(components)) runner.run_blocking_until_ctrl_c(command.execute::<HlNode, _>(components))

8
src/node/consensus/mod.rs
View File

@ -1,9 +1,9 @@
use crate::{hardforks::HlHardforks, node::HlNode, HlBlock, HlBlockBody, HlPrimitives}; use crate::{HlBlock, HlBlockBody, HlPrimitives, hardforks::HlHardforks, node::HlNode};
use alloy_consensus::Header; use alloy_consensus::Header;
use reth::{ use reth::{
api::FullNodeTypes, api::{FullNodeTypes, NodeTypes},
beacon_consensus::EthBeaconConsensus, beacon_consensus::EthBeaconConsensus,
builder::{components::ConsensusBuilder, BuilderContext}, builder::{BuilderContext, components::ConsensusBuilder},
consensus::{Consensus, ConsensusError, FullConsensus, HeaderValidator}, consensus::{Consensus, ConsensusError, FullConsensus, HeaderValidator},
consensus_common::validation::{ consensus_common::validation::{
validate_against_parent_4844, validate_against_parent_hash_number, validate_against_parent_4844, validate_against_parent_hash_number,
@ -24,7 +24,7 @@ impl<Node> ConsensusBuilder<Node> for HlConsensusBuilder
where where
Node: FullNodeTypes<Types = HlNode>, Node: FullNodeTypes<Types = HlNode>,
{ {
type Consensus = Arc<dyn FullConsensus<HlPrimitives, Error = ConsensusError>>; type Consensus = Arc<HlConsensus<<Node::Types as NodeTypes>::ChainSpec>>;
async fn build_consensus(self, ctx: &BuilderContext<Node>) -> eyre::Result<Self::Consensus> { async fn build_consensus(self, ctx: &BuilderContext<Node>) -> eyre::Result<Self::Consensus> {
Ok(Arc::new(HlConsensus::new(ctx.chain_spec()))) Ok(Arc::new(HlConsensus::new(ctx.chain_spec())))

6
src/node/consensus/reth_copy.rs
View File

@ -1,11 +1,11 @@
//! Copy of reth codebase. //! Copy of reth codebase.
use alloy_consensus::{proofs::calculate_receipt_root, BlockHeader, TxReceipt}; use alloy_consensus::{BlockHeader, TxReceipt, proofs::calculate_receipt_root};
use alloy_eips::eip7685::Requests; use alloy_eips::eip7685::Requests;
use alloy_primitives::{Bloom, B256}; use alloy_primitives::{B256, Bloom};
use reth::consensus::ConsensusError; use reth::consensus::ConsensusError;
use reth_chainspec::EthereumHardforks; use reth_chainspec::EthereumHardforks;
use reth_primitives::{gas_spent_by_transactions, GotExpected, RecoveredBlock}; use reth_primitives::{GotExpected, RecoveredBlock, gas_spent_by_transactions};
use reth_primitives_traits::{Block, Receipt as ReceiptTrait}; use reth_primitives_traits::{Block, Receipt as ReceiptTrait};
pub fn validate_block_post_execution<B, R, ChainSpec>( pub fn validate_block_post_execution<B, R, ChainSpec>(

2
src/node/evm/assembler.rs
View File

@ -1,6 +1,6 @@
use crate::{ use crate::{
node::evm::config::{HlBlockExecutorFactory, HlEvmConfig},
HlBlock, HlBlock,
node::evm::config::{HlBlockExecutorFactory, HlEvmConfig},
}; };
use alloy_consensus::Header; use alloy_consensus::Header;
use reth_evm::{ use reth_evm::{

43
src/node/evm/config.rs
View File

@ -1,5 +1,6 @@
use super::{executor::HlBlockExecutor, factory::HlEvmFactory}; use super::{executor::HlBlockExecutor, factory::HlEvmFactory};
use crate::{ use crate::{
HlBlock, HlBlockBody, HlPrimitives,
chainspec::HlChainSpec, chainspec::HlChainSpec,
evm::{spec::HlSpecId, transaction::HlTxEnv}, evm::{spec::HlSpecId, transaction::HlTxEnv},
hardforks::HlHardforks, hardforks::HlHardforks,
@ -9,31 +10,30 @@ use crate::{
rpc::engine_api::validator::HlExecutionData, rpc::engine_api::validator::HlExecutionData,
types::HlExtras, types::HlExtras,
}, },
HlBlock, HlBlockBody, HlPrimitives,
}; };
use alloy_consensus::{BlockHeader, Header, Transaction as _, TxReceipt, EMPTY_OMMER_ROOT_HASH}; use alloy_consensus::{BlockHeader, EMPTY_OMMER_ROOT_HASH, Header, Transaction as _, TxReceipt};
use alloy_eips::{merge::BEACON_NONCE, Encodable2718}; use alloy_eips::{Encodable2718, merge::BEACON_NONCE};
use alloy_primitives::{Log, U256}; use alloy_primitives::{Log, U256};
use reth_chainspec::{EthChainSpec, EthereumHardforks, Hardforks}; use reth_chainspec::{EthChainSpec, EthereumHardforks, Hardforks};
use reth_evm::{ use reth_evm::{
block::{BlockExecutionError, BlockExecutorFactory, BlockExecutorFor},
eth::{receipt_builder::ReceiptBuilder, EthBlockExecutionCtx},
execute::{BlockAssembler, BlockAssemblerInput},
precompiles::PrecompilesMap,
ConfigureEngineEvm, ConfigureEvm, EvmEnv, EvmEnvFor, EvmFactory, ExecutableTxIterator, ConfigureEngineEvm, ConfigureEvm, EvmEnv, EvmEnvFor, EvmFactory, ExecutableTxIterator,
ExecutionCtxFor, FromRecoveredTx, FromTxWithEncoded, IntoTxEnv, NextBlockEnvAttributes, ExecutionCtxFor, FromRecoveredTx, FromTxWithEncoded, IntoTxEnv, NextBlockEnvAttributes,
block::{BlockExecutionError, BlockExecutorFactory, BlockExecutorFor},
eth::{EthBlockExecutionCtx, receipt_builder::ReceiptBuilder},
execute::{BlockAssembler, BlockAssemblerInput},
precompiles::PrecompilesMap,
}; };
use reth_evm_ethereum::EthBlockAssembler; use reth_evm_ethereum::EthBlockAssembler;
use reth_payload_primitives::NewPayloadError; use reth_payload_primitives::NewPayloadError;
use reth_primitives::{logs_bloom, BlockTy, HeaderTy, Receipt, SealedBlock, SealedHeader}; use reth_primitives::{BlockTy, HeaderTy, Receipt, SealedBlock, SealedHeader, logs_bloom};
use reth_primitives_traits::{proofs, SignerRecoverable, WithEncoded}; use reth_primitives_traits::{SignerRecoverable, WithEncoded, proofs};
use reth_provider::BlockExecutionResult; use reth_provider::BlockExecutionResult;
use reth_revm::State; use reth_revm::State;
use revm::{ use revm::{
Inspector,
context::{BlockEnv, CfgEnv, TxEnv}, context::{BlockEnv, CfgEnv, TxEnv},
context_interface::block::BlobExcessGasAndPrice, context_interface::block::BlobExcessGasAndPrice,
primitives::hardfork::SpecId, primitives::hardfork::SpecId,
Inspector,
}; };
use std::{borrow::Cow, convert::Infallible, sync::Arc}; use std::{borrow::Cow, convert::Infallible, sync::Arc};
@ -106,7 +106,10 @@ where
} else { } else {
// for the first post-fork block, both parent.blob_gas_used and // for the first post-fork block, both parent.blob_gas_used and
// parent.excess_blob_gas are evaluated as 0 // parent.excess_blob_gas are evaluated as 0
Some(alloy_eips::eip7840::BlobParams::cancun().next_block_excess_blob_gas(0, 0)) Some(
alloy_eips::eip7840::BlobParams::cancun()
.next_block_excess_blob_gas_osaka(0, 0, 0),
)
}; };
} }
@ -284,7 +287,7 @@ where
self self
} }
fn evm_env(&self, header: &Header) -> EvmEnv<HlSpecId> { fn evm_env(&self, header: &Header) -> Result<EvmEnv<HlSpecId>, Self::Error> {
let blob_params = self.chain_spec().blob_params_at_timestamp(header.timestamp); let blob_params = self.chain_spec().blob_params_at_timestamp(header.timestamp);
let spec = revm_spec_by_timestamp_and_block_number( let spec = revm_spec_by_timestamp_and_block_number(
self.chain_spec().clone(), self.chain_spec().clone(),
@ -324,7 +327,7 @@ where
blob_excess_gas_and_price, blob_excess_gas_and_price,
}; };
EvmEnv { cfg_env, block_env } Ok(EvmEnv { cfg_env, block_env })
} }
fn next_evm_env( fn next_evm_env(
@ -373,9 +376,9 @@ where
fn context_for_block<'a>( fn context_for_block<'a>(
&self, &self,
block: &'a SealedBlock<BlockTy<Self::Primitives>>, block: &'a SealedBlock<BlockTy<Self::Primitives>>,
) -> ExecutionCtxFor<'a, Self> { ) -> Result<ExecutionCtxFor<'a, Self>, Self::Error> {
let block_body = block.body(); let block_body = block.body();
HlBlockExecutionCtx { Ok(HlBlockExecutionCtx {
ctx: EthBlockExecutionCtx { ctx: EthBlockExecutionCtx {
parent_hash: block.header().parent_hash, parent_hash: block.header().parent_hash,
parent_beacon_block_root: block.header().parent_beacon_block_root, parent_beacon_block_root: block.header().parent_beacon_block_root,
@ -386,15 +389,15 @@ where
read_precompile_calls: block_body.read_precompile_calls.clone(), read_precompile_calls: block_body.read_precompile_calls.clone(),
highest_precompile_address: block_body.highest_precompile_address, highest_precompile_address: block_body.highest_precompile_address,
}, },
} })
} }
fn context_for_next_block( fn context_for_next_block(
&self, &self,
parent: &SealedHeader<HeaderTy<Self::Primitives>>, parent: &SealedHeader<HeaderTy<Self::Primitives>>,
attributes: Self::NextBlockEnvCtx, attributes: Self::NextBlockEnvCtx,
) -> ExecutionCtxFor<'_, Self> { ) -> Result<ExecutionCtxFor<'_, Self>, Self::Error> {
HlBlockExecutionCtx { Ok(HlBlockExecutionCtx {
ctx: EthBlockExecutionCtx { ctx: EthBlockExecutionCtx {
parent_hash: parent.hash(), parent_hash: parent.hash(),
parent_beacon_block_root: attributes.parent_beacon_block_root, parent_beacon_block_root: attributes.parent_beacon_block_root,
@ -402,13 +405,13 @@ where
withdrawals: attributes.withdrawals.map(Cow::Owned), withdrawals: attributes.withdrawals.map(Cow::Owned),
}, },
extras: HlExtras::default(), // TODO: hacky, double check if this is correct extras: HlExtras::default(), // TODO: hacky, double check if this is correct
} })
} }
} }
impl ConfigureEngineEvm<HlExecutionData> for HlEvmConfig { impl ConfigureEngineEvm<HlExecutionData> for HlEvmConfig {
fn evm_env_for_payload(&self, payload: &HlExecutionData) -> EvmEnvFor<Self> { fn evm_env_for_payload(&self, payload: &HlExecutionData) -> EvmEnvFor<Self> {
self.evm_env(&payload.0.header) self.evm_env(&payload.0.header).unwrap()
} }
fn context_for_payload<'a>(&self, payload: &'a HlExecutionData) -> ExecutionCtxFor<'a, Self> { fn context_for_payload<'a>(&self, payload: &'a HlExecutionData) -> ExecutionCtxFor<'a, Self> {

46
src/node/evm/executor.rs
View File

@ -8,29 +8,26 @@ use crate::{
}, },
}; };
use alloy_consensus::{Transaction, TxReceipt}; use alloy_consensus::{Transaction, TxReceipt};
use alloy_eips::{eip7685::Requests, Encodable2718}; use alloy_eips::{Encodable2718, eip7685::Requests};
use alloy_evm::{block::ExecutableTx, eth::receipt_builder::ReceiptBuilderCtx}; use alloy_evm::{block::ExecutableTx, eth::receipt_builder::ReceiptBuilderCtx};
use alloy_primitives::{address, hex, Address, Bytes, U160, U256}; use alloy_primitives::{Address, Bytes, U160, U256, address, hex};
use reth_chainspec::{EthChainSpec, EthereumHardforks, Hardforks}; use reth_chainspec::{EthChainSpec, EthereumHardforks, Hardforks};
use reth_evm::{ use reth_evm::{
block::{BlockValidationError, CommitChanges}, Database, Evm, FromRecoveredTx, FromTxWithEncoded, IntoTxEnv, OnStateHook,
block::BlockValidationError,
eth::receipt_builder::ReceiptBuilder, eth::receipt_builder::ReceiptBuilder,
execute::{BlockExecutionError, BlockExecutor}, execute::{BlockExecutionError, BlockExecutor},
precompiles::{DynPrecompile, PrecompileInput, PrecompilesMap}, precompiles::{DynPrecompile, PrecompileInput, PrecompilesMap},
Database, Evm, FromRecoveredTx, FromTxWithEncoded, IntoTxEnv, OnStateHook,
}; };
use reth_provider::BlockExecutionResult; use reth_provider::BlockExecutionResult;
use reth_revm::State; use reth_revm::State;
use revm::{ use revm::{
context::{ DatabaseCommit,
result::{ExecutionResult, ResultAndState}, context::{TxEnv, result::ResultAndState},
TxEnv,
},
interpreter::instructions::utility::IntoU256, interpreter::instructions::utility::IntoU256,
precompile::{PrecompileError, PrecompileOutput, PrecompileResult}, precompile::{PrecompileError, PrecompileOutput, PrecompileResult},
primitives::HashMap, primitives::HashMap,
state::Bytecode, state::Bytecode,
DatabaseCommit,
}; };
pub fn is_system_transaction(tx: &TransactionSigned) -> bool { pub fn is_system_transaction(tx: &TransactionSigned) -> bool {
@ -110,7 +107,9 @@ where
const COREWRITER_ENABLED_BLOCK_NUMBER: u64 = 7578300; const COREWRITER_ENABLED_BLOCK_NUMBER: u64 = 7578300;
const COREWRITER_CONTRACT_ADDRESS: Address = const COREWRITER_CONTRACT_ADDRESS: Address =
address!("0x3333333333333333333333333333333333333333"); address!("0x3333333333333333333333333333333333333333");
const COREWRITER_CODE: &[u8] = &hex!("608060405234801561000f575f5ffd5b5060043610610029575f3560e01c806317938e131461002d575b5f5ffd5b61004760048036038101906100429190610123565b610049565b005b5f5f90505b61019081101561006557808060010191505061004e565b503373ffffffffffffffffffffffffffffffffffffffff167f8c7f585fb295f7eb1e6aeb8fba61b23a4fe60beda405f0045073b185c74412e383836040516100ae9291906101c8565b60405180910390a25050565b5f5ffd5b5f5ffd5b5f5ffd5b5f5ffd5b5f5ffd5b5f5f83601f8401126100e3576100e26100c2565b5b8235905067ffffffffffffffff811115610100576100ff6100c6565b5b60208301915083600182028301111561011c5761011b6100ca565b5b9250929050565b5f5f60208385031215610139576101386100ba565b5b5f83013567ffffffffffffffff811115610156576101556100be565b5b610162858286016100ce565b92509250509250929050565b5f82825260208201905092915050565b828183375f83830152505050565b5f601f19601f8301169050919050565b5f6101a7838561016e565b93506101b483858461017e565b6101bd8361018c565b840190509392505050565b5f6020820190508181035f8301526101e181848661019c565b9050939250505056fea2646970667358221220f01517e1fbaff8af4bd72cb063cccecbacbb00b07354eea7dd52265d355474fb64736f6c634300081c0033"); const COREWRITER_CODE: &[u8] = &hex!(
"608060405234801561000f575f5ffd5b5060043610610029575f3560e01c806317938e131461002d575b5f5ffd5b61004760048036038101906100429190610123565b610049565b005b5f5f90505b61019081101561006557808060010191505061004e565b503373ffffffffffffffffffffffffffffffffffffffff167f8c7f585fb295f7eb1e6aeb8fba61b23a4fe60beda405f0045073b185c74412e383836040516100ae9291906101c8565b60405180910390a25050565b5f5ffd5b5f5ffd5b5f5ffd5b5f5ffd5b5f5ffd5b5f5f83601f8401126100e3576100e26100c2565b5b8235905067ffffffffffffffff811115610100576100ff6100c6565b5b60208301915083600182028301111561011c5761011b6100ca565b5b9250929050565b5f5f60208385031215610139576101386100ba565b5b5f83013567ffffffffffffffff811115610156576101556100be565b5b610162858286016100ce565b92509250509250929050565b5f82825260208201905092915050565b828183375f83830152505050565b5f601f19601f8301169050919050565b5f6101a7838561016e565b93506101b483858461017e565b6101bd8361018c565b840190509392505050565b5f6020820190508181035f8301526101e181848661019c565b9050939250505056fea2646970667358221220f01517e1fbaff8af4bd72cb063cccecbacbb00b07354eea7dd52265d355474fb64736f6c634300081c0033"
);
if self.evm.block().number != U256::from(COREWRITER_ENABLED_BLOCK_NUMBER) { if self.evm.block().number != U256::from(COREWRITER_ENABLED_BLOCK_NUMBER) {
return Ok(()); return Ok(());
@ -161,11 +160,10 @@ where
Ok(()) Ok(())
} }
fn execute_transaction_with_commit_condition( fn execute_transaction_without_commit(
&mut self, &mut self,
tx: impl ExecutableTx<Self>, tx: impl ExecutableTx<Self>,
f: impl FnOnce(&ExecutionResult<<Self::Evm as Evm>::HaltReason>) -> CommitChanges, ) -> Result<ResultAndState<<Self::Evm as Evm>::HaltReason>, BlockExecutionError> {
) -> Result<Option<u64>, BlockExecutionError> {
// The sum of the transaction's gas limit, Tg, and the gas utilized in this block prior, // The sum of the transaction's gas limit, Tg, and the gas utilized in this block prior,
// must be no greater than the block's gasLimit. // must be no greater than the block's gasLimit.
let block_available_gas = self.evm.block().gas_limit - self.gas_used; let block_available_gas = self.evm.block().gas_limit - self.gas_used;
@ -178,16 +176,20 @@ where
.into()); .into());
} }
// Execute transaction. // Execute transaction and return the result
let ResultAndState { result, mut state } = self self.evm.transact(&tx).map_err(|err| {
.evm let hash = tx.tx().trie_hash();
.transact(&tx) BlockExecutionError::evm(err, hash)
.map_err(|err| BlockExecutionError::evm(err, tx.tx().trie_hash()))?; })
if !f(&result).should_commit() {
return Ok(None);
} }
fn commit_transaction(
&mut self,
output: ResultAndState<<Self::Evm as Evm>::HaltReason>,
tx: impl ExecutableTx<Self>,
) -> Result<u64, BlockExecutionError> {
let ResultAndState { result, mut state } = output;
let gas_used = result.gas_used(); let gas_used = result.gas_used();
// append gas used // append gas used
@ -215,7 +217,7 @@ where
// Commit the state changes. // Commit the state changes.
self.evm.db_mut().commit(state); self.evm.db_mut().commit(state);
Ok(Some(gas_used)) Ok(gas_used)
} }
fn finish(self) -> Result<(Self::Evm, BlockExecutionResult<R::Receipt>), BlockExecutionError> { fn finish(self) -> Result<(Self::Evm, BlockExecutionResult<R::Receipt>), BlockExecutionError> {

6
src/node/evm/factory.rs
View File

@ -7,16 +7,16 @@ use crate::evm::{
spec::HlSpecId, spec::HlSpecId,
transaction::HlTxEnv, transaction::HlTxEnv,
}; };
use reth_evm::{precompiles::PrecompilesMap, Database, EvmEnv, EvmFactory}; use reth_evm::{Database, EvmEnv, EvmFactory, precompiles::PrecompilesMap};
use reth_revm::Context; use reth_revm::Context;
use revm::{ use revm::{
Inspector,
context::{ context::{
result::{EVMError, HaltReason},
TxEnv, TxEnv,
result::{EVMError, HaltReason},
}, },
inspector::NoOpInspector, inspector::NoOpInspector,
precompile::{PrecompileSpecId, Precompiles}, precompile::{PrecompileSpecId, Precompiles},
Inspector,
}; };
/// Factory producing [`HlEvm`]. /// Factory producing [`HlEvm`].

24
src/node/evm/mod.rs
View File

@ -1,6 +1,6 @@
use crate::{ use crate::{
evm::{ evm::{
api::{ctx::HlContext, HlEvmInner}, api::{HlEvmInner, ctx::HlContext},
spec::HlSpecId, spec::HlSpecId,
transaction::HlTxEnv, transaction::HlTxEnv,
}, },
@ -10,18 +10,18 @@ use alloy_primitives::{Address, Bytes};
use config::HlEvmConfig; use config::HlEvmConfig;
use reth::{ use reth::{
api::FullNodeTypes, api::FullNodeTypes,
builder::{components::ExecutorBuilder, BuilderContext}, builder::{BuilderContext, components::ExecutorBuilder},
}; };
use reth_evm::{Database, Evm, EvmEnv}; use reth_evm::{Database, Evm, EvmEnv};
use revm::{ use revm::{
context::{
result::{EVMError, ExecutionResult, HaltReason, Output, ResultAndState, SuccessReason},
BlockEnv, TxEnv,
},
handler::{instructions::EthInstructions, EthPrecompiles, PrecompileProvider},
interpreter::{interpreter::EthInterpreter, InterpreterResult},
state::EvmState,
Context, ExecuteEvm, InspectEvm, Inspector, Context, ExecuteEvm, InspectEvm, Inspector,
context::{
BlockEnv, TxEnv,
result::{EVMError, ExecutionResult, HaltReason, Output, ResultAndState, SuccessReason},
},
handler::{EthPrecompiles, PrecompileProvider, instructions::EthInstructions},
interpreter::{InterpreterResult, interpreter::EthInterpreter},
state::EvmState,
}; };
use std::ops::{Deref, DerefMut}; use std::ops::{Deref, DerefMut};
@ -98,11 +98,7 @@ where
&mut self, &mut self,
tx: Self::Tx, tx: Self::Tx,
) -> Result<ResultAndState<Self::HaltReason>, Self::Error> { ) -> Result<ResultAndState<Self::HaltReason>, Self::Error> {
if self.inspect { if self.inspect { self.inner.inspect_tx(tx) } else { self.inner.transact(tx) }
self.inner.inspect_tx(tx)
} else {
self.inner.transact(tx)
}
} }
fn transact_system_call( fn transact_system_call(

2
src/node/evm/patch.rs
View File

@ -1,4 +1,4 @@
use alloy_primitives::{address, Address}; use alloy_primitives::{Address, address};
use reth_evm::block::BlockExecutionError; use reth_evm::block::BlockExecutionError;
use revm::{primitives::HashMap, state::Account}; use revm::{primitives::HashMap, state::Account};

6
src/node/mod.rs
View File

@ -4,11 +4,11 @@ use crate::{
pool::HlPoolBuilder, pool::HlPoolBuilder,
primitives::{HlBlock, HlPrimitives}, primitives::{HlBlock, HlPrimitives},
rpc::{ rpc::{
HlEthApiBuilder,
engine_api::{ engine_api::{
builder::HlEngineApiBuilder, payload::HlPayloadTypes, builder::HlEngineApiBuilder, payload::HlPayloadTypes,
validator::HlPayloadValidatorBuilder, validator::HlPayloadValidatorBuilder,
}, },
HlEthApiBuilder,
}, },
storage::HlStorage, storage::HlStorage,
}, },
@ -20,14 +20,14 @@ use network::HlNetworkBuilder;
use reth::{ use reth::{
api::{FullNodeTypes, NodeTypes}, api::{FullNodeTypes, NodeTypes},
builder::{ builder::{
Node, NodeAdapter,
components::{ComponentsBuilder, NoopPayloadServiceBuilder}, components::{ComponentsBuilder, NoopPayloadServiceBuilder},
rpc::RpcAddOns, rpc::RpcAddOns,
Node, NodeAdapter,
}, },
}; };
use reth_engine_primitives::ConsensusEngineHandle; use reth_engine_primitives::ConsensusEngineHandle;
use std::{marker::PhantomData, sync::Arc}; use std::{marker::PhantomData, sync::Arc};
use tokio::sync::{oneshot, Mutex}; use tokio::sync::{Mutex, oneshot};
pub mod cli; pub mod cli;
pub mod consensus; pub mod consensus;

2
src/node/network/block_import/mod.rs
View File

@ -8,7 +8,7 @@ use reth_primitives::NodePrimitives;
use service::{BlockMsg, ImportEvent, Outcome}; use service::{BlockMsg, ImportEvent, Outcome};
use std::{ use std::{
fmt, fmt,
task::{ready, Context, Poll}, task::{Context, Poll, ready},
}; };
use crate::node::network::HlNewBlock; use crate::node::network::HlNewBlock;

4
src/node/network/block_import/service.rs
View File

@ -1,17 +1,17 @@
use super::handle::ImportHandle; use super::handle::ImportHandle;
use crate::{ use crate::{
HlBlock, HlBlockBody,
consensus::HlConsensus, consensus::HlConsensus,
node::{ node::{
network::HlNewBlock, network::HlNewBlock,
rpc::engine_api::payload::HlPayloadTypes, rpc::engine_api::payload::HlPayloadTypes,
types::{BlockAndReceipts, EvmBlock}, types::{BlockAndReceipts, EvmBlock},
}, },
HlBlock, HlBlockBody,
}; };
use alloy_consensus::{BlockBody, Header}; use alloy_consensus::{BlockBody, Header};
use alloy_primitives::U128; use alloy_primitives::U128;
use alloy_rpc_types::engine::{ForkchoiceState, PayloadStatusEnum}; use alloy_rpc_types::engine::{ForkchoiceState, PayloadStatusEnum};
use futures::{future::Either, stream::FuturesUnordered, StreamExt}; use futures::{StreamExt, future::Either, stream::FuturesUnordered};
use reth_engine_primitives::{ConsensusEngineHandle, EngineTypes}; use reth_engine_primitives::{ConsensusEngineHandle, EngineTypes};
use reth_eth_wire::NewBlock; use reth_eth_wire::NewBlock;
use reth_network::{ use reth_network::{

14
src/node/network/mod.rs
View File

@ -1,20 +1,20 @@
#![allow(clippy::owned_cow)] #![allow(clippy::owned_cow)]
use crate::{ use crate::{
HlBlock,
consensus::HlConsensus, consensus::HlConsensus,
node::{ node::{
network::block_import::{handle::ImportHandle, service::ImportService, HlBlockImport}, HlNode,
network::block_import::{HlBlockImport, handle::ImportHandle, service::ImportService},
primitives::HlPrimitives, primitives::HlPrimitives,
rpc::engine_api::payload::HlPayloadTypes, rpc::engine_api::payload::HlPayloadTypes,
types::ReadPrecompileCalls, types::ReadPrecompileCalls,
HlNode,
}, },
pseudo_peer::{start_pseudo_peer, BlockSourceConfig}, pseudo_peer::{BlockSourceConfig, start_pseudo_peer},
HlBlock,
}; };
use alloy_rlp::{Decodable, Encodable}; use alloy_rlp::{Decodable, Encodable};
use reth::{ use reth::{
api::{FullNodeTypes, TxTy}, api::{FullNodeTypes, TxTy},
builder::{components::NetworkBuilder, BuilderContext}, builder::{BuilderContext, components::NetworkBuilder},
transaction_pool::{PoolTransaction, TransactionPool}, transaction_pool::{PoolTransaction, TransactionPool},
}; };
use reth_discv4::NodeRecord; use reth_discv4::NodeRecord;
@ -26,7 +26,7 @@ use reth_network_api::PeersInfo;
use reth_provider::StageCheckpointReader; use reth_provider::StageCheckpointReader;
use reth_stages_types::StageId; use reth_stages_types::StageId;
use std::sync::Arc; use std::sync::Arc;
use tokio::sync::{mpsc, oneshot, Mutex}; use tokio::sync::{Mutex, mpsc, oneshot};
use tracing::info; use tracing::info;
pub mod block_import; pub mod block_import;
@ -38,8 +38,8 @@ pub struct HlNewBlock(pub NewBlock<HlBlock>);
mod rlp { mod rlp {
use super::*; use super::*;
use crate::{ use crate::{
node::primitives::{BlockBody, TransactionSigned},
HlBlockBody, HlBlockBody,
node::primitives::{BlockBody, TransactionSigned},
}; };
use alloy_consensus::{BlobTransactionSidecar, Header}; use alloy_consensus::{BlobTransactionSidecar, Header};
use alloy_primitives::{Address, U128}; use alloy_primitives::{Address, U128};

10
src/node/pool.rs
View File

@ -6,12 +6,12 @@
//! Ethereum transaction pool only supports TransactionSigned (EthereumTxEnvelope<TxEip4844>), //! Ethereum transaction pool only supports TransactionSigned (EthereumTxEnvelope<TxEip4844>),
//! hence this placeholder for the transaction pool. //! hence this placeholder for the transaction pool.
use crate::node::{primitives::TransactionSigned, HlNode}; use crate::node::{HlNode, primitives::TransactionSigned};
use alloy_consensus::{ use alloy_consensus::{
error::ValueError, EthereumTxEnvelope, Transaction as TransactionTrait, TxEip4844, EthereumTxEnvelope, Transaction as TransactionTrait, TxEip4844, error::ValueError,
}; };
use alloy_eips::{eip7702::SignedAuthorization, Typed2718}; use alloy_eips::{Typed2718, eip7702::SignedAuthorization};
use alloy_primitives::{Address, Bytes, ChainId, TxHash, TxKind, B256, U256}; use alloy_primitives::{Address, B256, Bytes, ChainId, TxHash, TxKind, U256};
use alloy_rpc_types::AccessList; use alloy_rpc_types::AccessList;
use reth::{ use reth::{
api::FullNodeTypes, builder::components::PoolBuilder, transaction_pool::PoolTransaction, api::FullNodeTypes, builder::components::PoolBuilder, transaction_pool::PoolTransaction,
@ -19,7 +19,7 @@ use reth::{
use reth_ethereum_primitives::PooledTransactionVariant; use reth_ethereum_primitives::PooledTransactionVariant;
use reth_primitives::Recovered; use reth_primitives::Recovered;
use reth_primitives_traits::InMemorySize; use reth_primitives_traits::InMemorySize;
use reth_transaction_pool::{noop::NoopTransactionPool, EthPoolTransaction}; use reth_transaction_pool::{EthPoolTransaction, noop::NoopTransactionPool};
use std::sync::Arc; use std::sync::Arc;
pub struct HlPoolBuilder; pub struct HlPoolBuilder;

40
src/node/primitives/tx_wrapper.rs
View File

@ -1,30 +1,32 @@
//! HlNodePrimitives::TransactionSigned; it's the same as ethereum transaction type, //! HlNodePrimitives::TransactionSigned; it's the same as ethereum transaction type,
//! except that it supports pseudo signer for system transactions. //! except that it supports pseudo signer for system transactions.
use std::convert::Infallible;
use crate::evm::transaction::HlTxEnv; use crate::evm::transaction::HlTxEnv;
use alloy_consensus::{ use alloy_consensus::{
crypto::RecoveryError, error::ValueError, SignableTransaction, Signed, SignableTransaction, Signed, Transaction as TransactionTrait, TransactionEnvelope, TxEip1559,
Transaction as TransactionTrait, TransactionEnvelope, TxEip1559, TxEip2930, TxEip4844, TxEip2930, TxEip4844, TxEip7702, TxLegacy, TxType, TypedTransaction, crypto::RecoveryError,
TxEip7702, TxLegacy, TxType, TypedTransaction, error::ValueError, transaction::TxHashRef,
}; };
use alloy_eips::Encodable2718; use alloy_eips::Encodable2718;
use alloy_network::TxSigner; use alloy_network::TxSigner;
use alloy_primitives::{address, Address, TxHash, U256}; use alloy_primitives::{Address, TxHash, U256, address};
use alloy_rpc_types::{Transaction, TransactionInfo, TransactionRequest}; use alloy_rpc_types::{Transaction, TransactionInfo, TransactionRequest};
use alloy_signer::Signature; use alloy_signer::Signature;
use reth_codecs::alloy::transaction::{Envelope, FromTxCompact}; use reth_codecs::alloy::transaction::{Envelope, FromTxCompact};
use reth_db::{ use reth_db::{
table::{Compress, Decompress},
DatabaseError, DatabaseError,
table::{Compress, Decompress},
}; };
use reth_ethereum_primitives::PooledTransactionVariant; use reth_ethereum_primitives::PooledTransactionVariant;
use reth_evm::FromRecoveredTx; use reth_evm::FromRecoveredTx;
use reth_primitives::Recovered; use reth_primitives::Recovered;
use reth_primitives_traits::{ use reth_primitives_traits::{
serde_bincode_compat::SerdeBincodeCompat, InMemorySize, SignedTransaction, SignerRecoverable, InMemorySize, SignedTransaction, SignerRecoverable, serde_bincode_compat::SerdeBincodeCompat,
}; };
use reth_rpc_eth_api::{ use reth_rpc_eth_api::{
transaction::{FromConsensusTx, TryIntoTxEnv},
EthTxEnvError, SignTxRequestError, SignableTxRequest, TryIntoSimTx, EthTxEnvError, SignTxRequestError, SignableTxRequest, TryIntoSimTx,
transaction::{FromConsensusTx, TryIntoTxEnv},
}; };
use revm::context::{BlockEnv, CfgEnv, TxEnv}; use revm::context::{BlockEnv, CfgEnv, TxEnv};
@ -46,6 +48,12 @@ fn s_to_address(s: U256) -> Address {
Address::from_slice(&buf) Address::from_slice(&buf)
} }
impl TxHashRef for TransactionSigned {
fn tx_hash(&self) -> &TxHash {
self.inner().tx_hash()
}
}
impl SignerRecoverable for TransactionSigned { impl SignerRecoverable for TransactionSigned {
fn recover_signer(&self) -> Result<Address, RecoveryError> { fn recover_signer(&self) -> Result<Address, RecoveryError> {
if self.is_system_transaction() { if self.is_system_transaction() {
@ -69,11 +77,7 @@ impl SignerRecoverable for TransactionSigned {
} }
} }
impl SignedTransaction for TransactionSigned { impl SignedTransaction for TransactionSigned {}
fn tx_hash(&self) -> &TxHash {
self.inner().tx_hash()
}
}
// ------------------------------------------------------------ // ------------------------------------------------------------
// NOTE: All lines below are just wrappers for the inner type. // NOTE: All lines below are just wrappers for the inner type.
@ -250,9 +254,17 @@ impl TryIntoTxEnv<HlTxEnv<TxEnv>> for TransactionRequest {
impl FromConsensusTx<TransactionSigned> for Transaction { impl FromConsensusTx<TransactionSigned> for Transaction {
type TxInfo = TransactionInfo; type TxInfo = TransactionInfo;
type Err = Infallible;
fn from_consensus_tx(tx: TransactionSigned, signer: Address, tx_info: Self::TxInfo) -> Self { fn from_consensus_tx(
Self::from_transaction(Recovered::new_unchecked(tx.into_inner().into(), signer), tx_info) tx: TransactionSigned,
signer: Address,
tx_info: Self::TxInfo,
) -> Result<Self, Self::Err> {
Ok(Self::from_transaction(
Recovered::new_unchecked(tx.into_inner().into(), signer),
tx_info,
))
} }
} }

11
src/node/rpc/block.rs
View File

@ -1,12 +1,12 @@
use crate::node::rpc::{HlEthApi, HlRpcNodeCore}; use crate::node::rpc::{HlEthApi, HlRpcNodeCore};
use reth::rpc::server_types::eth::{ use reth::rpc::server_types::eth::{
builder::config::PendingBlockKind, error::FromEvmError, EthApiError, PendingBlock, EthApiError, PendingBlock, builder::config::PendingBlockKind, error::FromEvmError,
}; };
use reth_rpc_eth_api::{ use reth_rpc_eth_api::{
helpers::{
pending_block::PendingEnvBuilder, EthBlocks, LoadBlock, LoadPendingBlock, LoadReceipt,
},
RpcConvert, RpcConvert,
helpers::{
EthBlocks, LoadBlock, LoadPendingBlock, LoadReceipt, pending_block::PendingEnvBuilder,
},
}; };
impl<N, Rpc> EthBlocks for HlEthApi<N, Rpc> impl<N, Rpc> EthBlocks for HlEthApi<N, Rpc>
@ -29,7 +29,7 @@ impl<N, Rpc> LoadPendingBlock for HlEthApi<N, Rpc>
where where
N: HlRpcNodeCore, N: HlRpcNodeCore,
EthApiError: FromEvmError<N::Evm>, EthApiError: FromEvmError<N::Evm>,
Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>, Rpc: RpcConvert<Primitives = N::Primitives>,
{ {
#[inline] #[inline]
fn pending_block(&self) -> &tokio::sync::Mutex<Option<PendingBlock<N::Primitives>>> { fn pending_block(&self) -> &tokio::sync::Mutex<Option<PendingBlock<N::Primitives>>> {
@ -50,7 +50,6 @@ where
impl<N, Rpc> LoadReceipt for HlEthApi<N, Rpc> impl<N, Rpc> LoadReceipt for HlEthApi<N, Rpc>
where where
N: HlRpcNodeCore, N: HlRpcNodeCore,
EthApiError: FromEvmError<N::Evm>,
Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>, Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
{ {
} }

8
src/node/rpc/call.rs
View File

@ -1,19 +1,19 @@
use core::fmt; use core::fmt;
use super::{HlEthApi, HlRpcNodeCore}; use super::{HlEthApi, HlRpcNodeCore};
use crate::{node::evm::apply_precompiles, HlBlock}; use crate::{HlBlock, node::evm::apply_precompiles};
use alloy_consensus::transaction::TxHashRef;
use alloy_evm::Evm; use alloy_evm::Evm;
use alloy_primitives::B256; use alloy_primitives::B256;
use reth::rpc::server_types::eth::EthApiError; use reth::rpc::server_types::eth::EthApiError;
use reth_evm::{ConfigureEvm, Database, EvmEnvFor, HaltReasonFor, InspectorFor, SpecFor, TxEnvFor}; use reth_evm::{ConfigureEvm, Database, EvmEnvFor, HaltReasonFor, InspectorFor, SpecFor, TxEnvFor};
use reth_primitives::{NodePrimitives, Recovered}; use reth_primitives::{NodePrimitives, Recovered};
use reth_primitives_traits::SignedTransaction;
use reth_provider::{ProviderError, ProviderTx}; use reth_provider::{ProviderError, ProviderTx};
use reth_rpc_eth_api::{ use reth_rpc_eth_api::{
helpers::{Call, EthCall},
FromEvmError, RpcConvert, RpcNodeCore, FromEvmError, RpcConvert, RpcNodeCore,
helpers::{Call, EthCall},
}; };
use revm::{context::result::ResultAndState, DatabaseCommit}; use revm::{DatabaseCommit, context::result::ResultAndState};
impl<N> HlRpcNodeCore for N where N: RpcNodeCore<Primitives: NodePrimitives<Block = HlBlock>> {} impl<N> HlRpcNodeCore for N where N: RpcNodeCore<Primitives: NodePrimitives<Block = HlBlock>> {}

2
src/node/rpc/engine_api/validator.rs
View File

@ -9,7 +9,7 @@ use alloy_primitives::B256;
use alloy_rpc_types_engine::PayloadError; use alloy_rpc_types_engine::PayloadError;
use reth::{ use reth::{
api::{FullNodeComponents, NodeTypes}, api::{FullNodeComponents, NodeTypes},
builder::{rpc::PayloadValidatorBuilder, AddOnsContext}, builder::{AddOnsContext, rpc::PayloadValidatorBuilder},
}; };
use reth_engine_primitives::{ExecutionPayload, PayloadValidator}; use reth_engine_primitives::{ExecutionPayload, PayloadValidator};
use reth_payload_primitives::NewPayloadError; use reth_payload_primitives::NewPayloadError;

29
src/node/rpc/estimate.rs
View File

@ -1,5 +1,5 @@
use super::{apply_precompiles, HlEthApi, HlRpcNodeCore}; use super::{HlEthApi, HlRpcNodeCore, apply_precompiles};
use alloy_evm::overrides::{apply_state_overrides, StateOverrideError}; use alloy_evm::overrides::{StateOverrideError, apply_state_overrides};
use alloy_network::TransactionBuilder; use alloy_network::TransactionBuilder;
use alloy_primitives::{TxKind, U256}; use alloy_primitives::{TxKind, U256};
use alloy_rpc_types_eth::state::StateOverride; use alloy_rpc_types_eth::state::StateOverride;
@ -9,19 +9,19 @@ use reth_evm::{ConfigureEvm, Evm, EvmEnvFor, SpecFor, TransactionEnv, TxEnvFor};
use reth_revm::{database::StateProviderDatabase, db::CacheDB}; use reth_revm::{database::StateProviderDatabase, db::CacheDB};
use reth_rpc_convert::{RpcConvert, RpcTxReq}; use reth_rpc_convert::{RpcConvert, RpcTxReq};
use reth_rpc_eth_api::{ use reth_rpc_eth_api::{
helpers::{
estimate::{update_estimated_gas_range, EstimateCall},
Call,
},
AsEthApiError, IntoEthApiError, RpcNodeCore, AsEthApiError, IntoEthApiError, RpcNodeCore,
helpers::{
Call,
estimate::{EstimateCall, update_estimated_gas_range},
},
}; };
use reth_rpc_eth_types::{ use reth_rpc_eth_types::{
error::{api::FromEvmHalt, FromEvmError},
EthApiError, RevertError, RpcInvalidTransactionError, EthApiError, RevertError, RpcInvalidTransactionError,
error::{FromEvmError, api::FromEvmHalt},
}; };
use reth_rpc_server_types::constants::gas_oracle::{CALL_STIPEND_GAS, ESTIMATE_GAS_ERROR_RATIO}; use reth_rpc_server_types::constants::gas_oracle::{CALL_STIPEND_GAS, ESTIMATE_GAS_ERROR_RATIO};
use reth_storage_api::StateProvider; use reth_storage_api::StateProvider;
use revm::context_interface::{result::ExecutionResult, Transaction}; use revm::context_interface::{Transaction, result::ExecutionResult};
use tracing::trace; use tracing::trace;
impl<N, Rpc> EstimateCall for HlEthApi<N, Rpc> impl<N, Rpc> EstimateCall for HlEthApi<N, Rpc>
@ -82,13 +82,11 @@ where
let mut tx_env = self.create_txn_env(&evm_env, request, &mut db)?; let mut tx_env = self.create_txn_env(&evm_env, request, &mut db)?;
let mut is_basic_transfer = false; let mut is_basic_transfer = false;
if tx_env.input().is_empty() { if tx_env.input().is_empty()
if let TxKind::Call(to) = tx_env.kind() { && let TxKind::Call(to) = tx_env.kind()
if let Ok(code) = db.db.account_code(&to) { && let Ok(code) = db.db.account_code(&to) {
is_basic_transfer = code.map(|code| code.is_empty()).unwrap_or(true); is_basic_transfer = code.map(|code| code.is_empty()).unwrap_or(true);
} }
}
}
if tx_env.gas_price() > 0 { if tx_env.gas_price() > 0 {
highest_gas_limit = highest_gas_limit =
@ -107,12 +105,11 @@ where
let mut min_tx_env = tx_env.clone(); let mut min_tx_env = tx_env.clone();
min_tx_env.set_gas_limit(MIN_TRANSACTION_GAS); min_tx_env.set_gas_limit(MIN_TRANSACTION_GAS);
if let Ok(res) = evm.transact(min_tx_env).map_err(Self::Error::from_evm_err) { if let Ok(res) = evm.transact(min_tx_env).map_err(Self::Error::from_evm_err)
if res.result.is_success() { && res.result.is_success() {
return Ok(U256::from(MIN_TRANSACTION_GAS)); return Ok(U256::from(MIN_TRANSACTION_GAS));
} }
} }
}
trace!(target: "rpc::eth::estimate", ?tx_env, gas_limit = tx_env.gas_limit(), is_basic_transfer, "Starting gas estimation"); trace!(target: "rpc::eth::estimate", ?tx_env, gas_limit = tx_env.gas_limit(), is_basic_transfer, "Starting gas estimation");

31
src/node/rpc/mod.rs
View File

@ -1,7 +1,7 @@
use crate::{ use crate::{
HlBlock, HlPrimitives,
chainspec::HlChainSpec, chainspec::HlChainSpec,
node::{evm::apply_precompiles, types::HlExtras}, node::{evm::apply_precompiles, types::HlExtras},
HlBlock, HlPrimitives,
}; };
use alloy_eips::BlockId; use alloy_eips::BlockId;
use alloy_evm::Evm; use alloy_evm::Evm;
@ -10,19 +10,19 @@ use alloy_primitives::U256;
use reth::{ use reth::{
api::{FullNodeTypes, HeaderTy, NodeTypes, PrimitivesTy}, api::{FullNodeTypes, HeaderTy, NodeTypes, PrimitivesTy},
builder::{ builder::{
rpc::{EthApiBuilder, EthApiCtx},
FullNodeComponents, FullNodeComponents,
rpc::{EthApiBuilder, EthApiCtx},
}, },
rpc::{ rpc::{
eth::{core::EthApiInner, DevSigner, FullEthApiServer}, eth::{DevSigner, FullEthApiServer, core::EthApiInner},
server_types::eth::{ server_types::eth::{
receipt::EthReceiptConverter, EthApiError, EthStateCache, FeeHistoryCache, EthApiError, EthStateCache, FeeHistoryCache, GasPriceOracle,
GasPriceOracle, receipt::EthReceiptConverter,
}, },
}, },
tasks::{ tasks::{
pool::{BlockingTaskGuard, BlockingTaskPool},
TaskSpawner, TaskSpawner,
pool::{BlockingTaskGuard, BlockingTaskPool},
}, },
}; };
use reth_evm::{ConfigureEvm, Database, EvmEnvFor, HaltReasonFor, InspectorFor, TxEnvFor}; use reth_evm::{ConfigureEvm, Database, EvmEnvFor, HaltReasonFor, InspectorFor, TxEnvFor};
@ -32,12 +32,12 @@ use reth_provider::{
}; };
use reth_rpc::RpcTypes; use reth_rpc::RpcTypes;
use reth_rpc_eth_api::{ use reth_rpc_eth_api::{
helpers::{
pending_block::BuildPendingEnv, spec::SignersForApi, AddDevSigners, EthApiSpec, EthFees,
EthState, LoadFee, LoadPendingBlock, LoadState, SpawnBlocking, Trace,
},
EthApiTypes, FromEvmError, RpcConvert, RpcConverter, RpcNodeCore, RpcNodeCoreExt, EthApiTypes, FromEvmError, RpcConvert, RpcConverter, RpcNodeCore, RpcNodeCoreExt,
SignableTxRequest, SignableTxRequest,
helpers::{
AddDevSigners, EthApiSpec, EthFees, EthState, LoadFee, LoadPendingBlock, LoadState,
SpawnBlocking, Trace, pending_block::BuildPendingEnv, spec::SignersForApi,
},
}; };
use revm::context::result::ResultAndState; use revm::context::result::ResultAndState;
use std::{fmt, marker::PhantomData, sync::Arc}; use std::{fmt, marker::PhantomData, sync::Arc};
@ -60,12 +60,17 @@ pub(crate) struct HlEthApiInner<N: HlRpcNodeCore, Rpc: RpcConvert> {
type HlRpcConvert<N, NetworkT> = type HlRpcConvert<N, NetworkT> =
RpcConverter<NetworkT, <N as FullNodeComponents>::Evm, EthReceiptConverter<HlChainSpec>>; RpcConverter<NetworkT, <N as FullNodeComponents>::Evm, EthReceiptConverter<HlChainSpec>>;
#[derive(Clone)]
pub struct HlEthApi<N: HlRpcNodeCore, Rpc: RpcConvert> { pub struct HlEthApi<N: HlRpcNodeCore, Rpc: RpcConvert> {
/// Gateway to node's core components. /// Gateway to node's core components.
pub(crate) inner: Arc<HlEthApiInner<N, Rpc>>, pub(crate) inner: Arc<HlEthApiInner<N, Rpc>>,
} }
impl<N: HlRpcNodeCore, Rpc: RpcConvert> Clone for HlEthApi<N, Rpc> {
fn clone(&self) -> Self {
Self { inner: self.inner.clone() }
}
}
impl<N, Rpc> fmt::Debug for HlEthApi<N, Rpc> impl<N, Rpc> fmt::Debug for HlEthApi<N, Rpc>
where where
N: HlRpcNodeCore, N: HlRpcNodeCore,
@ -79,7 +84,7 @@ where
impl<N, Rpc> EthApiTypes for HlEthApi<N, Rpc> impl<N, Rpc> EthApiTypes for HlEthApi<N, Rpc>
where where
N: HlRpcNodeCore, N: HlRpcNodeCore,
Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>, Rpc: RpcConvert<Primitives = N::Primitives>,
{ {
type Error = EthApiError; type Error = EthApiError;
type NetworkTypes = Rpc::Network; type NetworkTypes = Rpc::Network;
@ -155,7 +160,7 @@ where
impl<N, Rpc> SpawnBlocking for HlEthApi<N, Rpc> impl<N, Rpc> SpawnBlocking for HlEthApi<N, Rpc>
where where
N: HlRpcNodeCore, N: HlRpcNodeCore,
Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>, Rpc: RpcConvert<Primitives = N::Primitives>,
{ {
#[inline] #[inline]
fn io_task_spawner(&self) -> impl TaskSpawner { fn io_task_spawner(&self) -> impl TaskSpawner {

2
src/node/rpc/precompile.rs
View File

@ -1,6 +1,6 @@
use alloy_eips::BlockId; use alloy_eips::BlockId;
use jsonrpsee::proc_macros::rpc; use jsonrpsee::proc_macros::rpc;
use jsonrpsee_core::{async_trait, RpcResult}; use jsonrpsee_core::{RpcResult, async_trait};
use reth_rpc_convert::RpcConvert; use reth_rpc_convert::RpcConvert;
use reth_rpc_eth_types::EthApiError; use reth_rpc_eth_types::EthApiError;
use tracing::trace; use tracing::trace;

10
src/node/rpc/transaction.rs
View File

@ -1,9 +1,11 @@
use std::time::Duration;
use crate::node::rpc::{HlEthApi, HlRpcNodeCore}; use crate::node::rpc::{HlEthApi, HlRpcNodeCore};
use alloy_primitives::{Bytes, B256}; use alloy_primitives::{B256, Bytes};
use reth::rpc::server_types::eth::EthApiError; use reth::rpc::server_types::eth::EthApiError;
use reth_rpc_eth_api::{ use reth_rpc_eth_api::{
helpers::{spec::SignersForRpc, EthTransactions, LoadTransaction},
RpcConvert, RpcConvert,
helpers::{EthTransactions, LoadTransaction, spec::SignersForRpc},
}; };
impl<N, Rpc> LoadTransaction for HlEthApi<N, Rpc> impl<N, Rpc> LoadTransaction for HlEthApi<N, Rpc>
@ -25,4 +27,8 @@ where
async fn send_raw_transaction(&self, _tx: Bytes) -> Result<B256, Self::Error> { async fn send_raw_transaction(&self, _tx: Bytes) -> Result<B256, Self::Error> {
unreachable!() unreachable!()
} }
fn send_raw_transaction_sync_timeout(&self) -> Duration {
self.inner.eth_api.send_raw_transaction_sync_timeout()
}
} }

2
src/node/spot_meta/patch.rs
View File

@ -1,5 +1,5 @@
use crate::node::spot_meta::SpotId; use crate::node::spot_meta::SpotId;
use alloy_primitives::{address, Address}; use alloy_primitives::{Address, address};
use std::collections::BTreeMap; use std::collections::BTreeMap;
/// Testnet-specific fix for #67 /// Testnet-specific fix for #67

6
src/node/storage/mod.rs
View File

@ -1,22 +1,22 @@
use crate::{ use crate::{
HlBlock, HlBlockBody, HlPrimitives,
node::{ node::{
primitives::tx_wrapper::{convert_to_eth_block_body, convert_to_hl_block_body}, primitives::tx_wrapper::{convert_to_eth_block_body, convert_to_hl_block_body},
types::HlExtras, types::HlExtras,
}, },
HlBlock, HlBlockBody, HlPrimitives,
}; };
use alloy_consensus::BlockHeader; use alloy_consensus::BlockHeader;
use alloy_primitives::Bytes; use alloy_primitives::Bytes;
use reth_chainspec::EthereumHardforks; use reth_chainspec::EthereumHardforks;
use reth_db::{ use reth_db::{
DbTxUnwindExt,
cursor::{DbCursorRO, DbCursorRW}, cursor::{DbCursorRO, DbCursorRW},
transaction::{DbTx, DbTxMut}, transaction::{DbTx, DbTxMut},
DbTxUnwindExt,
}; };
use reth_provider::{ use reth_provider::{
providers::{ChainStorage, NodeTypesForProvider},
BlockBodyReader, BlockBodyWriter, ChainSpecProvider, ChainStorageReader, ChainStorageWriter, BlockBodyReader, BlockBodyWriter, ChainSpecProvider, ChainStorageReader, ChainStorageWriter,
DBProvider, DatabaseProvider, EthStorage, ProviderResult, ReadBodyInput, StorageLocation, DBProvider, DatabaseProvider, EthStorage, ProviderResult, ReadBodyInput, StorageLocation,
providers::{ChainStorage, NodeTypesForProvider},
}; };
pub mod tables; pub mod tables;

2
src/node/storage/tables.rs
View File

@ -1,5 +1,5 @@
use alloy_primitives::{BlockNumber, Bytes}; use alloy_primitives::{BlockNumber, Bytes};
use reth_db::{table::TableInfo, tables, TableSet, TableType, TableViewer}; use reth_db::{TableSet, TableType, TableViewer, table::TableInfo, tables};
use std::fmt; use std::fmt;
tables! { tables! {

2
src/node/types/mod.rs
View File

@ -2,7 +2,7 @@
//! //!
//! Changes: //! Changes:
//! - ReadPrecompileCalls supports RLP encoding / decoding //! - ReadPrecompileCalls supports RLP encoding / decoding
use alloy_primitives::{Address, Bytes, Log, B256}; use alloy_primitives::{Address, B256, Bytes, Log};
use alloy_rlp::{Decodable, Encodable, RlpDecodable, RlpEncodable}; use alloy_rlp::{Decodable, Encodable, RlpDecodable, RlpEncodable};
use bytes::BufMut; use bytes::BufMut;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};

4
src/node/types/reth_compat.rs
View File

@ -10,12 +10,12 @@ use std::{
use tracing::info; use tracing::info;
use crate::{ use crate::{
HlBlock, HlBlockBody,
node::{ node::{
primitives::TransactionSigned as TxSigned, primitives::TransactionSigned as TxSigned,
spot_meta::{erc20_contract_to_spot_token, SpotId}, spot_meta::{SpotId, erc20_contract_to_spot_token},
types::{ReadPrecompileCalls, SystemTx}, types::{ReadPrecompileCalls, SystemTx},
}, },
HlBlock, HlBlockBody,
}; };
/// A raw transaction. /// A raw transaction.

4
src/pseudo_peer/network.rs
View File

@ -1,8 +1,8 @@
use super::service::{BlockHashCache, BlockPoller}; use super::service::{BlockHashCache, BlockPoller};
use crate::{chainspec::HlChainSpec, node::network::HlNetworkPrimitives, HlPrimitives}; use crate::{HlPrimitives, chainspec::HlChainSpec, node::network::HlNetworkPrimitives};
use reth_network::{ use reth_network::{
config::{rng_secret_key, SecretKey},
NetworkConfig, NetworkManager, PeersConfig, NetworkConfig, NetworkManager, PeersConfig,
config::{SecretKey, rng_secret_key},
}; };
use reth_network_peers::TrustedPeer; use reth_network_peers::TrustedPeer;
use reth_provider::test_utils::NoopProvider; use reth_provider::test_utils::NoopProvider;

5
src/pseudo_peer/service.rs
View File

@ -81,11 +81,10 @@ impl BlockPoller {
.await .await
.ok_or(eyre::eyre!("Failed to find latest block number"))?; .ok_or(eyre::eyre!("Failed to find latest block number"))?;
if let Some(debug_cutoff_height) = debug_cutoff_height { if let Some(debug_cutoff_height) = debug_cutoff_height
if next_block_number > debug_cutoff_height { && next_block_number > debug_cutoff_height {
next_block_number = debug_cutoff_height; next_block_number = debug_cutoff_height;
} }
}
loop { loop {
match block_source.collect_block(next_block_number).await { match block_source.collect_block(next_block_number).await {

2
src/pseudo_peer/sources/cached.rs
View File

@ -1,6 +1,6 @@
use super::{BlockSource, BlockSourceBoxed}; use super::{BlockSource, BlockSourceBoxed};
use crate::node::types::BlockAndReceipts; use crate::node::types::BlockAndReceipts;
use futures::{future::BoxFuture, FutureExt}; use futures::{FutureExt, future::BoxFuture};
use reth_network::cache::LruMap; use reth_network::cache::LruMap;
use std::sync::{Arc, RwLock}; use std::sync::{Arc, RwLock};

2
src/pseudo_peer/sources/hl_node/file_ops.rs
View File

@ -1,4 +1,4 @@
use super::{scan::Scanner, time_utils::TimeUtils, HOURLY_SUBDIR}; use super::{HOURLY_SUBDIR, scan::Scanner, time_utils::TimeUtils};
use crate::node::types::BlockAndReceipts; use crate::node::types::BlockAndReceipts;
use std::{ use std::{
fs::File, fs::File,

2
src/pseudo_peer/sources/hl_node/mod.rs
View File

@ -14,7 +14,7 @@ use self::{
use super::{BlockSource, BlockSourceBoxed}; use super::{BlockSource, BlockSourceBoxed};
use crate::node::types::BlockAndReceipts; use crate::node::types::BlockAndReceipts;
use futures::future::BoxFuture; use futures::future::BoxFuture;
use reth_metrics::{metrics, metrics::Counter, Metrics}; use reth_metrics::{Metrics, metrics, metrics::Counter};
use std::{ use std::{
path::{Path, PathBuf}, path::{Path, PathBuf},
sync::Arc, sync::Arc,

6
src/pseudo_peer/sources/hl_node/tests.rs
View File

@ -1,10 +1,10 @@
use super::*; use super::*;
use crate::{ use crate::{
node::types::{reth_compat, ReadPrecompileCalls}, node::types::{ReadPrecompileCalls, reth_compat},
pseudo_peer::sources::{hl_node::scan::LocalBlockAndReceipts, LocalBlockSource}, pseudo_peer::sources::{LocalBlockSource, hl_node::scan::LocalBlockAndReceipts},
}; };
use alloy_consensus::{BlockBody, Header}; use alloy_consensus::{BlockBody, Header};
use alloy_primitives::{Address, Bloom, Bytes, B256, B64, U256}; use alloy_primitives::{Address, B64, B256, Bloom, Bytes, U256};
use std::{io::Write, time::Duration}; use std::{io::Write, time::Duration};
const DEFAULT_FALLBACK_THRESHOLD_FOR_TEST: Duration = Duration::from_millis(5000); const DEFAULT_FALLBACK_THRESHOLD_FOR_TEST: Duration = Duration::from_millis(5000);

2
src/pseudo_peer/sources/hl_node/time_utils.rs
View File

@ -1,5 +1,5 @@
use std::path::Path; use std::path::Path;
use time::{macros::format_description, Date, OffsetDateTime, Time}; use time::{Date, OffsetDateTime, Time, macros::format_description};
pub struct TimeUtils; pub struct TimeUtils;

6
src/pseudo_peer/sources/local.rs
View File

@ -1,8 +1,8 @@
use super::{utils, BlockSource}; use super::{BlockSource, utils};
use crate::node::types::BlockAndReceipts; use crate::node::types::BlockAndReceipts;
use eyre::Context; use eyre::Context;
use futures::{future::BoxFuture, FutureExt}; use futures::{FutureExt, future::BoxFuture};
use reth_metrics::{metrics, metrics::Counter, Metrics}; use reth_metrics::{Metrics, metrics, metrics::Counter};
use std::path::PathBuf; use std::path::PathBuf;
use tracing::info; use tracing::info;

6
src/pseudo_peer/sources/s3.rs
View File

@ -1,8 +1,8 @@
use super::{utils, BlockSource}; use super::{BlockSource, utils};
use crate::node::types::BlockAndReceipts; use crate::node::types::BlockAndReceipts;
use aws_sdk_s3::types::RequestPayer; use aws_sdk_s3::types::RequestPayer;
use futures::{future::BoxFuture, FutureExt}; use futures::{FutureExt, future::BoxFuture};
use reth_metrics::{metrics, metrics::Counter, Metrics}; use reth_metrics::{Metrics, metrics, metrics::Counter};
use std::{sync::Arc, time::Duration}; use std::{sync::Arc, time::Duration};
use tracing::info; use tracing::info;

2
src/version.rs
View File

@ -1,6 +1,6 @@
use std::borrow::Cow; use std::borrow::Cow;
use reth_node_core::version::{try_init_version_metadata, RethCliVersionConsts}; use reth_node_core::version::{RethCliVersionConsts, try_init_version_metadata};
pub fn init_reth_hl_version() { pub fn init_reth_hl_version() {
let cargo_pkg_version = env!("CARGO_PKG_VERSION").to_string(); let cargo_pkg_version = env!("CARGO_PKG_VERSION").to_string();