Bitcoin Core is the reference implementation of a Bitcoin full node. It connects to the Bitcoin peer-to-peer network to download and fully validate blocks and transactions according to consensus rules. The system includes a full node daemon (bitcoind), a command-line interface (bitcoin-cli), a graphical user interface (bitcoin-qt), and a set of utility tools (bitcoin-tx, bitcoin-wallet, bitcoin-util). The architecture is modular: a kernel library (libbitcoinkernel) encapsulates consensus-critical code, a node layer manages networking, mempool, and chainstate, a wallet subsystem handles key management and transaction signing, and an IPC layer supports multiprocess separation. External dependencies include LevelDB (storage), libsecp256k1 (elliptic curve cryptography), ZeroMQ (notifications), and Qt (GUI). The system exposes JSON-RPC and REST APIs for programmatic interaction, and supports advanced features like BIP324 encrypted P2P transport, compact block relay, assumeutxo snapshots, and descriptor-based wallets.
ADAMANT Forging Pool is a blockchain service that calculates and distributes delegate voter rewards on the ADAMANT network. It consists of a Node.js/Express backend that processes forged blocks, computes voter rewards, handles scheduled payouts, and maintains MongoDB storage for blocks, voters, and transactions. The system features a Svelte/Vite web dashboard for monitoring pool status and voter rewards, plus a control CLI (`adm-pool`) for managing encrypted passphrases. Key security features include operator-encrypted passphrases, input validation to prevent NoSQL injection, and secret-free health monitoring. The architecture follows a modular design with clear separation between API handling, business logic, data storage, and external integrations.
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.
Bitcore is a comprehensive, production-grade monorepo for building multi-blockchain wallet infrastructure and blockchain data services. It provides a full stack including core cryptographic libraries (bitcore-lib for BTC, BCH, LTC, DOGE), wallet management (bitcore-wallet-service), client SDKs (bitcore-wallet-client), a blockchain indexer and API node (bitcore-node), a CLI wallet, and a React-based block explorer (insight). The architecture is modular with each cryptocurrency having its own package, but shares significant code duplication across coin-specific libraries. The system supports UTXO-based chains (BTC, LTC, DOGE, BCH) and account-based chains (EVM, Solana, XRP), including threshold signature schemes (TSS) and multi-sig wallets. External API adapters (Alchemy, Moralis) and fiat on-ramp integrations (Wyre, Banxa, Simplex, Transak) provide production features. The codebase is written primarily in TypeScript and JavaScript, with extensive test coverage and operational scripts. While functionality is rich, technical drift is medium due to duplicated code across coin libraries, outdated dependencies (sjcl, request, Gulp), and some deprecated patterns.
NBitcoin is a comprehensive .NET library for Bitcoin and altcoin protocol support. It provides low-level primitives for transactions, blocks, keys, scripts, addresses, HD wallets (BIP32/39), PSBT (BIP174/370), Taproot/Schnorr, and a full P2P networking stack. The library also includes internal cryptographic implementations (secp256k1, SHA-256, BouncyCastle) and supports 30+ altcoins via custom network definitions and consensus factories. It is used in production by BTCPay Server, Wasabi Wallet, and other Bitcoin infrastructure. The architecture is a set of interconnected NuGet packages (NBitcoin, NBitcoin.Altcoins, NBitcoin.Secp256k1, NBitcoin.TestFramework, NBitcoin.Bench) with extensive integration tests that run against real Bitcoin Core nodes. While the core library is well-engineered with clean abstractions, the altcoin surface introduces some duplication and conditional compilation complexity, and the internal BouncyCastle fork may diverge from upstream. Overall, it is a high-quality, actively maintained library with strong reusability of its core components.
This repository is a PHP library for creating Apple Wallet passes (.pkpass files) and related functionality. It provides classes to generate, sign, and package passes according to Apple's Wallet specifications, including support for boarding passes, store cards, event tickets, and financial orders. The library handles certificate-based signing, file inclusion, localization, and pass creation through a clean object-oriented interface. The architecture centers around the PKPass class which implements the core pass creation logic, including manifest generation, signature creation using OpenSSL, and ZIP packaging. FinanceOrder extends PKPass for financial transaction orders with order-specific constants and SHA-256 hashing. PKPassBundle enables combining multiple passes into a single .pkpasses file for bulk distribution. The Push class handles Apple Push Notification Service (APNS) integration for sending pass updates to devices. Key features include flexible data input (arrays or JSON strings), file management (local, remote, and string content), localization support, and proper error handling through custom exceptions. The library requires PHP 7.0+ with ZIP, JSON, and OpenSSL extensions, and includes comprehensive testing via PHPUnit.
Unicity Sphere is a self-custodial Web3 wallet and agent platform implemented as a React 19 single-page application. It provides wallet creation/restore (with mnemonic backup, password, and file import), direct messaging and group chat (via Nostr relays), a marketplace for agents and apps with reviews and quests, dApp connectivity through the Sphere Connect protocol (iframe agents and popup), and subscription-based quota management for aggregator API access. The architecture is a client-side SPA with a desktop-like shell (tabs, taskbar, wallet panel) using TanStack Query for server state, Framer Motion for animations, and Tailwind CSS for styling. Key entry points include the onboarding flow (CreateWalletFlow), the main wallet panel (WalletPanel), the Connect provider (ConnectProvider), and the desktop layout (DesktopLayout). External dependencies include the @unicitylabs/sphere-sdk for core wallet operations, a local @unicitylabs/sphere-ui package, REST APIs for marketplace and subscription gateway, and Sentry for error monitoring. The codebase has extensive unit and e2e test coverage with a strong focus on security invariants (duplicate send guards, settle shields, origin verification), though a security audit identified 131 findings including unencrypted seed storage and phishing risks. The project is actively maintained with frequent commits and issue triage, but exhibits tight coupling to the SDK and complex state machines that pose maintenance risks.
This repository implements the Dusk Network blockchain node (Rusk), a full Proof-of-Stake node with privacy-preserving transactions (Phoenix) and public transactions (Moonlight). The system is a Rust workspace containing a consensus engine (succinct attestation consensus with proposal/validation/ratification steps), a WebAssembly-based smart contract VM (Piecrust), a RocksDB/SQLite ledger, a mempool, an HTTP/GraphQL API server (Axum), and a CLI/TUI wallet. It also includes a JavaScript SDK (w3sper.js) for browser/Deno wallet interaction and a wallet-core library compilable to WASM. The architecture is modular: the node binary (rusk/src/bin/main.rs) composes services via a builder pattern (RuskNodeBuilder), supporting both full-chain and HTTP-only modes. Key data flows include transaction submission via RUES (Rusk Event System) or GraphQL, consensus message propagation over Kadcast P2P, block execution through the VM with hard-fork feature gating, and state persistence via RocksDB column families. External dependencies include dusk-plonk, dusk-poseidon, jubjub-schnorr, wasmtime, rkyv, and sqlx. The codebase demonstrates high craftsmanship in areas like deterministic committee sortition, zero-knowledge proof verification caching, and a reusable data-driver pattern for contract encoding/decoding.
nOS Client is an Electron-based desktop application that serves as a wallet and decentralized application (dApp) browser for the NEO blockchain. It provides a virtual operating system metaphor with a built-in webview-based browser, account management, portfolio tracking, token transfers, and GAS claiming. The app integrates with the NEO network via neon-js, supports hardware wallets (Ledger) and mnemonic-based key management, and exposes a custom JavaScript API (NOS.V1) to dApps through a request processor. The codebase is organized as a standard React/Redux SPA with multiple feature modules (auth, browser, account, settings, appstore) and heavy use of higher-order components for state management. The application is feature-rich but shows its age: dependencies are heavily outdated (Electron 2.x, Webpack 3, React 16.8 with recompose), and some sections like Exchange and Favorites are incomplete placeholders. Despite this, the core wallet and dApp browsing functionalities are implemented with reasonable modularity, though the reliance on legacy patterns and unmaintained libraries makes it risky to reuse without modernization.