Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

fix(build): Trying to fix build vs. latest modifed reth #30

Closed
wants to merge 1 commit into from
Closed

fix(build): Trying to fix build vs. latest modifed reth #30

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
139 changes: 42 additions & 97 deletions bin/reth/src/main.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,8 +28,9 @@ fn main() {
std::process::exit(1);
}
}*/

use reth::api::FullNodeTypes;
use alloy_sol_types::{sol, SolEventInterface, SolInterface};
use std::marker::PhantomData;
use db::Database;
use execution::execute_block;
use eyre::Error;
Expand All @@ -43,7 +44,7 @@ use reth_consensus::Consensus;
use reth_db::{test_utils::TempDatabase, DatabaseEnv};
use reth_execution_types::Chain;
use reth_exex::{ExExContext, ExExEvent};
use reth_node_api::{FullNodeTypesAdapter, NodeAddOns};
use reth_node_api::{FullNodeTypesAdapter, NodeAddOns, FullNodeComponents};
//use reth_node_api::{EngineTypes, FullNodeComponents, NodeAddOns};
use reth_node_builder::{components::Components, rpc::EthApiBuilderProvider, AddOns, FullNode, Node, NodeAdapter, NodeBuilder, NodeComponentsBuilder, NodeConfig, NodeHandle, RethFullAdapter};
use reth_node_ethereum::{node::EthereumAddOns, EthEvmConfig, EthExecutorProvider, EthereumNode};
Expand All @@ -57,7 +58,7 @@ use rpc::RpcTestContext;
use rusqlite::Connection;
use transaction::TransactionTestContext;
use wallet::Wallet;
use std::{future::Future, marker::PhantomData, pin::Pin, sync::Arc};
use std::{future::Future, pin::Pin, sync::Arc};

//use alloy_primitives::{Address, B256};
use reth::rpc::types::engine::PayloadAttributes;
Expand Down Expand Up @@ -92,6 +93,7 @@ pub(crate) fn eth_payload_attributes(timestamp: u64) -> EthPayloadBuilderAttribu
EthPayloadBuilderAttributes::new(B256::ZERO, attributes)
}

fn assert_send<T: Send>(_: &T) {}

sol!(RollupContract, "TaikoL1.json");
use RollupContract::{BlockProposed, RollupContractCalls, RollupContractEvents};
Expand All @@ -110,17 +112,25 @@ static CHAIN_SPEC: Lazy<Arc<ChainSpec>> = Lazy::new(|| {
)
});

