This repository is a community-maintained, curated registry of EVM-compatible blockchain networks. It contains thousands of JSON files under `_data/chains/`, each defining a chain's metadata: RPC endpoints, native currency, explorers, icons (IPFS CIDs), status (active/deprecated/incubating), parent L2 relationships, and feature flags. The dataset is the primary asset, designed for consumption by wallets, dApps, block explorers, and infrastructure tooling that needs up-to-date chain information. Beyond the data, the repository includes a Kotlin-based processor that validates all chain definitions (schema compliance, icon size/format, IPFS retrievability, ENS address checks) and produces aggregated `chains.json` and `chains_mini.json` outputs. A published Kotlin model library (`model/`) and an HTTP loader (`httpsloader/`) enable programmatic access. CI pipelines enforce formatting, schema validation, and per-PR checks. The project is hybrid: its core value is the dataset, but it also delivers a well-engineered application layer for validation, aggregation, and distribution. The registry answers questions like 'What RPC endpoints are available for chain X?', 'What is the native currency of chain Y?', 'Which chains are L2s of Ethereum?', and 'What explorers support EIP3091?'. It serves as a single source of truth for EVM chain metadata, reducing fragmentation across the ecosystem.
Hey is a decentralized social media application built on the Lens Protocol. It provides a full-featured frontend for users to interact with the Lens blockchain, including wallet authentication, post creation and engagement (likes, comments, reposts, collects, tips), group management, notifications, and profile customization. The application uses React 19 with Vite for bundling, TypeScript for type safety, and Tailwind CSS for styling. State management combines Apollo Client for GraphQL data persistence with Zustand stores for client-side state (account, notifications, preferences). Key architectural patterns include optimistic UI updates for blockchain transactions, portal-based modals, and custom hooks for transaction handling and media uploads. The codebase demonstrates strong modularity with reusable UI components and clear separation between UI, state management, and data layers.
OrbitDB is a serverless, peer-to-peer distributed database library built on IPFS and libp2p. It provides a Merkle-CRDT (conflict-free replicated data type) log as its core primitive, supporting multiple database types like Events (append-only log), Documents (indexed JSON), KeyValue, and KeyValueIndexed. The architecture is modular: it separates storage backends (memory, LevelDB, IPFS blocks, LRU cache), identity management (pluggable providers), access control (static ACL or dynamic ACL stored in a keyvalue database), and encryption (pluggable). The primary entry point is `createOrbitDB()`, which returns an OrbitDB instance that can open databases of any registered type. Data flows involve appending operations to an immutable, signed log of IPLD entries, syncing with remote peers via pubsub-based replication, and handling conflict resolution using Last-Write-Wins. External dependencies include Helia (IPFS), libp2p, LevelDB, and various multiformats libraries. The library is designed for both Node.js and browser environments, with a comprehensive test suite covering unit and integration scenarios.
EdgeVPN is a decentralized peer-to-peer VPN and overlay networking tool built on libp2p. It provides a VPN tunnel (TUN interface), TCP service tunneling (ngrok-like), HTTP egress proxy, DNS resolution, file transfer, and a distributed ledger for network state coordination. The architecture is a single Go binary with an embedded React SPA dashboard, exposing a REST API (Echo framework) and CLI (urfave/cli v2). The core innovation is a blockchain-style ledger that stores machine, service, DNS, and health records, with optional signed ownership enforcement and liveness-based reaping. The system uses libp2p for peer discovery (DHT, mDNS), pubsub (gossipsub), relays, and circuit v2. It is designed for decentralized networks without central coordination, and is used in production by Kairos (Kubernetes) and LocalAI (P2P distribution). The codebase demonstrates strong engineering with functional options patterns, comprehensive test suites, documentation generation from CLI code, and a design system for the React UI. However, it carries technical debt from experimental features (PeerGuard, DHCP, IPv6), a forked libp2p-pubsub dependency, and documentation drift that requires manual regeneration.
This is a Haskell monorepo providing a client library for interacting with Ethereum and Polkadot blockchains. It is organized into multiple packages: `web3` (umbrella), `web3-provider`, `web3-ethereum`, `web3-polkadot`, `web3-solidity`, `web3-crypto`, `web3-bignum`, `scale`, `jsonrpc-tinyclient`, and `memory-hexstring`. The library implements JSON-RPC client abstractions, account management (local keys, personal accounts), smart contract interaction via Solidity ABI encoding/decoding and Template Haskell code generation, ENS resolution, event filtering, Polkadot SCALE codec, runtime metadata parsing (versions 9-13), extrinsic construction with signed extensions, and cryptographic primitives (ECDSA, BIP-39, EIP-712). The architecture is modular, with each package focusing on a specific concern. Key entry points include `Network.Web3.Provider` for connecting to nodes, `Network.Ethereum.Contract.TH` for generating contract bindings, and `Network.Polkadot.Extrinsic` for building and signing transactions. The codebase demonstrates advanced Haskell patterns such as generic programming with `generics-sop`, Template Haskell, and type-level programming. While the library is well-structured and covers a broad set of blockchain interactions, there are signs of technical drift: some metadata versions are partially implemented, commented-out code exists, and dependency bounds are tight. Overall, it is a solid, actively maintained library suitable for Haskell-based blockchain development.
Fireproof is a local-first, real-time document database with CRDT-based conflict resolution, end-to-end encryption, and multi-platform support (browser, Node.js, Deno, Cloudflare Workers). The monorepo contains the core database engine (`@fireproof/core`), a cloud sync backend (Hono + Durable Objects), a dashboard web application for tenant/ledger management, a CLI tool for build and DevOps tasks, and a React hooks library (`use-fireproof`). The architecture is modular with clear separation between storage gateways (IndexedDB, filesystem, memory, cloud), key management (KeyBag with fingerprinting), device identity (X.509-like PKI), and protocol layers (WebSocket/HTTP message dispatch). The codebase exhibits strong engineering practices including extensive TypeScript usage, comprehensive testing (though some tests are skipped or known to fail), and reusable patterns like the Gateway interceptor, Result type, and Evento command pipeline. However, complexity is high due to multiple runtime targets and active refactoring between versions, and there are known critical bugs (e.g., remote sync not triggering subscriptions in React hooks).
Berty is a full-stack, privacy-focused, peer-to-peer messaging application. The system consists of a Go backend implementing the Wesh protocol (based on IPFS, libp2p, and OrbitDB) that provides core messaging, push notifications, authentication, replication, and directory services. The backend is exposed via gRPC and consumed by multiple clients: a React Native mobile app (with both a legacy JS variant and a newer Expo-based variant), a Go CLI with a terminal UI (mini) and a desktop GUI (Fyne), and native bridges for iOS and Android. The architecture is modular, with separate packages for error handling, authentication, push relay, and bot framework. Key entry points include the `berty daemon` CLI command, the mobile app entry points (`App.tsx` in both `js/packages` and `berty-bridge-expo/mobile`), and the bridge framework (`go/framework/bertybridge`). Data flows involve gRPC streams from the Go backend to the mobile clients, with event-driven state management and local encrypted storage via SQLCipher. External dependencies include libp2p, OrbitDB, gRPC, protobuf, and various platform-specific native modules for BLE, mDNS, and push notifications. The repository also contains auxiliary tools for infrastructure testing, rendezvous servers, and debugging (Tyber).
Snapshot is a decentralized, off-chain, gasless governance platform for DAOs and communities. This repository is the legacy (v1) frontend client, a Vue 3 single-page application (SPA) built with TypeScript, Vite, and Tailwind CSS. It provides a full-featured interface for creating and managing governance spaces, submitting proposals, voting (single-choice, approval, quadratic, ranked-choice, weighted), delegating voting power, and configuring treasury execution via plugins like oSnap and safeSnap. The application interacts with Ethereum and other EVM-compatible chains through Web3 wallets (MetaMask, WalletConnect), fetches on-chain data via subgraphs and RPC calls, and stores proposal content and vote receipts on IPFS. Key entry points include the space creation wizard (SetupView), proposal creation (SpaceCreate), proposal listing and voting (SpaceProposals, SpaceProposal), space settings (SpaceSettings), delegation management (SpaceDelegates), and a boost incentive system (SpaceBoost). The architecture follows a composable-first pattern with extensive use of Vue 3 Composition API, a plugin system for extensible governance features, and a custom UI component library (Tune). External dependencies include @snapshot-labs/snapshot.js for voting logic, @snapshot-labs/lock for wallet connection, Apollo Client for GraphQL queries, and various blockchain APIs (Alchemy, Covalent, Tenderly). The codebase is well-structured but shows signs of technical drift: duplicate code between safeSnap and oSnap plugins, hardcoded API keys, deprecated Vite plugin APIs, and incomplete localization files.