//! This example demonstrates how alloy's RPC types and consensus types are tied together.
//!
//! Consensus types are used in Ethereum execution layer consensus and communication. These include
//! transactions, headers, blocks, [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) envelopes, [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930), [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844), and more.
//!
//! The RPC types are used to communicate with Ethereum nodes.
//!
//! In the case of alloy, the consensus types are embedded into the RPC types unlocking a ton of
//! simplications across these two categories of types and also preventing accidental divergence
//! between the two.
//! This has been achieved without altering the resultant serialized JSON-RPC representations.
//!
//! One can easily convert the RPC types to their consensus counterparts using the `into_consensus`,
//! `into_inner` or in the case of transactions `into_recovered` methods.
//!
//! See:
//!
//! - [Embed consensus `Header` into RPC type](https://github.com/alloy-rs/alloy/pull/1573)
//! - [Embed `TxEnvelope` into RPC `Transaction`](https://github.com/alloy-rs/alloy/pull/1460)
//! - [Embed consenus `Log` and `Receipt` into respective RPC types](https://github.com/alloy-rs/alloy/pull/396)
 
use alloy::{
    eips::BlockId,
    primitives::b256,
    providers::{Provider, ProviderBuilder},
};
use eyre::OptionExt;
 
#[tokio::main]
async fn main() -> eyre::Result<()> {
    let provider = ProviderBuilder::new().connect("https://reth-ethereum.ithaca.xyz/rpc").await?;
 
    // Get the latest block from the RPC.
    let block = provider.get_block(BlockId::latest()).await?.ok_or_eyre("Block not found")?;
    // The immediate type returned is the RPC `Block` type which consists of the relevant consensus
    // types.
    assert!(matches!(block, alloy::rpc::types::Block { .. }));
    // This rpc block type contains the RPC `Header` type which encapsulates the consensus `Header`
    // type.
    // Easily access the consensus `Header` type without having to rebuild into another type.
    // If one needs to map the header or transaction to a different type, the following mapping
    // methods can be used: `try_map_header`, `map_header`, `try_map_transactions`,
    // `map_transactions`.
    assert!(matches!(block.header.inner, alloy::consensus::Header { .. }));
    // One can use the `into_consensus` method to get the consensus representation of the block.
    let consensus = block.into_consensus();
    assert!(matches!(consensus, alloy::consensus::Block { .. }));
 
    // Similarly, the RPC `Transaction` and `TransactionReceipt` types encapsulate their
    // corresponding consensus types.
 
    // Get a transaction by hash
    // <https://etherscan.io/tx/0x5b470467985bfd34f18979b5438ffce4f2a309a32bcc857fcbf48c4e4253ce16>
    let tx_hash = b256!("0x5b470467985bfd34f18979b5438ffce4f2a309a32bcc857fcbf48c4e4253ce16");
    let tx =
        provider.get_transaction_by_hash(tx_hash).await?.ok_or_eyre("Transaction not found")?;
    assert!(matches!(tx, alloy::rpc::types::Transaction { .. }));
    // The RPC `Transaction` type wraps a `Recovered<T>` containing the consensus `Transaction`
    // type.
    // The `Recovered<T>` consists of the signer recovered from the signature.
    // Unifying these reduces verbosity and allows for any one of the types using simple helper
    // methods as shown below.
    let recovered_tx = tx.into_recovered();
    assert!(matches!(recovered_tx, alloy::consensus::transaction::Recovered { .. }));
    assert!(matches!(recovered_tx.inner(), alloy::consensus::EthereumTxEnvelope::Eip1559(_)));
 
    let receipt = provider
        .get_transaction_receipt(tx_hash)
        .await?
        .ok_or_eyre("Transaction receipt not found")?;
    assert!(matches!(receipt, alloy::rpc::types::TransactionReceipt { .. }));
    // The `TransactionReceipt` type contains the consensus `ReceiptEnvelope` type.
    assert!(matches!(receipt.inner, alloy::consensus::ReceiptEnvelope::Eip1559(_)));
 
    Ok(())
}