struct Rollup<Node: reth_node_api::FullNodeComponents> {
struct Rollup<Node: FullNodeComponents> {
ctx: ExExContext<Node>,
node: TestNodeContext,
}

impl<Node: reth_node_api::FullNodeComponents> Rollup<Node> {
// impl<Node> Rollup<'a, Node>
// where
// Node: FullNodeComponents,
// Node::Provider: Clone + Unpin + Send + 'static,
// {
impl<Node: FullNodeComponents> Rollup<Node> {
fn new(ctx: ExExContext<Node>, node: TestNodeContext) -> eyre::Result<Self> {
Ok(Self { ctx, node })
}

async fn start(mut self) -> eyre::Result<()> {
async fn start(mut self) -> eyre::Result<()>
// where
// Self: Send + 'static{
{
// Process all new chain state notifications
while let Some(notification) = self.ctx.notifications.recv().await {
if let Some(reverted_chain) = notification.reverted_chain() {
Expand Down Expand Up @@ -398,9 +408,9 @@ pub async fn setup<N>(
is_dev: bool,
) -> eyre::Result<(Vec<NodeHelperType<N, N::AddOns>>, TaskManager, Wallet)>
where
N: Default + Node<TmpNodeAdapter<N>>,
N: Default + Node<TmpNodeAdapter<N>> + Send,
<N::AddOns as NodeAddOns<Adapter<N>>>::EthApi:
FullEthApiServer + AddDevSigners + EthApiBuilderProvider<Adapter<N>>,
FullEthApiServer + AddDevSigners + EthApiBuilderProvider<Adapter<N>> + Send,
{
let tasks = TaskManager::current();
let exec = tasks.executor();
Expand Down Expand Up @@ -454,97 +464,32 @@ fn main() -> eyre::Result<()> {
reth::cli::Cli::parse_args().run(|builder, _| async move {
let handle = builder
.node(EthereumNode::default())
.install_exex("Rollup", move |ctx| async {
//let connection = Connection::open(DATABASE_PATH)?;

let network_config = NetworkArgs {
discovery: DiscoveryArgs { disable_discovery: true, ..DiscoveryArgs::default() },
..NetworkArgs::default()
};

let tasks = TaskManager::current();
let exec = tasks.executor();

// let node_config = NodeConfig::test()
// .with_chain(CHAIN_SPEC.clone())
// .with_network(network_config.clone())
// .with_unused_ports()
// .with_rpc(RpcServerArgs::default().with_unused_ports().with_http())
// .set_dev(true);

// let node_handle: = NodeBuilder::new(node_config.clone())
// .testing_node(exec.clone())
// .node(Default::default())
// .launch()
// .await?;

// let mut node = NodeTestContext::new(node_handle.node).await?;

let (mut nodes, _tasks, _wallet) = setup::<EthereumNode>(
1,
Arc::new(
ChainSpecBuilder::default()
.chain(MAINNET.chain)
.genesis(serde_json::from_str(include_str!("../../../crates/ethereum/node/tests/assets/genesis.json")).unwrap())
.cancun_activated()
.build(),
),
false,
)
.await?;

let node = nodes.pop().unwrap();

//Ok((nodes, tasks, Wallet::default().with_chain_id(chain_spec.chain().into())))

// let wallet = Wallet::default();
// let raw_tx = TransactionTestContext::transfer_tx_bytes(1, wallet.inner).await;

// // make the node advance
// let tx_hash = node.rpc.inject_tx(raw_tx).await?;

// // make the node advance
// let (payload, _): (EthBuiltPayload, _) = node.advance_block(vec![], eth_payload_attributes).await?;

// let block_hash = payload.block().hash();
// let block_number = payload.block().number;
.install_exex("Rollup", move |ctx| {
Box::pin(async move {
let (mut nodes, _tasks, _wallet) = setup::<EthereumNode>(
1,
Arc::new(
ChainSpecBuilder::default()
.chain(MAINNET.chain)
.genesis(serde_json::from_str(include_str!("../../../crates/ethereum/node/tests/assets/genesis.json")).unwrap())
.cancun_activated()
.build(),
),
false,
)
.await?;

// // assert the block has been committed to the blockchain
// node.assert_new_block(tx_hash, block_hash, block_number).await?;
let node = nodes.pop().unwrap();


// let wallet = Wallet::default();
// let raw_tx = TransactionTestContext::transfer_tx_bytes(1, wallet.inner).await;

// // make the node advance
// let tx_hash = node.rpc.inject_tx(raw_tx).await?;

// // make the node advance
// let (payload, _) = node.advance_block(vec![], eth_payload_attributes).await?;

// let block_hash = payload.block().hash();
// let block_number = payload.block().number;

// // assert the block has been committed to the blockchain
// node.assert_new_block(tx_hash, block_hash, block_number).await?;

// // setup payload for submission
// let envelope_v3: <E as EngineTypes>::ExecutionPayloadV3 = payload.into();

// // submit payload to engine api
// let submission = EngineApiClient::<E>::new_payload_v3(
// &self.engine_api_client,
// envelope_v3.execution_payload(),
// versioned_hashes,
// payload_builder_attributes.parent_beacon_block_root().unwrap(),
// )
// .await?;

//let f: Pin<Box<dyn Future<Output = Result<(), Error>> + Send>> =
// Box::pin(Rollup::new(ctx, connection, node)?.start());
//f

Ok(Rollup::new(ctx, node)?.start())
let rollup = Rollup::new(ctx, node)?;

let future: Pin<Box<dyn Future<Output = eyre::Result<()>> + Send>> =
Box::pin(async move {
rollup.start().await
});

Ok(future)
}) as Pin<Box<dyn Future<Output = eyre::Result<Pin<Box<dyn Future<Output = eyre::Result<()>> + Send>>>> + Send>>
})
.launch()
.await?;
Expand Down
47 changes: 26 additions & 21 deletions bin/reth/src/node.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -98,7 +98,7 @@ where
let (payload, eth_attr) = self.advance_block(vec![], attributes_generator).await?;
let block_hash = payload.block().hash();
let block_number = payload.block().number;
self.assert_new_block(tx_hash, block_hash, block_number).await?;
//self.assert_new_block(tx_hash, block_hash, block_number).await?;
chain.push((payload, eth_attr));
}
Ok(chain)
Expand Down Expand Up @@ -224,26 +224,31 @@ where
block_hash: B256,
block_number: BlockNumber,
) -> eyre::Result<()> {
// get head block from notifications stream and verify the tx has been pushed to the
// pool is actually present in the canonical block
let head = self.engine_api.canonical_stream.next().await.unwrap();
let tx = head.tip().transactions().next();
assert_eq!(tx.unwrap().hash().as_slice(), tip_tx_hash.as_slice());

loop {
// wait for the block to commit
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
if let Some(latest_block) =
self.inner.provider.block_by_number_or_tag(BlockNumberOrTag::Latest)?
{
if latest_block.number == block_number {
// make sure the block hash we submitted via FCU engine api is the new latest
// block using an RPC call
assert_eq!(latest_block.hash_slow(), block_hash);
break
}
}
}

// Simplified version for debugging
println!("Asserting new block: {}", block_number);
Ok(())

// // get head block from notifications stream and verify the tx has been pushed to the
// // pool is actually present in the canonical block
// let head = self.engine_api.canonical_stream.next().await.unwrap();
// let tx = head.tip().transactions().next();
// assert_eq!(tx.unwrap().hash().as_slice(), tip_tx_hash.as_slice());

// loop {
// // wait for the block to commit
// tokio::time::sleep(std::time::Duration::from_millis(20)).await;
// if let Some(latest_block) =
// self.inner.provider.block_by_number_or_tag(BlockNumberOrTag::Latest)?
// {
// if latest_block.number == block_number {
// // make sure the block hash we submitted via FCU engine api is the new latest
// // block using an RPC call
// assert_eq!(latest_block.hash_slow(), block_hash);
// break
// }
// }
// }
// Ok(())
}
}
Loading