mirror of
https://github.com/hl-archive-node/nanoreth.git
synced 2025-12-06 10:59:55 +00:00
Merge pull request #80 from hl-archive-node/chore/v1.8.2
chore: Upgrade to reth v1.8.2
This commit is contained in:
sprites0
653
Cargo.lock
generated
653
Cargo.lock
generated
File diff suppressed because it is too large
Load Diff
110
Cargo.toml
110
Cargo.toml
@ -1,7 +1,7 @@
|
||||
[package]
|
||||
name = "reth_hl"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
edition = "2024"
|
||||
build = "build.rs"
|
||||
|
||||
[lib]
|
||||
@ -26,67 +26,67 @@ lto = "fat"
|
||||
codegen-units = 1
|
||||
|
||||
[dependencies]
|
||||
reth = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-cli = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-cli-commands = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-basic-payload-builder = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-db = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-db-api = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-chainspec = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-cli-util = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-discv4 = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-engine-primitives = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-ethereum-forks = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-ethereum-payload-builder = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-ethereum-primitives = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-eth-wire = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-eth-wire-types = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-evm = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-evm-ethereum = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-node-core = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-revm = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-network = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-network-p2p = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-network-api = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-node-ethereum = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-network-peers = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-payload-primitives = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-primitives = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-primitives-traits = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-provider = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34", features = ["test-utils"] }
|
||||
reth-rpc = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-rpc-eth-api = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-rpc-engine-api = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-tracing = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-trie-common = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-trie-db = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-codecs = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-transaction-pool = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-stages-types = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-storage-api = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-errors = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-rpc-convert = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-rpc-eth-types = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-rpc-server-types = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
reth-metrics = { git = "https://github.com/sprites0/reth", rev = "40dd1247a55fdceca05e38a1320c054010d5bb34" }
|
||||
revm = { version = "29.0.0", default-features = false }
|
||||
reth = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-cli = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-cli-commands = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-basic-payload-builder = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-db = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-db-api = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-chainspec = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-cli-util = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-discv4 = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-engine-primitives = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-ethereum-forks = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-ethereum-payload-builder = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-ethereum-primitives = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-eth-wire = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-eth-wire-types = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-evm = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-evm-ethereum = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-node-core = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-revm = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-network = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-network-p2p = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-network-api = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-node-ethereum = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-network-peers = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-payload-primitives = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-primitives = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-primitives-traits = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-provider = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88", features = ["test-utils"] }
|
||||
reth-rpc = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-rpc-eth-api = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-rpc-engine-api = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-tracing = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-trie-common = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-trie-db = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-codecs = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-transaction-pool = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-stages-types = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-storage-api = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-errors = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-rpc-convert = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-rpc-eth-types = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-rpc-server-types = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
reth-metrics = { git = "https://github.com/hl-archive-node/reth", rev = "83baf84bcb6d88081fc1b39f97733b8ec345cb88" }
|
||||
revm = { version = "29.0.1", default-features = false }
|
||||
|
||||
# alloy dependencies
|
||||
alloy-genesis = { version = "1.0.30", default-features = false }
|
||||
alloy-consensus = { version = "1.0.30", default-features = false }
|
||||
alloy-genesis = { version = "1.0.37", default-features = false }
|
||||
alloy-consensus = { version = "1.0.37", default-features = false }
|
||||
alloy-chains = { version = "0.2.5", default-features = false }
|
||||
alloy-eips = { version = "1.0.30", default-features = false }
|
||||
alloy-evm = { version = "0.20.1", default-features = false }
|
||||
alloy-eips = { version = "1.0.37", default-features = false }
|
||||
alloy-evm = { version = "0.21.0", 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-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-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-eth = { version = "1.0.30", default-features = false }
|
||||
alloy-rpc-types-engine = { version = "1.0.30", default-features = false }
|
||||
alloy-signer = { version = "1.0.30", default-features = false }
|
||||
alloy-rpc-types = { version = "1.0.37", features = ["eth"], default-features = false }
|
||||
alloy-rpc-types-eth = { version = "1.0.37", default-features = false }
|
||||
alloy-rpc-types-engine = { version = "1.0.37", default-features = false }
|
||||
alloy-signer = { version = "1.0.37", default-features = false }
|
||||
alloy-sol-macro = "1.3.1"
|
||||
alloy-sol-types = { version = "1.3.1", default-features = false }
|
||||
|
||||
|
||||
@ -2,18 +2,18 @@ use alloy_eips::BlockId;
|
||||
use alloy_json_rpc::RpcObject;
|
||||
use alloy_primitives::{Bytes, U256};
|
||||
use alloy_rpc_types_eth::{
|
||||
state::{EvmOverrides, StateOverride},
|
||||
BlockOverrides,
|
||||
state::{EvmOverrides, StateOverride},
|
||||
};
|
||||
use jsonrpsee::{
|
||||
http_client::{HttpClient, HttpClientBuilder},
|
||||
proc_macros::rpc,
|
||||
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_api::{helpers::EthCall, RpcTxReq};
|
||||
use reth_rpc_eth_api::{RpcTxReq, helpers::EthCall};
|
||||
|
||||
#[rpc(server, namespace = "eth")]
|
||||
pub(crate) trait CallForwarderApi<TxReq: RpcObject> {
|
||||
|
||||
@ -7,34 +7,37 @@
|
||||
//! For non-system transactions, we can just return the log as is, and the client will
|
||||
//! 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_json_rpc::RpcObject;
|
||||
use alloy_primitives::{B256, U256};
|
||||
use alloy_rpc_types::{
|
||||
pubsub::{Params, SubscriptionKind},
|
||||
BlockTransactions, Filter, FilterChanges, FilterId, Log, PendingTransactionFilterKind,
|
||||
TransactionInfo,
|
||||
pubsub::{Params, SubscriptionKind},
|
||||
};
|
||||
use jsonrpsee::{proc_macros::rpc, PendingSubscriptionSink, SubscriptionMessage, SubscriptionSink};
|
||||
use jsonrpsee_core::{async_trait, RpcResult};
|
||||
use jsonrpsee_types::{error::INTERNAL_ERROR_CODE, ErrorObject};
|
||||
use jsonrpsee::{PendingSubscriptionSink, SubscriptionMessage, SubscriptionSink, proc_macros::rpc};
|
||||
use jsonrpsee_core::{RpcResult, async_trait};
|
||||
use jsonrpsee_types::{ErrorObject, error::INTERNAL_ERROR_CODE};
|
||||
use reth::{api::FullNodeComponents, builder::rpc::RpcContext, tasks::TaskSpawner};
|
||||
use reth_primitives_traits::{BlockBody as _, SignedTransaction};
|
||||
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::{
|
||||
helpers::{EthBlocks, EthTransactions, LoadReceipt},
|
||||
transaction::ConvertReceiptInput,
|
||||
EthApiServer, EthApiTypes, EthFilterApiServer, EthPubSubApiServer, FullEthApiTypes, RpcBlock,
|
||||
RpcConvert, RpcHeader, RpcNodeCoreExt, RpcReceipt, RpcTransaction, RpcTxReq,
|
||||
helpers::{EthBlocks, EthTransactions, LoadReceipt},
|
||||
transaction::ConvertReceiptInput,
|
||||
};
|
||||
use serde::Serialize;
|
||||
use std::{borrow::Cow, marker::PhantomData, sync::Arc};
|
||||
use std::{marker::PhantomData, sync::Arc};
|
||||
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:
|
||||
EthApiServer<
|
||||
@ -182,7 +185,7 @@ impl<Eth: EthWrapper> HlSystemTransactionExt<Eth> {
|
||||
};
|
||||
|
||||
let input = ConvertReceiptInput {
|
||||
receipt: Cow::Borrowed(receipt),
|
||||
receipt: receipt.clone(),
|
||||
tx,
|
||||
gas_used: receipt.cumulative_gas_used() - gas_used,
|
||||
next_log_index,
|
||||
@ -530,7 +533,7 @@ async fn adjust_block_receipts<Eth: EthWrapper>(
|
||||
};
|
||||
|
||||
let input = ConvertReceiptInput {
|
||||
receipt: Cow::Borrowed(receipt),
|
||||
receipt: receipt.clone(),
|
||||
tx,
|
||||
gas_used: receipt.cumulative_gas_used() - gas_used,
|
||||
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 {
|
||||
let provider = eth_api.provider();
|
||||
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();
|
||||
system_tx_count
|
||||
|
||||
block.body.transactions().iter().filter(|tx| tx.is_system_transaction()).count()
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
|
||||
@ -2,14 +2,14 @@ use std::time::Duration;
|
||||
|
||||
use alloy_json_rpc::RpcObject;
|
||||
use alloy_network::Ethereum;
|
||||
use alloy_primitives::{Bytes, B256};
|
||||
use alloy_primitives::{B256, Bytes};
|
||||
use alloy_rpc_types::TransactionRequest;
|
||||
use jsonrpsee::{
|
||||
http_client::{HttpClient, HttpClientBuilder},
|
||||
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_eth_api::RpcReceipt;
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
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_primitives::{Header, SealedHeader};
|
||||
use std::sync::LazyLock;
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
use crate::chainspec::{hl::hl_testnet, HlChainSpec};
|
||||
use crate::chainspec::{HlChainSpec, hl::hl_testnet};
|
||||
|
||||
use super::hl::hl_mainnet;
|
||||
use reth_cli::chainspec::ChainSpecParser;
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
use alloy_primitives::{BlockNumber, B256};
|
||||
use alloy_primitives::{B256, BlockNumber};
|
||||
use reth_provider::{BlockNumReader, ProviderError};
|
||||
use std::cmp::Ordering;
|
||||
|
||||
|
||||
@ -2,8 +2,8 @@ use super::HlEvmInner;
|
||||
use crate::evm::{spec::HlSpecId, transaction::HlTxTr};
|
||||
use reth_revm::context::ContextTr;
|
||||
use revm::{
|
||||
context::Cfg, context_interface::Block, handler::instructions::EthInstructions,
|
||||
interpreter::interpreter::EthInterpreter, Context, Database,
|
||||
Context, Database, context::Cfg, context_interface::Block,
|
||||
handler::instructions::EthInstructions, interpreter::interpreter::EthInterpreter,
|
||||
};
|
||||
|
||||
/// Trait that allows for hl HlEvm to be built.
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
use crate::evm::{spec::HlSpecId, transaction::HlTxEnv};
|
||||
use revm::{
|
||||
Context, Journal, MainContext,
|
||||
context::{BlockEnv, CfgEnv, TxEnv},
|
||||
database_interface::EmptyDB,
|
||||
Context, Journal, MainContext,
|
||||
};
|
||||
|
||||
/// Type alias for the default context type of the HlEvm.
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
use super::HlEvmInner;
|
||||
use crate::evm::{spec::HlSpecId, transaction::HlTxTr};
|
||||
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,
|
||||
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
|
||||
|
||||
@ -1,15 +1,15 @@
|
||||
use revm::{
|
||||
Inspector,
|
||||
bytecode::opcode::BLOCKHASH,
|
||||
context::{ContextSetters, Evm, FrameStack},
|
||||
context_interface::ContextTr,
|
||||
handler::{
|
||||
EthFrame, EthPrecompiles, EvmTr, FrameInitOrResult, FrameTr, PrecompileProvider,
|
||||
evm::{ContextDbError, FrameInitResult},
|
||||
instructions::{EthInstructions, InstructionProvider},
|
||||
EthFrame, EthPrecompiles, EvmTr, FrameInitOrResult, FrameTr, PrecompileProvider,
|
||||
},
|
||||
inspector::{InspectorEvmTr, JournalExt},
|
||||
interpreter::{interpreter::EthInterpreter, Instruction, InterpreterResult},
|
||||
Inspector,
|
||||
interpreter::{Instruction, InterpreterResult, interpreter::EthInterpreter},
|
||||
};
|
||||
|
||||
use crate::chainspec::MAINNET_CHAIN_ID;
|
||||
|
||||
@ -7,8 +7,8 @@ use alloy_primitives::keccak256;
|
||||
use revm::{
|
||||
context::Host,
|
||||
interpreter::{
|
||||
as_u64_saturated, interpreter_types::StackTr, popn_top, InstructionContext,
|
||||
InterpreterTypes,
|
||||
InstructionContext, InterpreterTypes, as_u64_saturated, interpreter_types::StackTr,
|
||||
popn_top,
|
||||
},
|
||||
primitives::{BLOCK_HASH_HISTORY, U256},
|
||||
};
|
||||
|
||||
@ -7,7 +7,7 @@ use reth_primitives_traits::SignerRecoverable;
|
||||
use revm::{
|
||||
context::TxEnv,
|
||||
context_interface::transaction::Transaction,
|
||||
primitives::{Address, Bytes, TxKind, B256, U256},
|
||||
primitives::{Address, B256, Bytes, TxKind, U256},
|
||||
};
|
||||
|
||||
#[auto_impl(&, &mut, Box, Arc)]
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
use alloy_chains::{Chain, NamedChain};
|
||||
use core::any::Any;
|
||||
use reth_chainspec::ForkCondition;
|
||||
use reth_ethereum_forks::{hardfork, ChainHardforks, EthereumHardfork, Hardfork};
|
||||
use reth_ethereum_forks::{ChainHardforks, EthereumHardfork, Hardfork, hardfork};
|
||||
|
||||
hardfork!(
|
||||
/// The name of a hl hardfork.
|
||||
|
||||
13
src/main.rs
13
src/main.rs
@ -9,12 +9,12 @@ use reth_hl::{
|
||||
hl_node_compliance::install_hl_node_compliance,
|
||||
tx_forwarder::{self, EthForwarderApiServer},
|
||||
},
|
||||
chainspec::{parser::HlChainSpecParser, HlChainSpec},
|
||||
chainspec::{HlChainSpec, parser::HlChainSpecParser},
|
||||
node::{
|
||||
HlNode,
|
||||
cli::{Cli, HlNodeArgs},
|
||||
rpc::precompile::{HlBlockPrecompileApiServer, HlBlockPrecompileExt},
|
||||
storage::tables::Tables,
|
||||
HlNode,
|
||||
},
|
||||
};
|
||||
use tracing::info;
|
||||
@ -27,11 +27,6 @@ static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
|
||||
fn main() -> eyre::Result<()> {
|
||||
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
|
||||
reth_hl::version::init_reth_hl_version();
|
||||
|
||||
@ -80,8 +75,8 @@ fn main() -> eyre::Result<()> {
|
||||
|
||||
Ok(())
|
||||
})
|
||||
.apply(|builder| {
|
||||
builder.db().create_tables_for::<Tables>().expect("create tables");
|
||||
.apply(|mut builder| {
|
||||
builder.db_mut().create_tables_for::<Tables>().expect("create tables");
|
||||
builder
|
||||
})
|
||||
.launch()
|
||||
|
||||
@ -1,21 +1,21 @@
|
||||
use crate::{
|
||||
chainspec::{parser::HlChainSpecParser, HlChainSpec},
|
||||
node::{consensus::HlConsensus, evm::config::HlEvmConfig, storage::tables::Tables, HlNode},
|
||||
chainspec::{HlChainSpec, parser::HlChainSpecParser},
|
||||
node::{HlNode, consensus::HlConsensus, evm::config::HlEvmConfig, storage::tables::Tables},
|
||||
pseudo_peer::BlockSourceArgs,
|
||||
};
|
||||
use clap::{Args, Parser};
|
||||
use reth::{
|
||||
CliRunner,
|
||||
args::LogArgs,
|
||||
builder::{NodeBuilder, WithLaunchContext},
|
||||
cli::Commands,
|
||||
prometheus_exporter::install_prometheus_recorder,
|
||||
version::version_metadata,
|
||||
CliRunner,
|
||||
};
|
||||
use reth_chainspec::EthChainSpec;
|
||||
use reth_cli::chainspec::ChainSpecParser;
|
||||
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 std::{
|
||||
fmt::{self},
|
||||
@ -136,8 +136,9 @@ where
|
||||
// Install the prometheus recorder to be sure to record all metrics
|
||||
let _ = install_prometheus_recorder();
|
||||
|
||||
let components =
|
||||
|spec: Arc<C::ChainSpec>| (HlEvmConfig::new(spec.clone()), HlConsensus::new(spec));
|
||||
let components = |spec: Arc<C::ChainSpec>| {
|
||||
(HlEvmConfig::new(spec.clone()), Arc::new(HlConsensus::new(spec)))
|
||||
};
|
||||
|
||||
match self.command {
|
||||
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))
|
||||
}
|
||||
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::Import(command) => {
|
||||
runner.run_blocking_until_ctrl_c(command.execute::<HlNode, _>(components))
|
||||
|
||||
@ -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 reth::{
|
||||
api::FullNodeTypes,
|
||||
api::{FullNodeTypes, NodeTypes},
|
||||
beacon_consensus::EthBeaconConsensus,
|
||||
builder::{components::ConsensusBuilder, BuilderContext},
|
||||
builder::{BuilderContext, components::ConsensusBuilder},
|
||||
consensus::{Consensus, ConsensusError, FullConsensus, HeaderValidator},
|
||||
consensus_common::validation::{
|
||||
validate_against_parent_4844, validate_against_parent_hash_number,
|
||||
@ -24,7 +24,7 @@ impl<Node> ConsensusBuilder<Node> for HlConsensusBuilder
|
||||
where
|
||||
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> {
|
||||
Ok(Arc::new(HlConsensus::new(ctx.chain_spec())))
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
//! 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_primitives::{Bloom, B256};
|
||||
use alloy_primitives::{B256, Bloom};
|
||||
use reth::consensus::ConsensusError;
|
||||
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};
|
||||
|
||||
pub fn validate_block_post_execution<B, R, ChainSpec>(
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
use crate::{
|
||||
node::evm::config::{HlBlockExecutorFactory, HlEvmConfig},
|
||||
HlBlock,
|
||||
node::evm::config::{HlBlockExecutorFactory, HlEvmConfig},
|
||||
};
|
||||
use alloy_consensus::Header;
|
||||
use reth_evm::{
|
||||
|
||||
@ -1,5 +1,6 @@
|
||||
use super::{executor::HlBlockExecutor, factory::HlEvmFactory};
|
||||
use crate::{
|
||||
HlBlock, HlBlockBody, HlPrimitives,
|
||||
chainspec::HlChainSpec,
|
||||
evm::{spec::HlSpecId, transaction::HlTxEnv},
|
||||
hardforks::HlHardforks,
|
||||
@ -9,31 +10,30 @@ use crate::{
|
||||
rpc::engine_api::validator::HlExecutionData,
|
||||
types::HlExtras,
|
||||
},
|
||||
HlBlock, HlBlockBody, HlPrimitives,
|
||||
};
|
||||
use alloy_consensus::{BlockHeader, Header, Transaction as _, TxReceipt, EMPTY_OMMER_ROOT_HASH};
|
||||
use alloy_eips::{merge::BEACON_NONCE, Encodable2718};
|
||||
use alloy_consensus::{BlockHeader, EMPTY_OMMER_ROOT_HASH, Header, Transaction as _, TxReceipt};
|
||||
use alloy_eips::{Encodable2718, merge::BEACON_NONCE};
|
||||
use alloy_primitives::{Log, U256};
|
||||
use reth_chainspec::{EthChainSpec, EthereumHardforks, Hardforks};
|
||||
use reth_evm::{
|
||||
block::{BlockExecutionError, BlockExecutorFactory, BlockExecutorFor},
|
||||
eth::{receipt_builder::ReceiptBuilder, EthBlockExecutionCtx},
|
||||
execute::{BlockAssembler, BlockAssemblerInput},
|
||||
precompiles::PrecompilesMap,
|
||||
ConfigureEngineEvm, ConfigureEvm, EvmEnv, EvmEnvFor, EvmFactory, ExecutableTxIterator,
|
||||
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_payload_primitives::NewPayloadError;
|
||||
use reth_primitives::{logs_bloom, BlockTy, HeaderTy, Receipt, SealedBlock, SealedHeader};
|
||||
use reth_primitives_traits::{proofs, SignerRecoverable, WithEncoded};
|
||||
use reth_primitives::{BlockTy, HeaderTy, Receipt, SealedBlock, SealedHeader, logs_bloom};
|
||||
use reth_primitives_traits::{SignerRecoverable, WithEncoded, proofs};
|
||||
use reth_provider::BlockExecutionResult;
|
||||
use reth_revm::State;
|
||||
use revm::{
|
||||
Inspector,
|
||||
context::{BlockEnv, CfgEnv, TxEnv},
|
||||
context_interface::block::BlobExcessGasAndPrice,
|
||||
primitives::hardfork::SpecId,
|
||||
Inspector,
|
||||
};
|
||||
use std::{borrow::Cow, convert::Infallible, sync::Arc};
|
||||
|
||||
@ -45,10 +45,10 @@ pub struct HlBlockAssembler {
|
||||
impl<F> BlockAssembler<F> for HlBlockAssembler
|
||||
where
|
||||
F: for<'a> BlockExecutorFactory<
|
||||
ExecutionCtx<'a> = HlBlockExecutionCtx<'a>,
|
||||
Transaction = TransactionSigned,
|
||||
Receipt = Receipt,
|
||||
>,
|
||||
ExecutionCtx<'a> = HlBlockExecutionCtx<'a>,
|
||||
Transaction = TransactionSigned,
|
||||
Receipt = Receipt,
|
||||
>,
|
||||
{
|
||||
type Block = HlBlock;
|
||||
|
||||
@ -106,7 +106,10 @@ where
|
||||
} else {
|
||||
// for the first post-fork block, both parent.blob_gas_used and
|
||||
// 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),
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
@ -237,9 +240,9 @@ where
|
||||
R: ReceiptBuilder<Transaction = TransactionSigned, Receipt: TxReceipt<Log = Log>>,
|
||||
Spec: EthereumHardforks + HlHardforks + EthChainSpec + Hardforks + Clone,
|
||||
EvmF: EvmFactory<
|
||||
Tx: FromRecoveredTx<TransactionSigned> + FromTxWithEncoded<TransactionSigned>,
|
||||
Precompiles = PrecompilesMap,
|
||||
>,
|
||||
Tx: FromRecoveredTx<TransactionSigned> + FromTxWithEncoded<TransactionSigned>,
|
||||
Precompiles = PrecompilesMap,
|
||||
>,
|
||||
R::Transaction: From<TransactionSigned> + Clone,
|
||||
Self: 'static,
|
||||
HlTxEnv<TxEnv>: IntoTxEnv<<EvmF as EvmFactory>::Tx>,
|
||||
@ -284,7 +287,7 @@ where
|
||||
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 spec = revm_spec_by_timestamp_and_block_number(
|
||||
self.chain_spec().clone(),
|
||||
@ -324,7 +327,7 @@ where
|
||||
blob_excess_gas_and_price,
|
||||
};
|
||||
|
||||
EvmEnv { cfg_env, block_env }
|
||||
Ok(EvmEnv { cfg_env, block_env })
|
||||
}
|
||||
|
||||
fn next_evm_env(
|
||||
@ -373,9 +376,9 @@ where
|
||||
fn context_for_block<'a>(
|
||||
&self,
|
||||
block: &'a SealedBlock<BlockTy<Self::Primitives>>,
|
||||
) -> ExecutionCtxFor<'a, Self> {
|
||||
) -> Result<ExecutionCtxFor<'a, Self>, Self::Error> {
|
||||
let block_body = block.body();
|
||||
HlBlockExecutionCtx {
|
||||
Ok(HlBlockExecutionCtx {
|
||||
ctx: EthBlockExecutionCtx {
|
||||
parent_hash: block.header().parent_hash,
|
||||
parent_beacon_block_root: block.header().parent_beacon_block_root,
|
||||
@ -386,15 +389,15 @@ where
|
||||
read_precompile_calls: block_body.read_precompile_calls.clone(),
|
||||
highest_precompile_address: block_body.highest_precompile_address,
|
||||
},
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fn context_for_next_block(
|
||||
&self,
|
||||
parent: &SealedHeader<HeaderTy<Self::Primitives>>,
|
||||
attributes: Self::NextBlockEnvCtx,
|
||||
) -> ExecutionCtxFor<'_, Self> {
|
||||
HlBlockExecutionCtx {
|
||||
) -> Result<ExecutionCtxFor<'_, Self>, Self::Error> {
|
||||
Ok(HlBlockExecutionCtx {
|
||||
ctx: EthBlockExecutionCtx {
|
||||
parent_hash: parent.hash(),
|
||||
parent_beacon_block_root: attributes.parent_beacon_block_root,
|
||||
@ -402,13 +405,13 @@ where
|
||||
withdrawals: attributes.withdrawals.map(Cow::Owned),
|
||||
},
|
||||
extras: HlExtras::default(), // TODO: hacky, double check if this is correct
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl ConfigureEngineEvm<HlExecutionData> for HlEvmConfig {
|
||||
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> {
|
||||
|
||||
@ -8,29 +8,26 @@ use crate::{
|
||||
},
|
||||
};
|
||||
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_primitives::{address, hex, Address, Bytes, U160, U256};
|
||||
use alloy_primitives::{Address, Bytes, U160, U256, address, hex};
|
||||
use reth_chainspec::{EthChainSpec, EthereumHardforks, Hardforks};
|
||||
use reth_evm::{
|
||||
block::{BlockValidationError, CommitChanges},
|
||||
Database, Evm, FromRecoveredTx, FromTxWithEncoded, IntoTxEnv, OnStateHook,
|
||||
block::BlockValidationError,
|
||||
eth::receipt_builder::ReceiptBuilder,
|
||||
execute::{BlockExecutionError, BlockExecutor},
|
||||
precompiles::{DynPrecompile, PrecompileInput, PrecompilesMap},
|
||||
Database, Evm, FromRecoveredTx, FromTxWithEncoded, IntoTxEnv, OnStateHook,
|
||||
};
|
||||
use reth_provider::BlockExecutionResult;
|
||||
use reth_revm::State;
|
||||
use revm::{
|
||||
context::{
|
||||
result::{ExecutionResult, ResultAndState},
|
||||
TxEnv,
|
||||
},
|
||||
DatabaseCommit,
|
||||
context::{TxEnv, result::ResultAndState},
|
||||
interpreter::instructions::utility::IntoU256,
|
||||
precompile::{PrecompileError, PrecompileOutput, PrecompileResult},
|
||||
primitives::HashMap,
|
||||
state::Bytecode,
|
||||
DatabaseCommit,
|
||||
};
|
||||
|
||||
pub fn is_system_transaction(tx: &TransactionSigned) -> bool {
|
||||
@ -87,12 +84,12 @@ impl<'a, DB, EVM, Spec, R: ReceiptBuilder> HlBlockExecutor<'a, EVM, Spec, R>
|
||||
where
|
||||
DB: Database + 'a,
|
||||
EVM: Evm<
|
||||
DB = &'a mut State<DB>,
|
||||
Precompiles = PrecompilesMap,
|
||||
Tx: FromRecoveredTx<R::Transaction>
|
||||
+ FromRecoveredTx<TransactionSigned>
|
||||
+ FromTxWithEncoded<TransactionSigned>,
|
||||
>,
|
||||
DB = &'a mut State<DB>,
|
||||
Precompiles = PrecompilesMap,
|
||||
Tx: FromRecoveredTx<R::Transaction>
|
||||
+ FromRecoveredTx<TransactionSigned>
|
||||
+ FromTxWithEncoded<TransactionSigned>,
|
||||
>,
|
||||
Spec: EthereumHardforks + HlHardforks + EthChainSpec + Hardforks + Clone,
|
||||
R: ReceiptBuilder<Transaction = TransactionSigned, Receipt: TxReceipt>,
|
||||
<R as ReceiptBuilder>::Transaction: Unpin + From<TransactionSigned>,
|
||||
@ -110,7 +107,9 @@ where
|
||||
const COREWRITER_ENABLED_BLOCK_NUMBER: u64 = 7578300;
|
||||
const COREWRITER_CONTRACT_ADDRESS: Address =
|
||||
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) {
|
||||
return Ok(());
|
||||
@ -137,12 +136,12 @@ impl<'a, DB, E, Spec, R> BlockExecutor for HlBlockExecutor<'a, E, Spec, R>
|
||||
where
|
||||
DB: Database + 'a,
|
||||
E: Evm<
|
||||
DB = &'a mut State<DB>,
|
||||
Tx: FromRecoveredTx<R::Transaction>
|
||||
+ FromRecoveredTx<TransactionSigned>
|
||||
+ FromTxWithEncoded<TransactionSigned>,
|
||||
Precompiles = PrecompilesMap,
|
||||
>,
|
||||
DB = &'a mut State<DB>,
|
||||
Tx: FromRecoveredTx<R::Transaction>
|
||||
+ FromRecoveredTx<TransactionSigned>
|
||||
+ FromTxWithEncoded<TransactionSigned>,
|
||||
Precompiles = PrecompilesMap,
|
||||
>,
|
||||
Spec: EthereumHardforks + HlHardforks + EthChainSpec + Hardforks,
|
||||
R: ReceiptBuilder<Transaction = TransactionSigned, Receipt: TxReceipt>,
|
||||
<R as ReceiptBuilder>::Transaction: Unpin + From<TransactionSigned>,
|
||||
@ -161,11 +160,10 @@ where
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn execute_transaction_with_commit_condition(
|
||||
fn execute_transaction_without_commit(
|
||||
&mut self,
|
||||
tx: impl ExecutableTx<Self>,
|
||||
f: impl FnOnce(&ExecutionResult<<Self::Evm as Evm>::HaltReason>) -> CommitChanges,
|
||||
) -> Result<Option<u64>, BlockExecutionError> {
|
||||
) -> Result<ResultAndState<<Self::Evm as Evm>::HaltReason>, BlockExecutionError> {
|
||||
// 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.
|
||||
let block_available_gas = self.evm.block().gas_limit - self.gas_used;
|
||||
@ -178,15 +176,19 @@ where
|
||||
.into());
|
||||
}
|
||||
|
||||
// Execute transaction.
|
||||
let ResultAndState { result, mut state } = self
|
||||
.evm
|
||||
.transact(&tx)
|
||||
.map_err(|err| BlockExecutionError::evm(err, tx.tx().trie_hash()))?;
|
||||
// Execute transaction and return the result
|
||||
self.evm.transact(&tx).map_err(|err| {
|
||||
let hash = tx.tx().trie_hash();
|
||||
BlockExecutionError::evm(err, 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();
|
||||
|
||||
@ -215,7 +217,7 @@ where
|
||||
// Commit the state changes.
|
||||
self.evm.db_mut().commit(state);
|
||||
|
||||
Ok(Some(gas_used))
|
||||
Ok(gas_used)
|
||||
}
|
||||
|
||||
fn finish(self) -> Result<(Self::Evm, BlockExecutionResult<R::Receipt>), BlockExecutionError> {
|
||||
|
||||
@ -7,16 +7,16 @@ use crate::evm::{
|
||||
spec::HlSpecId,
|
||||
transaction::HlTxEnv,
|
||||
};
|
||||
use reth_evm::{precompiles::PrecompilesMap, Database, EvmEnv, EvmFactory};
|
||||
use reth_evm::{Database, EvmEnv, EvmFactory, precompiles::PrecompilesMap};
|
||||
use reth_revm::Context;
|
||||
use revm::{
|
||||
Inspector,
|
||||
context::{
|
||||
result::{EVMError, HaltReason},
|
||||
TxEnv,
|
||||
result::{EVMError, HaltReason},
|
||||
},
|
||||
inspector::NoOpInspector,
|
||||
precompile::{PrecompileSpecId, Precompiles},
|
||||
Inspector,
|
||||
};
|
||||
|
||||
/// Factory producing [`HlEvm`].
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
use crate::{
|
||||
evm::{
|
||||
api::{ctx::HlContext, HlEvmInner},
|
||||
api::{HlEvmInner, ctx::HlContext},
|
||||
spec::HlSpecId,
|
||||
transaction::HlTxEnv,
|
||||
},
|
||||
@ -10,18 +10,18 @@ use alloy_primitives::{Address, Bytes};
|
||||
use config::HlEvmConfig;
|
||||
use reth::{
|
||||
api::FullNodeTypes,
|
||||
builder::{components::ExecutorBuilder, BuilderContext},
|
||||
builder::{BuilderContext, components::ExecutorBuilder},
|
||||
};
|
||||
use reth_evm::{Database, Evm, EvmEnv};
|
||||
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::{
|
||||
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};
|
||||
|
||||
@ -98,11 +98,7 @@ where
|
||||
&mut self,
|
||||
tx: Self::Tx,
|
||||
) -> Result<ResultAndState<Self::HaltReason>, Self::Error> {
|
||||
if self.inspect {
|
||||
self.inner.inspect_tx(tx)
|
||||
} else {
|
||||
self.inner.transact(tx)
|
||||
}
|
||||
if self.inspect { self.inner.inspect_tx(tx) } else { self.inner.transact(tx) }
|
||||
}
|
||||
|
||||
fn transact_system_call(
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
use alloy_primitives::{address, Address};
|
||||
use alloy_primitives::{Address, address};
|
||||
use reth_evm::block::BlockExecutionError;
|
||||
use revm::{primitives::HashMap, state::Account};
|
||||
|
||||
|
||||
@ -4,11 +4,11 @@ use crate::{
|
||||
pool::HlPoolBuilder,
|
||||
primitives::{HlBlock, HlPrimitives},
|
||||
rpc::{
|
||||
HlEthApiBuilder,
|
||||
engine_api::{
|
||||
builder::HlEngineApiBuilder, payload::HlPayloadTypes,
|
||||
validator::HlPayloadValidatorBuilder,
|
||||
},
|
||||
HlEthApiBuilder,
|
||||
},
|
||||
storage::HlStorage,
|
||||
},
|
||||
@ -20,14 +20,14 @@ use network::HlNetworkBuilder;
|
||||
use reth::{
|
||||
api::{FullNodeTypes, NodeTypes},
|
||||
builder::{
|
||||
Node, NodeAdapter,
|
||||
components::{ComponentsBuilder, NoopPayloadServiceBuilder},
|
||||
rpc::RpcAddOns,
|
||||
Node, NodeAdapter,
|
||||
},
|
||||
};
|
||||
use reth_engine_primitives::ConsensusEngineHandle;
|
||||
use std::{marker::PhantomData, sync::Arc};
|
||||
use tokio::sync::{oneshot, Mutex};
|
||||
use tokio::sync::{Mutex, oneshot};
|
||||
|
||||
pub mod cli;
|
||||
pub mod consensus;
|
||||
|
||||
@ -8,7 +8,7 @@ use reth_primitives::NodePrimitives;
|
||||
use service::{BlockMsg, ImportEvent, Outcome};
|
||||
use std::{
|
||||
fmt,
|
||||
task::{ready, Context, Poll},
|
||||
task::{Context, Poll, ready},
|
||||
};
|
||||
|
||||
use crate::node::network::HlNewBlock;
|
||||
|
||||
@ -1,17 +1,17 @@
|
||||
use super::handle::ImportHandle;
|
||||
use crate::{
|
||||
HlBlock, HlBlockBody,
|
||||
consensus::HlConsensus,
|
||||
node::{
|
||||
network::HlNewBlock,
|
||||
rpc::engine_api::payload::HlPayloadTypes,
|
||||
types::{BlockAndReceipts, EvmBlock},
|
||||
},
|
||||
HlBlock, HlBlockBody,
|
||||
};
|
||||
use alloy_consensus::{BlockBody, Header};
|
||||
use alloy_primitives::U128;
|
||||
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_eth_wire::NewBlock;
|
||||
use reth_network::{
|
||||
|
||||
@ -1,20 +1,20 @@
|
||||
#![allow(clippy::owned_cow)]
|
||||
use crate::{
|
||||
HlBlock,
|
||||
consensus::HlConsensus,
|
||||
node::{
|
||||
network::block_import::{handle::ImportHandle, service::ImportService, HlBlockImport},
|
||||
HlNode,
|
||||
network::block_import::{HlBlockImport, handle::ImportHandle, service::ImportService},
|
||||
primitives::HlPrimitives,
|
||||
rpc::engine_api::payload::HlPayloadTypes,
|
||||
types::ReadPrecompileCalls,
|
||||
HlNode,
|
||||
},
|
||||
pseudo_peer::{start_pseudo_peer, BlockSourceConfig},
|
||||
HlBlock,
|
||||
pseudo_peer::{BlockSourceConfig, start_pseudo_peer},
|
||||
};
|
||||
use alloy_rlp::{Decodable, Encodable};
|
||||
use reth::{
|
||||
api::{FullNodeTypes, TxTy},
|
||||
builder::{components::NetworkBuilder, BuilderContext},
|
||||
builder::{BuilderContext, components::NetworkBuilder},
|
||||
transaction_pool::{PoolTransaction, TransactionPool},
|
||||
};
|
||||
use reth_discv4::NodeRecord;
|
||||
@ -26,7 +26,7 @@ use reth_network_api::PeersInfo;
|
||||
use reth_provider::StageCheckpointReader;
|
||||
use reth_stages_types::StageId;
|
||||
use std::sync::Arc;
|
||||
use tokio::sync::{mpsc, oneshot, Mutex};
|
||||
use tokio::sync::{Mutex, mpsc, oneshot};
|
||||
use tracing::info;
|
||||
|
||||
pub mod block_import;
|
||||
@ -38,8 +38,8 @@ pub struct HlNewBlock(pub NewBlock<HlBlock>);
|
||||
mod rlp {
|
||||
use super::*;
|
||||
use crate::{
|
||||
node::primitives::{BlockBody, TransactionSigned},
|
||||
HlBlockBody,
|
||||
node::primitives::{BlockBody, TransactionSigned},
|
||||
};
|
||||
use alloy_consensus::{BlobTransactionSidecar, Header};
|
||||
use alloy_primitives::{Address, U128};
|
||||
|
||||
@ -6,12 +6,12 @@
|
||||
//! Ethereum transaction pool only supports TransactionSigned (EthereumTxEnvelope<TxEip4844>),
|
||||
//! hence this placeholder for the transaction pool.
|
||||
|
||||
use crate::node::{primitives::TransactionSigned, HlNode};
|
||||
use crate::node::{HlNode, primitives::TransactionSigned};
|
||||
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_primitives::{Address, Bytes, ChainId, TxHash, TxKind, B256, U256};
|
||||
use alloy_eips::{Typed2718, eip7702::SignedAuthorization};
|
||||
use alloy_primitives::{Address, B256, Bytes, ChainId, TxHash, TxKind, U256};
|
||||
use alloy_rpc_types::AccessList;
|
||||
use reth::{
|
||||
api::FullNodeTypes, builder::components::PoolBuilder, transaction_pool::PoolTransaction,
|
||||
@ -19,7 +19,7 @@ use reth::{
|
||||
use reth_ethereum_primitives::PooledTransactionVariant;
|
||||
use reth_primitives::Recovered;
|
||||
use reth_primitives_traits::InMemorySize;
|
||||
use reth_transaction_pool::{noop::NoopTransactionPool, EthPoolTransaction};
|
||||
use reth_transaction_pool::{EthPoolTransaction, noop::NoopTransactionPool};
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct HlPoolBuilder;
|
||||
|
||||
@ -1,30 +1,32 @@
|
||||
//! HlNodePrimitives::TransactionSigned; it's the same as ethereum transaction type,
|
||||
//! except that it supports pseudo signer for system transactions.
|
||||
use std::convert::Infallible;
|
||||
|
||||
use crate::evm::transaction::HlTxEnv;
|
||||
use alloy_consensus::{
|
||||
crypto::RecoveryError, error::ValueError, SignableTransaction, Signed,
|
||||
Transaction as TransactionTrait, TransactionEnvelope, TxEip1559, TxEip2930, TxEip4844,
|
||||
TxEip7702, TxLegacy, TxType, TypedTransaction,
|
||||
SignableTransaction, Signed, Transaction as TransactionTrait, TransactionEnvelope, TxEip1559,
|
||||
TxEip2930, TxEip4844, TxEip7702, TxLegacy, TxType, TypedTransaction, crypto::RecoveryError,
|
||||
error::ValueError, transaction::TxHashRef,
|
||||
};
|
||||
use alloy_eips::Encodable2718;
|
||||
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_signer::Signature;
|
||||
use reth_codecs::alloy::transaction::{Envelope, FromTxCompact};
|
||||
use reth_db::{
|
||||
table::{Compress, Decompress},
|
||||
DatabaseError,
|
||||
table::{Compress, Decompress},
|
||||
};
|
||||
use reth_ethereum_primitives::PooledTransactionVariant;
|
||||
use reth_evm::FromRecoveredTx;
|
||||
use reth_primitives::Recovered;
|
||||
use reth_primitives_traits::{
|
||||
serde_bincode_compat::SerdeBincodeCompat, InMemorySize, SignedTransaction, SignerRecoverable,
|
||||
InMemorySize, SignedTransaction, SignerRecoverable, serde_bincode_compat::SerdeBincodeCompat,
|
||||
};
|
||||
use reth_rpc_eth_api::{
|
||||
transaction::{FromConsensusTx, TryIntoTxEnv},
|
||||
EthTxEnvError, SignTxRequestError, SignableTxRequest, TryIntoSimTx,
|
||||
transaction::{FromConsensusTx, TryIntoTxEnv},
|
||||
};
|
||||
use revm::context::{BlockEnv, CfgEnv, TxEnv};
|
||||
|
||||
@ -46,6 +48,12 @@ fn s_to_address(s: U256) -> Address {
|
||||
Address::from_slice(&buf)
|
||||
}
|
||||
|
||||
impl TxHashRef for TransactionSigned {
|
||||
fn tx_hash(&self) -> &TxHash {
|
||||
self.inner().tx_hash()
|
||||
}
|
||||
}
|
||||
|
||||
impl SignerRecoverable for TransactionSigned {
|
||||
fn recover_signer(&self) -> Result<Address, RecoveryError> {
|
||||
if self.is_system_transaction() {
|
||||
@ -69,11 +77,7 @@ impl SignerRecoverable for TransactionSigned {
|
||||
}
|
||||
}
|
||||
|
||||
impl SignedTransaction for TransactionSigned {
|
||||
fn tx_hash(&self) -> &TxHash {
|
||||
self.inner().tx_hash()
|
||||
}
|
||||
}
|
||||
impl SignedTransaction for TransactionSigned {}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// 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 {
|
||||
type TxInfo = TransactionInfo;
|
||||
type Err = Infallible;
|
||||
|
||||
fn from_consensus_tx(tx: TransactionSigned, signer: Address, tx_info: Self::TxInfo) -> Self {
|
||||
Self::from_transaction(Recovered::new_unchecked(tx.into_inner().into(), signer), tx_info)
|
||||
fn from_consensus_tx(
|
||||
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,
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
use crate::node::rpc::{HlEthApi, HlRpcNodeCore};
|
||||
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::{
|
||||
helpers::{
|
||||
pending_block::PendingEnvBuilder, EthBlocks, LoadBlock, LoadPendingBlock, LoadReceipt,
|
||||
},
|
||||
RpcConvert,
|
||||
helpers::{
|
||||
EthBlocks, LoadBlock, LoadPendingBlock, LoadReceipt, pending_block::PendingEnvBuilder,
|
||||
},
|
||||
};
|
||||
|
||||
impl<N, Rpc> EthBlocks for HlEthApi<N, Rpc>
|
||||
@ -29,7 +29,7 @@ impl<N, Rpc> LoadPendingBlock for HlEthApi<N, Rpc>
|
||||
where
|
||||
N: HlRpcNodeCore,
|
||||
EthApiError: FromEvmError<N::Evm>,
|
||||
Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
|
||||
Rpc: RpcConvert<Primitives = N::Primitives>,
|
||||
{
|
||||
#[inline]
|
||||
fn pending_block(&self) -> &tokio::sync::Mutex<Option<PendingBlock<N::Primitives>>> {
|
||||
@ -50,7 +50,6 @@ where
|
||||
impl<N, Rpc> LoadReceipt for HlEthApi<N, Rpc>
|
||||
where
|
||||
N: HlRpcNodeCore,
|
||||
EthApiError: FromEvmError<N::Evm>,
|
||||
Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
|
||||
{
|
||||
}
|
||||
|
||||
@ -1,19 +1,19 @@
|
||||
use core::fmt;
|
||||
|
||||
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_primitives::B256;
|
||||
use reth::rpc::server_types::eth::EthApiError;
|
||||
use reth_evm::{ConfigureEvm, Database, EvmEnvFor, HaltReasonFor, InspectorFor, SpecFor, TxEnvFor};
|
||||
use reth_primitives::{NodePrimitives, Recovered};
|
||||
use reth_primitives_traits::SignedTransaction;
|
||||
use reth_provider::{ProviderError, ProviderTx};
|
||||
use reth_rpc_eth_api::{
|
||||
helpers::{Call, EthCall},
|
||||
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>> {}
|
||||
|
||||
@ -22,11 +22,11 @@ where
|
||||
N: HlRpcNodeCore,
|
||||
EthApiError: FromEvmError<N::Evm>,
|
||||
Rpc: RpcConvert<
|
||||
Primitives = N::Primitives,
|
||||
Error = EthApiError,
|
||||
TxEnv = TxEnvFor<N::Evm>,
|
||||
Spec = SpecFor<N::Evm>,
|
||||
>,
|
||||
Primitives = N::Primitives,
|
||||
Error = EthApiError,
|
||||
TxEnv = TxEnvFor<N::Evm>,
|
||||
Spec = SpecFor<N::Evm>,
|
||||
>,
|
||||
{
|
||||
}
|
||||
|
||||
@ -35,11 +35,11 @@ where
|
||||
N: HlRpcNodeCore,
|
||||
EthApiError: FromEvmError<N::Evm>,
|
||||
Rpc: RpcConvert<
|
||||
Primitives = N::Primitives,
|
||||
Error = EthApiError,
|
||||
TxEnv = TxEnvFor<N::Evm>,
|
||||
Spec = SpecFor<N::Evm>,
|
||||
>,
|
||||
Primitives = N::Primitives,
|
||||
Error = EthApiError,
|
||||
TxEnv = TxEnvFor<N::Evm>,
|
||||
Spec = SpecFor<N::Evm>,
|
||||
>,
|
||||
{
|
||||
#[inline]
|
||||
fn call_gas_limit(&self) -> u64 {
|
||||
|
||||
@ -9,7 +9,7 @@ use alloy_primitives::B256;
|
||||
use alloy_rpc_types_engine::PayloadError;
|
||||
use reth::{
|
||||
api::{FullNodeComponents, NodeTypes},
|
||||
builder::{rpc::PayloadValidatorBuilder, AddOnsContext},
|
||||
builder::{AddOnsContext, rpc::PayloadValidatorBuilder},
|
||||
};
|
||||
use reth_engine_primitives::{ExecutionPayload, PayloadValidator};
|
||||
use reth_payload_primitives::NewPayloadError;
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
use super::{apply_precompiles, HlEthApi, HlRpcNodeCore};
|
||||
use alloy_evm::overrides::{apply_state_overrides, StateOverrideError};
|
||||
use super::{HlEthApi, HlRpcNodeCore, apply_precompiles};
|
||||
use alloy_evm::overrides::{StateOverrideError, apply_state_overrides};
|
||||
use alloy_network::TransactionBuilder;
|
||||
use alloy_primitives::{TxKind, U256};
|
||||
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_rpc_convert::{RpcConvert, RpcTxReq};
|
||||
use reth_rpc_eth_api::{
|
||||
helpers::{
|
||||
estimate::{update_estimated_gas_range, EstimateCall},
|
||||
Call,
|
||||
},
|
||||
AsEthApiError, IntoEthApiError, RpcNodeCore,
|
||||
helpers::{
|
||||
Call,
|
||||
estimate::{EstimateCall, update_estimated_gas_range},
|
||||
},
|
||||
};
|
||||
use reth_rpc_eth_types::{
|
||||
error::{api::FromEvmHalt, FromEvmError},
|
||||
EthApiError, RevertError, RpcInvalidTransactionError,
|
||||
error::{FromEvmError, api::FromEvmHalt},
|
||||
};
|
||||
use reth_rpc_server_types::constants::gas_oracle::{CALL_STIPEND_GAS, ESTIMATE_GAS_ERROR_RATIO};
|
||||
use reth_storage_api::StateProvider;
|
||||
use revm::context_interface::{result::ExecutionResult, Transaction};
|
||||
use revm::context_interface::{Transaction, result::ExecutionResult};
|
||||
use tracing::trace;
|
||||
|
||||
impl<N, Rpc> EstimateCall for HlEthApi<N, Rpc>
|
||||
@ -30,11 +30,11 @@ where
|
||||
N: HlRpcNodeCore,
|
||||
EthApiError: FromEvmError<N::Evm> + From<StateOverrideError<ProviderError>>,
|
||||
Rpc: RpcConvert<
|
||||
Primitives = N::Primitives,
|
||||
Error = EthApiError,
|
||||
TxEnv = TxEnvFor<N::Evm>,
|
||||
Spec = SpecFor<N::Evm>,
|
||||
>,
|
||||
Primitives = N::Primitives,
|
||||
Error = EthApiError,
|
||||
TxEnv = TxEnvFor<N::Evm>,
|
||||
Spec = SpecFor<N::Evm>,
|
||||
>,
|
||||
{
|
||||
// Modified version that adds `apply_precompiles`; comments are stripped out.
|
||||
fn estimate_gas_with<S>(
|
||||
@ -82,13 +82,11 @@ where
|
||||
let mut tx_env = self.create_txn_env(&evm_env, request, &mut db)?;
|
||||
|
||||
let mut is_basic_transfer = false;
|
||||
if tx_env.input().is_empty() {
|
||||
if let TxKind::Call(to) = tx_env.kind() {
|
||||
if let Ok(code) = db.db.account_code(&to) {
|
||||
if tx_env.input().is_empty()
|
||||
&& let TxKind::Call(to) = tx_env.kind()
|
||||
&& let Ok(code) = db.db.account_code(&to) {
|
||||
is_basic_transfer = code.map(|code| code.is_empty()).unwrap_or(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if tx_env.gas_price() > 0 {
|
||||
highest_gas_limit =
|
||||
@ -107,11 +105,10 @@ where
|
||||
let mut min_tx_env = tx_env.clone();
|
||||
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 res.result.is_success() {
|
||||
if let Ok(res) = evm.transact(min_tx_env).map_err(Self::Error::from_evm_err)
|
||||
&& res.result.is_success() {
|
||||
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");
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
use crate::{
|
||||
HlBlock, HlPrimitives,
|
||||
chainspec::HlChainSpec,
|
||||
node::{evm::apply_precompiles, types::HlExtras},
|
||||
HlBlock, HlPrimitives,
|
||||
};
|
||||
use alloy_eips::BlockId;
|
||||
use alloy_evm::Evm;
|
||||
@ -10,19 +10,19 @@ use alloy_primitives::U256;
|
||||
use reth::{
|
||||
api::{FullNodeTypes, HeaderTy, NodeTypes, PrimitivesTy},
|
||||
builder::{
|
||||
rpc::{EthApiBuilder, EthApiCtx},
|
||||
FullNodeComponents,
|
||||
rpc::{EthApiBuilder, EthApiCtx},
|
||||
},
|
||||
rpc::{
|
||||
eth::{core::EthApiInner, DevSigner, FullEthApiServer},
|
||||
eth::{DevSigner, FullEthApiServer, core::EthApiInner},
|
||||
server_types::eth::{
|
||||
receipt::EthReceiptConverter, EthApiError, EthStateCache, FeeHistoryCache,
|
||||
GasPriceOracle,
|
||||
EthApiError, EthStateCache, FeeHistoryCache, GasPriceOracle,
|
||||
receipt::EthReceiptConverter,
|
||||
},
|
||||
},
|
||||
tasks::{
|
||||
pool::{BlockingTaskGuard, BlockingTaskPool},
|
||||
TaskSpawner,
|
||||
pool::{BlockingTaskGuard, BlockingTaskPool},
|
||||
},
|
||||
};
|
||||
use reth_evm::{ConfigureEvm, Database, EvmEnvFor, HaltReasonFor, InspectorFor, TxEnvFor};
|
||||
@ -32,12 +32,12 @@ use reth_provider::{
|
||||
};
|
||||
use reth_rpc::RpcTypes;
|
||||
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,
|
||||
SignableTxRequest,
|
||||
helpers::{
|
||||
AddDevSigners, EthApiSpec, EthFees, EthState, LoadFee, LoadPendingBlock, LoadState,
|
||||
SpawnBlocking, Trace, pending_block::BuildPendingEnv, spec::SignersForApi,
|
||||
},
|
||||
};
|
||||
use revm::context::result::ResultAndState;
|
||||
use std::{fmt, marker::PhantomData, sync::Arc};
|
||||
@ -60,12 +60,17 @@ pub(crate) struct HlEthApiInner<N: HlRpcNodeCore, Rpc: RpcConvert> {
|
||||
type HlRpcConvert<N, NetworkT> =
|
||||
RpcConverter<NetworkT, <N as FullNodeComponents>::Evm, EthReceiptConverter<HlChainSpec>>;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct HlEthApi<N: HlRpcNodeCore, Rpc: RpcConvert> {
|
||||
/// Gateway to node's core components.
|
||||
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>
|
||||
where
|
||||
N: HlRpcNodeCore,
|
||||
@ -79,7 +84,7 @@ where
|
||||
impl<N, Rpc> EthApiTypes for HlEthApi<N, Rpc>
|
||||
where
|
||||
N: HlRpcNodeCore,
|
||||
Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
|
||||
Rpc: RpcConvert<Primitives = N::Primitives>,
|
||||
{
|
||||
type Error = EthApiError;
|
||||
type NetworkTypes = Rpc::Network;
|
||||
@ -155,7 +160,7 @@ where
|
||||
impl<N, Rpc> SpawnBlocking for HlEthApi<N, Rpc>
|
||||
where
|
||||
N: HlRpcNodeCore,
|
||||
Rpc: RpcConvert<Primitives = N::Primitives, Error = EthApiError>,
|
||||
Rpc: RpcConvert<Primitives = N::Primitives>,
|
||||
{
|
||||
#[inline]
|
||||
fn io_task_spawner(&self) -> impl TaskSpawner {
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
use alloy_eips::BlockId;
|
||||
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_eth_types::EthApiError;
|
||||
use tracing::trace;
|
||||
|
||||
@ -1,9 +1,11 @@
|
||||
use std::time::Duration;
|
||||
|
||||
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_eth_api::{
|
||||
helpers::{spec::SignersForRpc, EthTransactions, LoadTransaction},
|
||||
RpcConvert,
|
||||
helpers::{EthTransactions, LoadTransaction, spec::SignersForRpc},
|
||||
};
|
||||
|
||||
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> {
|
||||
unreachable!()
|
||||
}
|
||||
|
||||
fn send_raw_transaction_sync_timeout(&self) -> Duration {
|
||||
self.inner.eth_api.send_raw_transaction_sync_timeout()
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
use crate::node::spot_meta::SpotId;
|
||||
use alloy_primitives::{address, Address};
|
||||
use alloy_primitives::{Address, address};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
/// Testnet-specific fix for #67
|
||||
|
||||
@ -1,22 +1,22 @@
|
||||
use crate::{
|
||||
HlBlock, HlBlockBody, HlPrimitives,
|
||||
node::{
|
||||
primitives::tx_wrapper::{convert_to_eth_block_body, convert_to_hl_block_body},
|
||||
types::HlExtras,
|
||||
},
|
||||
HlBlock, HlBlockBody, HlPrimitives,
|
||||
};
|
||||
use alloy_consensus::BlockHeader;
|
||||
use alloy_primitives::Bytes;
|
||||
use reth_chainspec::EthereumHardforks;
|
||||
use reth_db::{
|
||||
DbTxUnwindExt,
|
||||
cursor::{DbCursorRO, DbCursorRW},
|
||||
transaction::{DbTx, DbTxMut},
|
||||
DbTxUnwindExt,
|
||||
};
|
||||
use reth_provider::{
|
||||
providers::{ChainStorage, NodeTypesForProvider},
|
||||
BlockBodyReader, BlockBodyWriter, ChainSpecProvider, ChainStorageReader, ChainStorageWriter,
|
||||
DBProvider, DatabaseProvider, EthStorage, ProviderResult, ReadBodyInput, StorageLocation,
|
||||
providers::{ChainStorage, NodeTypesForProvider},
|
||||
};
|
||||
|
||||
pub mod tables;
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
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;
|
||||
|
||||
tables! {
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
//!
|
||||
//! Changes:
|
||||
//! - 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 bytes::BufMut;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
@ -10,12 +10,12 @@ use std::{
|
||||
use tracing::info;
|
||||
|
||||
use crate::{
|
||||
HlBlock, HlBlockBody,
|
||||
node::{
|
||||
primitives::TransactionSigned as TxSigned,
|
||||
spot_meta::{erc20_contract_to_spot_token, SpotId},
|
||||
spot_meta::{SpotId, erc20_contract_to_spot_token},
|
||||
types::{ReadPrecompileCalls, SystemTx},
|
||||
},
|
||||
HlBlock, HlBlockBody,
|
||||
};
|
||||
|
||||
/// A raw transaction.
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
use super::service::{BlockHashCache, BlockPoller};
|
||||
use crate::{chainspec::HlChainSpec, node::network::HlNetworkPrimitives, HlPrimitives};
|
||||
use crate::{HlPrimitives, chainspec::HlChainSpec, node::network::HlNetworkPrimitives};
|
||||
use reth_network::{
|
||||
config::{rng_secret_key, SecretKey},
|
||||
NetworkConfig, NetworkManager, PeersConfig,
|
||||
config::{SecretKey, rng_secret_key},
|
||||
};
|
||||
use reth_network_peers::TrustedPeer;
|
||||
use reth_provider::test_utils::NoopProvider;
|
||||
|
||||
@ -81,11 +81,10 @@ impl BlockPoller {
|
||||
.await
|
||||
.ok_or(eyre::eyre!("Failed to find latest block number"))?;
|
||||
|
||||
if let Some(debug_cutoff_height) = debug_cutoff_height {
|
||||
if next_block_number > debug_cutoff_height {
|
||||
if let Some(debug_cutoff_height) = debug_cutoff_height
|
||||
&& next_block_number > debug_cutoff_height {
|
||||
next_block_number = debug_cutoff_height;
|
||||
}
|
||||
}
|
||||
|
||||
loop {
|
||||
match block_source.collect_block(next_block_number).await {
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
use super::{BlockSource, BlockSourceBoxed};
|
||||
use crate::node::types::BlockAndReceipts;
|
||||
use futures::{future::BoxFuture, FutureExt};
|
||||
use futures::{FutureExt, future::BoxFuture};
|
||||
use reth_network::cache::LruMap;
|
||||
use std::sync::{Arc, RwLock};
|
||||
|
||||
|
||||
@ -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 std::{
|
||||
fs::File,
|
||||
|
||||
@ -14,7 +14,7 @@ use self::{
|
||||
use super::{BlockSource, BlockSourceBoxed};
|
||||
use crate::node::types::BlockAndReceipts;
|
||||
use futures::future::BoxFuture;
|
||||
use reth_metrics::{metrics, metrics::Counter, Metrics};
|
||||
use reth_metrics::{Metrics, metrics, metrics::Counter};
|
||||
use std::{
|
||||
path::{Path, PathBuf},
|
||||
sync::Arc,
|
||||
@ -75,8 +75,8 @@ impl BlockSource for HlNodeBlockSource {
|
||||
let too_soon = now - last_poll_time < args.fallback_threshold;
|
||||
if more_recent && too_soon {
|
||||
return Err(eyre::eyre!(
|
||||
"Not found locally; limiting polling rate before fallback so that hl-node has chance to catch up"
|
||||
));
|
||||
"Not found locally; limiting polling rate before fallback so that hl-node has chance to catch up"
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
use super::*;
|
||||
use crate::{
|
||||
node::types::{reth_compat, ReadPrecompileCalls},
|
||||
pseudo_peer::sources::{hl_node::scan::LocalBlockAndReceipts, LocalBlockSource},
|
||||
node::types::{ReadPrecompileCalls, reth_compat},
|
||||
pseudo_peer::sources::{LocalBlockSource, hl_node::scan::LocalBlockAndReceipts},
|
||||
};
|
||||
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};
|
||||
|
||||
const DEFAULT_FALLBACK_THRESHOLD_FOR_TEST: Duration = Duration::from_millis(5000);
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
use std::path::Path;
|
||||
use time::{macros::format_description, Date, OffsetDateTime, Time};
|
||||
use time::{Date, OffsetDateTime, Time, macros::format_description};
|
||||
|
||||
pub struct TimeUtils;
|
||||
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
use super::{utils, BlockSource};
|
||||
use super::{BlockSource, utils};
|
||||
use crate::node::types::BlockAndReceipts;
|
||||
use eyre::Context;
|
||||
use futures::{future::BoxFuture, FutureExt};
|
||||
use reth_metrics::{metrics, metrics::Counter, Metrics};
|
||||
use futures::{FutureExt, future::BoxFuture};
|
||||
use reth_metrics::{Metrics, metrics, metrics::Counter};
|
||||
use std::path::PathBuf;
|
||||
use tracing::info;
|
||||
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
use super::{utils, BlockSource};
|
||||
use super::{BlockSource, utils};
|
||||
use crate::node::types::BlockAndReceipts;
|
||||
use aws_sdk_s3::types::RequestPayer;
|
||||
use futures::{future::BoxFuture, FutureExt};
|
||||
use reth_metrics::{metrics, metrics::Counter, Metrics};
|
||||
use futures::{FutureExt, future::BoxFuture};
|
||||
use reth_metrics::{Metrics, metrics, metrics::Counter};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
use tracing::info;
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
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() {
|
||||
let cargo_pkg_version = env!("CARGO_PKG_VERSION").to_string();
|
||||
|
||||
Reference in New Issue
Block a user