immudb is an immutable, cryptographically verifiable database system designed for tamper-evident storage. It provides ACID transactions with cryptographic verification via Merkle trees, ensuring data integrity and historical auditability. The system supports multiple data models: key-value, SQL (with PostgreSQL wire protocol compatibility), and document storage. Architecture follows a modular client-server design with separate binaries for server (immudb), admin CLI (immuadmin), client CLI (immuclient), and test tool (immutest). Key entry points include cmd/immudb/immudb.go (server), cmd/immuadmin/immuadmin.go (admin), and cmd/immuclient/immuclient.go (client). Data flows involve clients sending requests via gRPC or PostgreSQL wire protocol to the server, which processes transactions, appends to an immutable log, updates verification structures, and returns verifiable responses. External dependencies include Go modules for gRPC, protobuf, Viper, cryptographic libraries, and optional S3/MinIO for remote storage. The codebase demonstrates strong engineering practices with clear separation of concerns, extensive testing, and active maintenance.
Sunlight is a production-grade, static Certificate Transparency (CT) log implementation written in Go, sponsored by Let's Encrypt. It implements the C2SP Static CT API and provides both a write-path log server (cmd/sunlight) and a read-path static file server (cmd/skylight). The system accepts certificate submissions via the RFC 6962 add-chain/pre-chain endpoints, sequences them into a Merkle tree using the tlog library, and publishes tiles (hash, data, names) along with signed checkpoints. It also supports the tlog-witness and tlog-mirror protocols for transparency and cross-checking. The architecture is modular: the core log engine lives in internal/ctlog with pluggable backends for storage (local filesystem, S3, in-memory) and distributed locking (SQLite, DynamoDB, ETag-based S3). The sequencer uses a pool of pending entries with low-priority eviction, batched sequencing, and staged uploads via tarballs for crash recovery. Deduplication is handled via a SQLite cache with 256-bit hashes. The system includes extensive observability with Prometheus metrics, structured logging, and debug endpoints for heavy hitters and SSL key logging. Key entry points include the main server binaries (cmd/sunlight, cmd/skylight), a key generation tool (cmd/sunlight-keygen), a partial tile garbage collector (cmd/partial-aftersun), a cache recomputation tool (cmd/recompute-cache), and a names tile generator (cmd/names-prism). The client library (client.go) provides a high-level API for fetching and verifying log entries and inclusion proofs. External dependencies include certificate-transparency-go, torchwood, and golang.org/x/mod/sumdb/tlog. The codebase demonstrates high craftsmanship with several reusable internal packages: durable crash-safe file writes, immutable file flag setting, HyperLogLog cardinality estimation, Space Saving heavy hitters, and a custom XAES-256-GCM implementation. Testing is extensive, including in-memory fake backends, synctest for time-dependent rate limits, and deterministic test data generation.
This repository is the Rust implementation of the Minotari/Tari base-layer blockchain protocol. It is primarily a large application monorepo, although it embeds deep cryptographic and consensus research. In production, it ships as several runnable binaries: a base node (minotari_node), a console wallet (minotari_console_wallet), a SHA-3 miner (minotari_miner), a Monero merge-mining proxy (minotari_merge_mining_proxy), an offline signer, and experimental MCP servers (minotari_mcp_node, minotari_mcp_wallet) that expose node and wallet capabilities to AI agents. The node validates and stores blockchain data using LMDB for chain state and SQLite for peer/wallet/DHT metadata, synchronizes via block/header/horizon sync state machines, and communicates over a custom stack combining TCP/Tor transports, Noise encryption, and a DHT for discovery and message propagation. Wallets construct confidential transactions with Pedersen commitments, range proofs, covenants, and one-sided payments, and expose gRPC/HTTP APIs. Architecturally, the workspace is divided into base-layer crates (core, wallet, transaction_components, mmr, p2p, sidechain), a custom comms stack (comms/core, comms/dht), shared infrastructure (service_framework, storage, shutdown, metrics, derive, hashing), and application binaries. The service framework uses Tower-style initializers and reply channels; the consensus layer includes multiple PoW algorithms (SHA3x, Cuckaroo, Monero RandomX), validation pipelines, mempool management, reorg handling, and sidechain validator-node logic. Data flows from transaction construction in the wallet through gRPC/HTTP submission to the node's mempool, then into block templates, validation, and LMDB chain storage; P2P messages propagate over the DHT/Tor transport. Code quality is generally strong: core components have extensive integration tests, benches, CI workflows, and careful error typing. The MMR, sparse Merkle tree, hashing, and dedup cache components are cleanly isolated and reusable. However, the size of the codebase leads to some rough edges: MCP servers contain placeholder implementations, wallet FFI code relies on raw unsafe, and a few modules carry stale comments or dead code. Overall, this is a professionally maintained blockchain implementation rather than an experimental research repo.