ethers.js is a production-grade TypeScript library for interacting with Ethereum-compatible blockchains, compiled to dual ESM and CommonJS packages with browser-specific module replacements (crypto, base64, geturl, ws, wordlists). The architecture is a modular facade: a top-level barrel (src.ts/index.ts) re-exports sub-modules for ABI encoding, address handling, contracts, crypto primitives, hashing, providers, transactions, utilities, wallets, and BIP-39 wordlists. The provider layer is the deepest abstraction — an AbstractProvider base class with polling/socket/filter-ID subscriber contracts, plus concrete implementations for JSON-RPC, WebSocket, IPC, browser-injected wallets (EIP-1193/6963), and community services (Infura, Alchemy, Etherscan, Chainstack, Ankr, QuickNode, Blockscout, Pocket, Cloudflare) with hardcoded community API keys and once-per-service throttle messages. Network-specific behavior is customizable through a plugin system (GasCostPlugin, EnsPlugin, FeeDataNetworkPlugin), and a FallbackProvider aggregates backends with quorum logic.
This repository is the official TypeScript SDK for the Fuel Network blockchain, structured as a monorepo using pnpm and Turbo. It provides a comprehensive suite of libraries for wallet management, transaction construction, smart contract interaction (contracts, predicates, scripts), and code generation from Sway ABIs. The codebase includes a CLI tool (`fuels`) for project scaffolding, building, deploying, and running local test nodes. It supports both Node.js and browser environments, evidenced by dual build configurations and React-based dApp templates. The architecture relies heavily on generated GraphQL operations and external binary dependencies (`forc`, `fuel-core`) which are managed internally via installation scripts.
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.
Blockscout is an open-source blockchain explorer for EVM-compatible chains, written in Elixir using the Phoenix framework. It indexes and serves on-chain data including blocks, transactions, internal transactions, token transfers, token balances, contract code, and more. The system is composed of four umbrella apps: `explorer` (database schemas, chain import pipeline, caching), `block_scout_web` (Phoenix web server with REST API v2, JSON-RPC, GraphQL, and real-time WebSocket channels), `indexer` (background fetchers that pull data from Ethereum nodes using JSON-RPC), and `ethereum_jsonrpc` (transport abstraction with chain-specific variants for Geth, Nethermind, Besu, etc.). The architecture is a monolith with clear separation of concerns, using PostgreSQL as the primary store, ETS/ConCache for caching, and Oban for async job processing. It supports multiple chain types (Ethereum, Optimism, Arbitrum, Celo, ZkSync, Scroll, and more) via compile-time and runtime configuration, with chain-specific data models and import pipelines. External dependencies include a PostgreSQL database, an Ethereum JSON-RPC endpoint, optional microservices for smart contract verification (Rust verifier, Sourcify), and third-party market data providers (CoinGecko, DefiLlama). The frontend is a single-page application built with jQuery and custom JavaScript, with real-time updates via Phoenix Channels. The codebase is well-structured with extensive use of Elixir behaviours (BufferedTask, Import.Runner, FillingMigration) and a sophisticated caching layer. It is actively maintained with frequent releases, thorough CI/CD, and a large community.
This is a Avalanche blockchain faucet service that allows users to request test tokens for various EVM-compatible networks and subnets. The application consists of a Node.js/Express.js backend with a React.js frontend. It implements sophisticated rate limiting (global, IP-based, wallet-based, and common token disbursal), captcha verification (reCAPTCHA v2/v3), and a pipeline check system requiring either mainnet balance validation or coupon redemption for token requests. The service supports multiple EVM chains and ERC20 tokens, with automatic nonce and balance management, transaction queuing, and mempool limit handling. Key architectural features include modular middleware, decoupled services for coupon and mainnet checking, and clean separation between blockchain interaction logic and API handling.
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.
The Eleven is a full-stack prediction market platform for live football events, deployed on X Layer (chain 196) using Uniswap v4 hooks. The system is powered by 11 autonomous AI agent personas (e.g., IlRegista, IlBomber) that monitor live match data from API-Football or Football-Data.org, evaluate binary propositions (e.g., clean sheet, corners over, next goal), and create markets via a commit-reveal mechanism. Markets are implemented as PropMarketHook contracts deployed through a factory using CREATE2. Users can stake on outcomes gaslessly via EIP-3009 signatures relayed by the x402-facilitator service, and markets are resolved deterministically after match events. The monorepo (pnpm workspaces) contains five packages: `contracts` (Foundry-based Solidity), `agent` (TypeScript runtime with Prisma persistence), `web` (Next.js 15 dApp with RainbowKit, Three.js 3D pitch, and Farcaster Frame v2 integration), `x402-facilitator` (standalone npm package for gasless USDT0 transfers), and `mcp-server` (MCP bridge exposing market tools to AI agents). The architecture is event-driven: the agent's TickLoop polls matches, emits deltas, and triggers market creation/reveal/resolution skills. The web app provides a full dApp experience including a markets list, agent detail views, a status page, and documentation. Key reusable patterns include a generic proposition template system with ABI encoding/decoding, a CREATE2 salt miner for hook deployment, a commit-reveal skill with cryptographic safety, and a gasless staking flow that can be extracted for any EIP-3009-compatible token. The codebase is well-tested (172 web tests, 229 agent tests, 85 contract tests with 100% coverage on the hook) and actively maintained with CI/CD via GitHub Actions and Railway deployment.
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.
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.
Tape is a decentralized video-sharing platform built on Lens Protocol. The monorepo contains multiple frontends: a legacy Next.js app (apps/web), a newer Vite + TanStack Router rewrite (apps/web-vite), an Expo/React Native mobile app, an embeddable video player, and an Open Graph image generator. The backend consists of a Hono API (apps/api) for oEmbed, DID resolution, metadata, and event ingestion, plus a cron service (apps/cron) for cleanup, analytics flushing, and S3 backups. Smart contracts for permissionless signup live in apps/contracts. The platform supports video upload, short-form bytes, comments, mirrors, collects, tips, follows, notifications, search, and profile management, all interacting with Lens Protocol's GraphQL APIs and on-chain contracts. Data flows through several layers: media is uploaded to IPFS/S3/Arweave, metadata is stored on Arweave or IPFS, and social actions are executed via Lens Protocol typed-data signing and broadcasting. The platform also runs an in-house analytics pipeline: browser events are queued through a service worker to Redis, flushed to ClickHouse by cron jobs, and backed up to S3. Postgres (via Prisma) stores platform-level data such as allowed tokens, profile toggles, curated profiles, and platform stats. Redis is used for caching and queueing throughout. Although primarily an application, the repository has a meaningful data/analytics component (ClickHouse schema, event/trail tracking, Redis-backed queues, S3 backup jobs) that could be reused independently. The codebase is actively maintained but carries migration debt: two web frontends, two UI kits (packages/ui and packages/winder), two Lens GraphQL clients (v1 and v2), and commented-out cron services indicate an in-progress transition. No meaningful test suite is present; CI focuses on Biome checks and builds.
The Filecoin Community repository serves as a central hub for community documentation, project showcases, and governance. It contains markdown files detailing community processes, calls, polls, and working group activities. The projects directory showcases applications and tools built by the community on Filecoin. The repository provides standardized templates for project submissions, meeting agendas, and notes, facilitating consistent community engagement. While it lacks executable code, it effectively coordinates the Filecoin ecosystem through structured documentation and resource sharing.
The bnb-chain/bnb-chain.github.io repository serves as the source for the BNB Chain Knowledge Base, a static documentation website hosted at https://docs.bnbchain.org. Built with MkDocs and the Material theme, it provides comprehensive guides, tutorials, and references for the BNB Chain ecosystem, including BNB Smart Chain (BSC), opBNB, and BNB Greenfield. The site is deployed via GitHub Actions to GitHub Pages with a custom domain. Key technical components include custom JavaScript enhancements: an AI chatbot (SuperIntern) with SPA navigation support, a dynamically loaded footer menu with API fallback, MathJax for mathematical rendering, and external link handling. These components demonstrate reusable patterns for static site enhancement, particularly the chatbot's history API listener for SPA compatibility and the footer menu's resilient API integration. While the repository primarily functions as a documentation portal, its implementation as a static web application involves standard web development practices. The codebase exhibits good engineering in its frontend enhancements, though the core documentation content is Markdown-driven and the site architecture follows MkDocs conventions. Maintenance appears active based on recent commits and issue activity, though dependency pinning in the CI workflow presents a moderate technical drift risk.
Repository is a production Android application for Mixin Network, combining a cryptocurrency wallet with a messenger. It integrates with Mixin API (api.mixin.one) and Blaze messaging, supports transfers, swaps, web3 trades, perps, fiat money, and market analytics. The app is built with Kotlin, uses MVVM with ViewModels and Flows, Room for persistence, and a mix of Jetpack Compose and legacy View-based UI. A separate query-codegen Gradle module generates type-safe query code, and release automation includes Fastlane, Docker build box, and APK signature verification.