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.
Freqtrade is a production-grade cryptocurrency trading bot written in Python. It provides a full-fledged platform for designing, backtesting, and executing automated trading strategies across major exchanges (Binance, Kraken, Bybit, OKX, etc.) via the CCXT library. The bot supports both spot and futures trading, dry-run simulation, and live deployment with docker and systemd integration. At its core, it exposes a plugin architecture for strategy definitions, pairlist filters, and risk protection modules, all configured through a unified YAML/JSON configuration system. It also includes an embedded REST API and WebSocket server for remote monitoring and control, with optional Telegram and Discord notification channels. Beyond live trading, freqtrade offers a comprehensive research subsystem: a deterministic backtesting engine with realistic fee/slippage modeling, hyperparameter optimization (hyperopt) using Optuna with over a dozen loss functions, and a machine learning module (FreqAI) that integrates sklearn, XGBoost, LightGBM, PyTorch, and reinforcement learning (SB3). The codebase includes tools for lookahead and recursive analysis to detect strategy biases, plus data download/convert/clean utilities supporting multiple storage formats (feather, parquet, JSON). Architecturally, the project follows a modular design with clear separation of concerns: exchange abstraction layer, strategy resolver, data provider, persistence (SQLAlchemy), and RPC multiplexing. It uses dependency injection through resolvers, a logging mixin for debounced messages, and a custom scheduler for periodic tasks. The test suite is extensive with over 800 test files covering all major components. While the codebase is large and some modules (e.g., exchange-specific subclasses) are tightly coupled to CCXT, many internal patterns such as the plugin system, resolver, and data handler interfaces are well-abstracted and could be extracted for reuse in other Python trading or data pipeline projects.
Lightning Network Daemon (lnd) is a full-featured Lightning Network node implementation written in Go. It enables users to participate in the Lightning Network by opening and managing payment channels, sending/receiving payments, routing payments for others, and enforcing channel contracts via blockchain monitoring. The architecture is modular, separating concerns into distinct subsystems: peer-to-peer networking (brontide, lnpeer), channel state management (channeldb, chanstate, lnwallet), payment switching and routing (htlcswitch, routing), blockchain monitoring (chainntnfs), contract enforcement (contractcourt), RPC services (lnrpc), watchtower functionality, and autopilot for automated channel management. Key entry points include the daemon (cmd/lnd/main.go), CLI (cmd/lncli/main.go), and various RPC servers. Data flows involve processing peer messages to update channel state, persisting state to pluggable backends (BoltDB, PostgreSQL, SQLite, etcd), monitoring blockchain events affecting channels, and handling RPC commands for node control and queries. External dependencies include Bitcoin full nodes (bitcoind/btcd or Neutrino), database libraries, and various Go utilities (btcutil, btcec, gRPC).
This repository is a curated, version-controlled taxonomy of cryptocurrency and blockchain ecosystems and their associated GitHub repositories. It is the dataset behind Electric Capital's developer activity reports. The primary artifact is a large collection of timestamped migration files (a custom DSL using commands like `repadd`, `ecoadd`, `ecocon`) that incrementally build a graph mapping ecosystems to repositories with tags. The dataset spans over a decade (2014–2026) and includes hundreds of thousands of repository entries across dozens of ecosystems, from major chains (Ethereum, Bitcoin, Stellar) to niche projects and hackathon submissions. The repository also provides a Python CLI tool (`open-dev-data`) for validating migrations, exporting the taxonomy as JSON Lines or Parquet, downloading the full dataset with resumable transfers and integrity checks, and exploring it locally via DuckDB and an interactive TUI (Harlequin). The codebase is well-structured, with clean abstractions for the data model, timestamp handling, and shell-like command parsing. However, the dataset itself suffers from significant noise—many entries are student hackathon repos, boilerplate forks, or duplicate URLs—which dilutes its signal for research. The curation is manual and not automatically deduplicated. Despite this, the taxonomy and tooling are highly reusable for any domain needing a version-controlled, hierarchically categorized registry of external projects.
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.
CCXT is a cryptocurrency exchange trading library that provides a unified API for over 100 exchanges across 7 programming languages (TypeScript/JavaScript, Python, PHP, C#, Go, Java). The core is written in TypeScript from which all other language bindings are transpiled. It implements both REST and WebSocket APIs for market data, trading, and account management. The library normalizes exchange-specific data formats into a common schema, enabling cross-exchange arbitrage and analytics. Key architectural patterns include a base Exchange class with exchange-specific subclasses, a pro/ subdirectory for WebSocket-enabled exchanges, static_dependencies/ for vendored third-party code (ethers, starknet, bip39, etc.), and an extensive test suite with both static and live tests. The repository includes a playground (Next.js web IDE), CLI tool, documentation site (Fumadocs), CI/CD for all languages, and Docker development environment.
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.
The Java Stellar SDK is a comprehensive client library for interacting with the Stellar blockchain network, providing both Horizon REST API bindings and Soroban smart contract support. It handles transaction construction, signing, and submission, as well as account management, asset operations, liquidity pools, and decentralized exchange path finding. The library is built on a robust XDR codec layer generated from protocol definitions, with handcrafted decoders that enforce depth limits and size constraints for safe binary parsing. It also includes a SPI-based platform abstraction for Base32/Base64 encoding to support Android deployments, and a sophisticated contract client that manages Soroban transaction lifecycle (simulation, restoration, signing, and submission). The codebase is actively maintained, with a large test suite spanning Java and Kotlin, CI/CD pipelines, and support for the latest Stellar protocol features (CAP-71, CAP-85, SEP-10/45/51/53). While the XDR generation pipeline requires periodic regeneration, the core SDK abstractions are well-isolated and exhibit strong engineering practices such as builder patterns, immutable value objects, and custom Gson deserializers for Horizon response parsing.
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.
This repository is a production-grade Go library implementing a Bitcoin light client based on BIP 157/158 compact block filters (Neutrino). It is designed for mobile Lightning Network wallets and provides SPV (Simplified Payment Verification) without requiring a full node. The core architecture revolves around a ChainService that orchestrates peer connections, block header sync, filter header sync, UTXO queries, transaction broadcasting, and chain rescanning. The library stores headers in flat files with bbolt-backed indices, and filters in a boltdb database. It includes a sophisticated peer query management system with retry, timeout, and banning logic, as well as caching layers for blocks and filters. The codebase is well-structured into subpackages with clear responsibilities, many of which are reusable in other Go projects. It is actively maintained by Lightning Labs and used in production by lnd (Lightning Network Daemon).
Jesse is a mature, full-stack algorithmic trading framework designed for cryptocurrency backtesting, live/paper trading, hyperparameter optimization, Monte Carlo simulation, and rule significance testing. It combines a Python library with a FastAPI web server and a Nuxt.js dashboard, offering a comprehensive environment for developing and validating trading strategies. The repository also includes an MCP (Model Context Protocol) server for AI-assistant integration, over 180 technical indicators (many with Rust-accelerated backends), and a research API for programmatic strategy analysis. Architecture is modular with distinct layers: CLI entrypoint → web controllers / MCP tools → service layer → simulation engine (backtest/optimize/live) → exchange adapters. State management uses global singletons for in-memory simulation state, while persistent data is stored via Peewee ORM (PostgreSQL, optional TimescaleDB). The indicator library showcases a clean pattern with sequential/non-sequential modes and Rust fallback. However, the codebase shows signs of organic growth with some tightly coupled modules (global config, store singletons) and a large static frontend bundle that is opaque to analysis. Key strengths include the breadth of supported exchanges (10+), robust backtesting with realistic fee/margin/leverage modeling, and a well-designed MCP tool layer for AI-assisted development. Weaknesses include exchange driver duplication, a complex Rust subprocess for coordination, and dependency on many external APIs that require ongoing maintenance.
BittyTax is a Python CLI application suite for computing UK cryptocurrency tax liabilities. It consists of three console tools: bittytax_conv normalizes raw CSV/XLSX exports from approximately 80 exchanges, wallets, block explorers and accounting platforms into standardized transaction records; bittytax applies HMRC rules such as same-day matching, bed-and-breakfast, Section 104 pooling, and ten-day matching for companies, then generates PDF/Excel/console reports for capital gains, income, margin trading, holdings, and audit; bittytax_price fetches historical and latest asset prices from CoinGecko, CoinPaprika, CoinStats, Frankfurter, and BittyTaxAPI with local JSON caching. The repository is fundamentally an application rather than a data-research project: it exposes CLI entry points, has a plugin-based parser architecture, config-driven behavior, test suites, and CI pipelines, while the data-heavy parser and price modules are application subsystems rather than analytical pipelines.
Kronos is a foundation model for financial K-line (OHLCV) time series data, accepted at AAAI 2026. It introduces a novel two-stage architecture: a BinarySphericalQuantizer tokenizer that converts continuous multi-dimensional market data into hierarchical discrete tokens, followed by an autoregressive decoder-only Transformer (with RoPE, RMSNorm, hierarchical embedding, and dependency-aware layers) pre-trained on data from 45+ global exchanges. The repository provides a complete research pipeline including model definition, tokenizer training, predictor fine-tuning (via Qlib or custom CSV), backtesting, and inference through multiple interfaces (Python API, CLI examples, a Tkinter GUI, and a Flask web UI). While the core model and tokenizer demonstrate strong research craftsmanship, the codebase exhibits signs of rapid prototyping: many example scripts with overlapping functionality, hardcoded paths, AI-generated comments, and prediction outputs that sometimes degenerate to constant values or numerical instability, indicating the model is still in an experimental stage. The repository is hybrid in nature—primarily a research project with application wrappers for demonstration and evaluation.
This repository is a Python client library for the Alpha Vantage financial data API. It provides synchronous and asynchronous wrappers for accessing stock/cryptocurrency time series, technical indicators, foreign exchange rates, commodities, economic indicators, fundamental data, options, and news sentiment. The library is designed as a straightforward SDK with a decorator-based architecture that handles API key injection, URL construction, and output formatting (JSON, pandas DataFrame, CSV). The codebase includes a comprehensive test suite with mock data and integration tests. However, it exhibits technical drift: declared support for Python 2.7 (EOL), an outdated CI configuration (Travis on Ubuntu Xenial), a hardcoded version number in documentation that differs from the library version, and duplication of core logic between synchronous and async modules. The library is functional and widely used, but not exemplary in terms of modern Python practices or maintainability.
This repository implements the Steem blockchain node (steemd), a Delegated Proof-of-Stake (DPoS) consensus platform with social media features. The system processes transactions, maintains chain state via shared-memory (chainbase) or RocksDB (MIRA) backends, and exposes a JSON-RPC API for querying accounts, blocks, market history, and social features like follows and tags. It includes a plugin architecture (appbase) for modular functionality, with plugins for witness production, P2P networking, resource credits (RC), account history, market history, and more. The codebase is written in C++17 and relies heavily on the custom fc library for asynchronous I/O, cryptography, serialization, and reflection. The architecture is a monolithic node daemon with a plugin system. Key entry points are the steemd binary (programs/steemd/main.cpp) and the CLI wallet (programs/cli_wallet/main.cpp). Data flows from P2P network messages through the chain plugin to the database, with operations evaluated by evaluators and state changes persisted via chainbase or MIRA. External dependencies include Boost, OpenSSL, RocksDB, and secp256k1-zkp. The repository also contains extensive Python test scripts for API regression and integration testing. While the codebase is well-structured and demonstrates advanced C++ patterns (static_variant, multi-index containers, reflection), it shows signs of technical drift: legacy plugins coexist with appbase plugins, conditional compilation for SMT and MIRA features, and several FC_TODO comments indicating incomplete migrations. The fc library itself is a reusable foundation but tightly coupled to the project's threading model.
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.
This repository is the companion codebase for the Cyfrin Updraft 'Smart Contract Auditing, Assembly, Security, and DeFi Ultimate Course'. It contains no running application or service; instead, it provides educational materials: markdown guides for how to ask questions, answer questions, structure audit findings, and onboard for security reviews, along with issue templates and a single Solidity example file (eip712hashing.sol) demonstrating EIP-712 hashing. The repository also hosts images and links to external course videos. There are no executable scripts, API endpoints, or data pipelines. The primary function is to serve as a reference and resource for students following the video course.