Union is a hyper-efficient zero-knowledge infrastructure layer for cross-chain interoperability, implementing IBC (Inter-Blockchain Communication) with light clients for Cosmos, Ethereum, Sui, StarkNet, Gno, and many other chains. The system comprises a Cosmos SDK blockchain (uniond), a zero-knowledge prover (galoisd) for Groth16 proofs, a modular relayer (voyager) with plugin-based architecture, CosmWasm smart contracts for IBC and asset transfers (UCS03), EVM Solidity contracts, and a TypeScript SDK for programmatic interaction. The frontend is a Svelte 5 application (app2) providing a transfer interface, explorer, dashboard, and staking UI, while documentation is served via an Astro site. The architecture is a multi-language monorepo with Rust as the dominant language for core libraries and relayer modules, Go for the Cosmos SDK chain and prover, TypeScript for SDKs and frontend, and Solidity/Move for smart contracts. Key design patterns include a trait-based light client interface (IbcClient), a plugin system for relayer modules (voyager_sdk), functional effect management in TypeScript (Effect-TS), and derive macros for encoding (model, ssz, ethabi). The codebase demonstrates high craftsmanship in its type-safe encoding primitives, storage abstractions (depolama), and persistent queue (pg-queue), though it suffers from some code duplication across SDK versions and generated protobuf drift risks.
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).