Fuel Core is a production-grade Rust implementation of the Fuel blockchain node, serving as the execution layer for a modular rollup ecosystem. It operates as a full node with block production (PoA consensus via Redis leader lease), transaction pool, upgradable WASM-based execution, P2P networking (libp2p with gossipsub and request-response), an Ethereum relayer bridge, and a comprehensive GraphQL API for queries and transactions. The system uses a service-oriented architecture with clear port/adapter boundaries, allowing each subsystem (sync, compression, gas pricing, tx status management, etc.) to be independently tested and swapped. Key data flows include transaction submission through GraphQL or P2P gossip, verification by the txpool, inclusion in blocks by the producer, execution by the upgradable executor, and persistence to RocksDB. The codebase demonstrates high craftsmanship with clean abstractions, extensive integration and property-based testing, and a strong focus on performance and observability (Prometheus metrics, structured tracing). While it is primarily an application, it also includes research-grade components such as gas price algorithms (V0 and V1 with PD controllers) and block compression schemes.
celestia-node is a Go implementation of Celestia's data availability (DA) node, supporting Bridge, Light, and Full node types. It ingests blocks from a Celestia consensus network (CometBFT), erasure-codes them into Extended Data Squares (EDS), and makes shares available via libp2p-based protocols (Shwap/Shrex, Bitswap). Light nodes perform Data Availability Sampling (DAS) to probabilistically verify block availability without downloading full blocks. The system exposes a JSON-RPC API for blob submission/retrieval, header sync, state queries, and node administration. Architecturally, the application is built with Uber FX dependency injection, composing modules for P2P networking (libp2p with DHT discovery), share exchange, header syncing, state/tx client (gRPC to core), blob service, DAS coordinator, EDS store (file-based with caching), and telemetry (OpenTelemetry, Prometheus). It includes a comprehensive test suite with in-memory mock networks and Docker-based end-to-end tests. While primarily a production blockchain node, it also serves as a reference implementation for Celestia's research protocols (NMT-based proofs, erasure coding, DAS).
Anoma is an Elixir/OTP implementation of the Anoma protocol - a distributed operating system for intent-centric applications. The codebase implements a full node architecture with multiple supervised engines: Mempool (transaction submission/ordering), Ordering (consensus sequencing), Executor (parallel transaction execution), Storage (Merkelized key-value store with RocksDB/Mnesia), Shard (partitioned KV store with watermark-based concurrency), IntentPool/Solver (intent matching and composition), Logging (event persistence and replay), and Transport (gRPC/IntraNode networking with proxy-based remote node communication). The system uses Nock/Noun as its core computation model (via anoma-lib), with a Cairo backend for shielded/zero-knowledge transactions. Transactions are submitted as jammed Nock nouns, executed in isolated workers, and results flow through an event-driven architecture (event_broker). The node supports distributed operation via gRPC transport with automatic peer discovery and advertisement. Key architectural patterns: CQRS-style engines (casts for mutations, calls for queries), typed event definitions with filters (defevent macro), supervisor hierarchies with dynamic child management, and a replay mechanism that validates persisted state on restart by spinning up a mock node. The codebase follows an "examples over tests" philosophy - extensive executable examples in lib/examples/ serve as both documentation and integration tests.
This repository provides a Docker-based setup for running a Base node, which is an Ethereum Layer 2 network built on the OP Stack. It consists of two main services: an execution client (base-reth-node) responsible for transaction processing and block production, and a consensus client (base-consensus) handling the proof-of-stake mechanism and network agreement. The setup uses Docker Compose to orchestrate these services, with the execution client exposing RPC and WebSocket endpoints for external interaction and the consensus client relying on the execution client for engine API communication. The repository includes multi-stage Docker builds to compile the Rust-based clients from source, entrypoint scripts that handle configuration, authentication, and optional features like Flashblocks and historical proofs, and a Supervisor configuration to manage both client processes. While the code is functional and follows Docker and Rust best practices, it is largely boilerplate for setting up a blockchain node and contains few reusable components beyond a utility function for public IP detection. Importantly, the repository has been archived, with development and releases moved to the `base/base` repository, meaning this codebase is no longer maintained and users are directed to the new location for updates and support.