wincode is a Rust binary serialization library designed for high-performance, in-place deserialization and direct memory writes. It provides a drop-in, configurable alternative to bincode with the same default wire format, but adds compile-time configuration (endianness, integer encoding, length encoding, tag encoding) through const generics, eliminating runtime overhead. The library exposes `SchemaWrite` and `SchemaRead` traits with derive macros (`SchemaWrite`, `SchemaRead`, `UninitBuilder`) that generate optimized serialization/deserialization code, including `MaybeUninit`-based builders for initializing structs without intermediate copies. The architecture is layered: a `Reader`/`Writer` I/O abstraction with trusted-window optimizations (eliding bounds checks for known-size blocks), a schema layer mapping types to `TypeMeta` (static size and zero-copy eligibility), and a config layer that composes compile-time parameters. Unsafe code is pervasive but carefully isolated in unchecked slice readers/writers, zero-copy lifetimes (`ZeroCopy` trait), and unconditional `UninitBuilder` logic. Fuzzing, proptest-based property testing, Miri validation, and security audits by Neodyme, OtterSec, and Asymmetric Research ensure correctness under adversarial inputs. The library is actively maintained by Anza (Solana) and is used in performance-critical Solana infrastructure. It supports `no_std` + `alloc`, and integrates with external types like `bumpalo`, `bv`, `bytes`, `ecow`, `indexmap`, `smallvec`, and `uuid`. The codebase exhibits strong engineering craftsmanship but requires a high MSRV (1.89) and has a heavy reliance on unsafe that demands rigorous auditing. Overall, it is a well-architected, production-grade serialization library.
This repository contains the full implementation of the Marginfi v2 protocol, a decentralized lending and borrowing platform on Solana. The core is an Anchor-based Rust smart contract that manages deposits, borrows, repays, liquidations, orders, and flash loans across multiple assets. It integrates with external lending protocols (Kamino, Drift, Solend, JupLend) via cross-program invocation (CPI), allowing users to use positions from those protocols as collateral. The codebase also includes a comprehensive CLI tool (p0-cli) for admin operations and user interaction, a standalone type crate for shared data structures, multiple mock programs for integration testing, and extensive test suites (Rust integration tests, TypeScript bankrun tests, and fuzz testing with Trident and libfuzzer). The architecture is a single Solana program with a rich set of instruction handlers, supported by off-chain tooling. The repository demonstrates high engineering craftsmanship with well-structured code, reusable components, and thorough testing across many edge cases.
Yellowstone gRPC Geyser is a Solana blockchain data streaming service implementing the Geyser plugin interface. It provides a high-performance gRPC server for subscribing to blockchain events (accounts, transactions, slots, blocks) with advanced filtering, commitment levels, and deshred (pre-execution) streams. The architecture features a modular Rust workspace with separate crates for the core plugin, client libraries, protobuf definitions, and tooling. Key capabilities include TLS hot-reloading, token-bucket rate limiting, Prometheus metrics, authentication layers, and multi-language client support (Rust, Go, Node.js, TypeScript). The system handles complex data routing through broadcast channels, load-aware streams, and block reconstruction logic to ensure ordered delivery of blockchain events.
This repository is the Meteora DLMM (Dynamic Liquidity Market Maker) SDK, a comprehensive multi-language toolkit for interacting with the Meteora concentrated liquidity AMM protocol on Solana. The system includes a Rust core library (`commons/`) with swap quoting, fee calculation, PDA derivation, and math utilities; a TypeScript client (`ts-client/`) that provides a high-level `DLMM` class for pool interaction, liquidity management, rebalancing, and limit orders; a Rust CLI for admin and user operations; a Python client that wraps the TypeScript SDK via a REST API; and a market-making bot example. The on-chain program is defined in IDL files with over 50 instructions supporting multiple pool types (permissionless, permissioned, customizable), Token-2022 with transfer hooks, and advanced features like volatility-based dynamic fees and oracle TWAP. Architecturally, the SDK is layered: the Rust `commons` crate contains the core business logic and is reused by the CLI and market-making bot, while the TypeScript client reimplements much of this logic for off-chain use. The CLI serves as a reference implementation for all protocol operations. The market-making bot demonstrates automated position rebalancing using configurable strategies. The Python client is a thin wrapper that delegates to a TypeScript server, making it less independent. The codebase is heavily tested with Rust integration tests and TypeScript unit tests, including property-based tests for bid-ask math and Token-2022 compatibility. The primary data flows are: user requests (swap, add/remove liquidity, claim fees) go through the client SDK, which constructs and signs transactions for the Meteora DLMM on-chain program. The SDK computes quotes off-chain, simulates rebalancing, and derives required accounts. The market-making bot periodically fetches pool state, evaluates active price drift, and executes rebalancing transactions. The codebase demonstrates strong engineering practices with clear separation of concerns, reusable math utilities, and consistent patterns across languages.
Wormhole is a generic cross-chain messaging protocol that allows smart contracts on different blockchain networks to communicate with each other. This monorepo contains the full protocol implementation: a guardian node (Go) that observes events on supported blockchains, signs Verifiable Action Approvals (VAAs), and relays them; smart contracts deployed on Solana, Ethereum, CosmWasm, NEAR, Sui, Aptos, Algorand, and a custom Cosmos SDK chain (Wormchain); multi-language SDKs (JavaScript, Go, Rust) for integrating with the protocol; and a CLI tool for governance and bridge operations. The system supports token bridging, NFT bridging, cross-chain queries (CCQ), and native token transfers (NTT) with an accountant contract for balance tracking. The architecture follows a microservices pattern within the guardian node: chain-specific watchers feed events into a processor that builds VAAs, which are signed by a quorum of guardians and then broadcasted via P2P/gRPC. On the smart contract side, each blockchain has its own implementation of core bridge logic, token bridge, NFT bridge, and governance modules. The codebase uses a variety of frameworks including Solitaire (a custom Solana framework), Anchor (for SVM shims), CosmWasm contracts, and standard Solidity patterns. Extensive testing infrastructure exists with unit tests, integration tests (some hitting live testnets), and formal verification (KEVM for EVM contracts). While the code is large and spans many languages, the core abstractions (VAA structs, guardian set management, watcher interfaces, supervisor pattern, and the Solitaire framework) are well-designed and demonstrate professional engineering maturity. The monorepo also includes generated protobuf code, deployment scripts, devnet configurations, and audit reports, making it a complete reference implementation but also introducing maintenance complexity and some technical debt (e.g., deprecated chain handling, hardcoded keys in tests, and occasional use of panic).
This is a multi-platform Solana trading bot designed for sniping newly created tokens on pump.fun and letsbonk.fun (Raydium LaunchLab). It listens for token creation events in real-time via multiple mechanisms (gRPC Geyser, WebSocket logs/block subscription, third-party PumpPortal feed), then automatically executes buy and sell trades using program instructions (v2 with full account lists). The codebase emphasizes a platform-agnostic architecture with abstract interfaces for address derivation, instruction building, event parsing, and curve management, allowing new platforms to be added without altering core trading logic. It includes optional 'extreme fast mode' for zero-RPC buys, configurable exit strategies (take-profit, stop-loss, time-based), priority fee management (fixed or dynamic), compute unit optimization, and an interactive cleanup manager. The repository is explicitly educational ('NOT FOR PRODUCTION') and ships with an extensive suite of standalone learning examples and verification scripts that offline-test edge cases such as v1/v2 transaction cutover, optional trailing arguments, price feed failures, and retry bounding. Despite its purpose as a demonstration, the code demonstrates solid engineering practices: abstraction layers, configuration-driven bots, a token bucket rate limiter, plugin-based fee engines, and generic Anchor IDL decoders.
This is the Solana.Unity-SDK, a comprehensive Unity package for integrating Solana blockchain functionality into games and applications. It provides multiple wallet connection methods (in-game wallet, Web3Auth social login, Phantom/Solflare deep links, Mobile Wallet Adapter for Android, WebGL browser wallets), transaction signing, NFT minting via Metaplex Candy Machines (including a full editor toolchain for deployment), DEX swap aggregation (Jupiter), domain resolution (.skr), and cross-platform compatibility (Android, iOS, WebGL). The SDK bundles its own async infrastructure (UniTask 2.5.0) and includes sample UI screens for a wallet application. It is architectured around a central Web3 singleton, an abstract WalletBase class with concrete implementations, and platform-specific adapter classes. The codebase is well-structured with clear separation of concerns, but suffers from some monolithic classes (e.g., Web3Auth, CandyMachineController) and reliance on hardcoded endpoints and program IDs. The editor tools are fully functional but tightly coupled to the UnityEditor API. Overall, it is a professional-grade SDK with moderate reusability of its individual components.
This repository claims to be a Solana trading bot hub but contains ZERO actual trading bot code. The entire codebase consists of only 3 files: .gitignore, README.md, and one image asset. The README is purely a marketing landing page with affiliate/referral links to external trading platforms (Axiom, Odin Bot, Bloom, Trojan, GMGN, Padre, etc.). There are no Python, TypeScript, Rust, or any other programming language source files. No package manifests, no configuration files, no actual bot implementations. This is effectively a placeholder repository designed to drive traffic to affiliate partners, not a functional software project. The repository structure suggests it was created solely for SEO/marketing purposes with no intention of providing reusable code or actual trading bot implementations.