tempo-node

[dependencies]
tempo-node = "0.1.0"

use tempo_node::node::TempoNode;

// TempoNode defines:
// - Primitives: TempoPrimitives (blocks, headers, transactions, receipts)
// - ChainSpec: TempoChainSpec
// - StateCommitment: StateRoot

use tempo_node::TempoFullNode;

// Type alias for:
// FullNode<TempoNodeAdapter, TempoAddOns<TempoNodeAdapter>>

use tempo_node::rpc::TempoEthApi;

// Key features:
// - Returns placeholder for eth_getBalance (native currency not used)
// - Handles 2D nonces for AA transactions
// - Routes subblock transactions to validators
// - Gas estimation for fee tokens

use tempo_node::rpc::{TempoAdminApi, TempoAdminApiServer};
use alloy_primitives::B256;

// Create admin API
let validator_key = Some(B256::from([1u8; 32]));
let admin = TempoAdminApi::new(validator_key);

// Returns validator key
let key = admin.validator_key().await?;

use tempo_node::rpc::consensus::{
    TempoConsensusRpc, TempoConsensusApiServer,
    Query, ConsensusState, CertifiedBlock
};

// Create consensus RPC (requires ConsensusFeed impl)
let consensus = TempoConsensusRpc::new(feed);

// Get latest finalization
let block = consensus.get_finalization(Query::Latest).await?;

// Get consensus state
let state = consensus.get_latest().await?;

// Subscribe to events
consensus.subscribe_events(sink).await?;

// Get identity transition proofs
let proof = consensus.get_identity_transition_proof(
    Some(epoch),
    false // only most recent transition
).await?;

use tempo_node::rpc::token::{TempoToken, TempoTokenApiServer};

// Create token API
let token_api = TempoToken::new(eth_api);

// Get tokens (paginated)
let tokens = token_api.tokens(params).await?;

// Get tokens by address
let addr_tokens = token_api.tokens_by_address(params).await?;

// Get role history
let history = token_api.role_history(params).await?;

use tempo_node::node::TempoNodeArgs;

// Includes:
// - Validator configuration
// - RPC settings  
// - Network parameters
// - Database paths

use tempo_node::node::TempoPoolBuilder;

// Implements PoolBuilder<Node> for Tempo
// Handles:
// - AA transaction validation
// - 2D nonce tracking
// - Validity windows (valid_before/valid_after)
// - Fee token balance checks

use tempo_node::telemetry;

// Initialize telemetry with OpenTelemetry
tempo_node::telemetry::init();

use tempo_node::{version_metadata, init_version_metadata};

// Initialize version info at build time
init_version_metadata();

// Access version info
let version = version_metadata();
println!("Version: {}", version.version);
println!("Commit: {}", version.commit_hash);

// Re-exports
pub use tempo_consensus as consensus;
pub use tempo_evm as evm;
pub use tempo_primitives as primitives;

use tempo_node::engine;

// Located in crates/node/src/engine.rs
// Handles:
// - Engine API RPC methods
// - Block building coordination
// - Payload assembly

use tempo_node::rpc::SUBBLOCK_TX_CHANNEL_CAPACITY;

// Channel capacity for subblock transactions: 10,000
// High enough to prevent legitimate transactions from being evicted
// during high-load scenarios

use tempo_node::rpc::NATIVE_BALANCE_PLACEHOLDER;
use alloy_primitives::U256;

// Placeholder returned by eth_getBalance
const PLACEHOLDER: U256 = uint!(4242424242424242424242424242424242424242424242424242424242424242424242424242_U256);

use tempo_node::{
    node::{TempoNode, TempoNodeArgs, TempoPoolBuilder},
    rpc::{TempoEthApiBuilder, TempoAdminApi, TempoConsensusRpc},
};
use reth_node_builder::{NodeBuilder, NodeConfig};

#[tokio::main]
async fn main() -> eyre::Result<()> {
    // Parse CLI args
    let args = TempoNodeArgs::parse();
    
    // Build node
    let node = NodeBuilder::new(NodeConfig::default())
        .with_types::<TempoNode>()
        .with_components(TempoNode::components())
        .with_add_ons(TempoNode::add_ons(args))
        .build()?;
    
    // Launch node
    node.launch().await?;
    
    Ok(())
}