Contract tooling

The smart contract development tool for Pythonistas, Data Scientists, and Security Professionals

Scaffold-ETH 2 is a Next.js plus Hardhat or Foundry starter with wallet hooks, hot contract reload, local faucet utilities, and extension modules for full-stack dapp deployment.

A Python-based development and testing framework for smart contracts targeting the Ethereum Virtual Machine.

A rich and accessible Web3 toolset for learning, building, and testing on multiple chains

Moccasin is Cyfrin's Python-first workflow on Titanoboa for testing, fuzzing, and deploying Vyper written smart contracts.

slang from the Nomic Foundation is a modular Solidity compiler frontend with a parser, concrete syntax tree, and bindings. Builders import it when writing a linter, formatter, or other tool that has to understand Solidity source.

BuildBear is a hosted service that spins up a private testnet sandbox mirroring a real chain such as Ethereum, Polygon, BSC, or Arbitrum. Builders point tests at it to work against a private fork with real chain state.

Huff is a low-level assembly language and compiler for writing hand-optimized EVM bytecode, with development continuing in huff2. Builders reach for it when bytecode has to be tuned by hand.

py-solc-x is a Python wrapper and version manager for the solc Solidity compiler, used by Brownie and Ape style test suites. Python builders install it to fetch and switch compiler versions from their own scripts.

Wake is a Python framework for testing, fuzzing, and static analysis of Solidity projects. Builders reach for it when they want to write contract tests and fuzzing campaigns in Python and run analysis over the same codebase.

The Stylus SDK is the Rust SDK for writing smart contracts that run in Arbitrum's Stylus environment alongside the EVM. Rust builders use it when contract logic should be written in Rust rather than Solidity.

Hardhat is a development environment to build and deploy your Ethereum software

Foundry is a fast, portable Rust toolchain for Ethereum smart contract engineering that manages dependencies, compiles Solidity, runs fuzz and unit tests, deploys contracts, and drives scripted chain interaction from the terminal or Solidity automation scripts.

Kurtosis packages reproducible multi-service devnets so you can spin up realistic Ethereum or rollup stacks for integration tests faster than hand-maintained compose files.

CreateX is pcaversaccio's trustless universal deployer that wraps CREATE, CREATE2, and CREATE3-style flows so teams can launch contracts from predictable addresses without bespoke factory code.

Hardhat plugin to deploy your smart contracts across multiple EVM chains with the same deterministic address. A total of 133 EVM chains are currently supported, including (almost) all OP-stack-powered chains.

Create2Deployer is a minimal factory contract from pcaversaccio that wraps the CREATE2 opcode with safety checks so teams can deploy counterfactual contracts at deterministic addresses.

Txtx turns the stress, pain and tears of Smart Contract Infrastructure management by introducing Crypto Infrastructure as Code. Runbooks are the blueprint for Engineering Excellence, setting the new standard for Web3 Infrastructures.

Chainlink Faucets dispense testnet ETH and LINK across the supported test networks. Builders use them to fund an account before deploying and testing contracts on a testnet.

Decker is a TypeScript CLI for creating configurable local Ethereum devnets with execution and consensus clients, relays, and block builders. Teams use its recipes for integration tests and infrastructure development.

ethereal is a Go command line tool for everyday Ethereum tasks, including sending transactions, managing ENS records, transferring tokens, and inspecting accounts. Builders install it for one-off operations that do not justify a script.

ethereum-genesis-generator creates execution and consensus layer genesis state for a testnet and serves it over a web server. Devnet and rollup teams run it to produce the genesis files for a custom network.

EthPillar is a setup script and terminal interface for installing and managing an Ethereum staking node with execution, consensus and MEV-Boost clients. Solo stakers run it to stand up a node without editing client configuration by hand.

foundry-toolchain is the official GitHub Action that installs Foundry in continuous integration. Builders add it to a workflow so forge test and forge script run on every pull request.

Immunefi is a bug bounty platform where projects post rewards for whitehats who find and responsibly disclose contract vulnerabilities. Teams list a program there to give researchers a paid route to report issues.

PoWFaucet is a modular testnet faucet for EVM chains with anti-abuse methods including a mining puzzle, captcha, IP limits, and Gitcoin Passport, and it backs the Sepolia proof-of-work faucet. Teams running a testnet self-host it to hand out test ETH without giving it all to one address.

Rocket Pool Smart Node is the command line package node operators run to set up and manage a Rocket Pool minipool, wrapping execution and consensus clients plus validator duties.

rocketh is a deployment and test harness for Ethereum contracts built around viem, keeping one record of deployments per network so scripts and tests agree. Builders use it when they want repeatable deployments without Hardhat, which the hardhat-deploy plugin wraps over the same code.

Sedge is a command line setup tool from Nethermind that generates docker-compose configurations for execution, consensus, and validator client combinations. Builders run it to get a working node setup without writing the compose files.

Cannon is a DevOps tool for protocols on Ethereum. It manages smart contract deployment and configuration for local development and live networks.

hardhat-deploy is a Hardhat plugin for replicable deployments with named accounts, proxies, and diamonds. Builders install it when deployments must be repeatable across networks and track upgradeable contracts.

DAppNode is an operating system with an app store for running Ethereum execution and consensus clients and other node software on your own hardware. Someone setting up a home node installs it and picks client packages instead of configuring each service by hand.

eth-docker is a Dockerized stack for deploying and managing execution, consensus, and validator clients on mainnet. Node operators use it to run a full node setup from configuration files instead of hand-installed binaries.

ethereum-helm-charts are Helm charts from ethPandaOps for running Ethereum execution and consensus clients and related infrastructure on Kubernetes. Teams add them to a cluster rather than writing client manifests themselves.

The Kurtosis ethereum-package spins up reproducible multi-client Ethereum devnets, including mev-boost and supporting tooling. Builders run it when they need a local network that mirrors a real client mix.

simple-optimism-node is a one-command Docker setup for running an OP Stack node. Builders run it to get their own Optimism node, in the same way eth-docker covers mainnet clients.

OpenZeppelin Contracts are the go-to library for smart contract development.

Solidity is an object-oriented, high-level language for implementing smart contracts.

Pythonic Smart Contract Language for the EVM

Solidity-Oriented Development Tooling

Solady by Vectorized collects aggressively optimized Solidity snippets from Merkle proofs to compression helpers, wrapping careful inline assembly in approachable APIs so advanced developers can ship gas-efficient patterns while learning cutting-edge optimization techniques from a living reference library.

Fe is a Rust-inspired language targeting the EVM; today you can explore Fe v2's type system via CLI or editor tooling even while bytecode generation is still evolving.

Solhint is a Solidity linter you wire into editors or CI to enforce style rules and catch footgun patterns early.

Juan Blanco's VS Code Solidity extension adds syntax highlighting, compile commands, hover metadata, quick fixes, monorepo detection, optional Nethereum codegen, lint integration, and an LSP server.

WhatsABI recovers selectors, proxies, and partial ABIs from bytecode alone-use it in wallets, explorers, or local tools when verified source is missing but you still need calldata decoding.

Solidity plugin for IntelliJ

PRBMath is a smart contract library that adds support for fixed-point types and advanced math functions like logarithms and exponentials in Solidity. Operating with 18-decimal numbers, PRBMath is at the same time gas efficient and user-friendly.

Solc-select is a command line utility for quickly installing and switching between Solidity compiler versions.

A Prettier plugin for automatically formatting your Solidity code.

State-of-the-art, highly opinionated, hyper-optimised, and secureVyper smart contract building blocks.

Solidity Bytes Utils is a classic library for concatenating, slicing, and casting dynamic bytes arrays in Solidity memory or storage-long maintained and widely forked across major protocols.

ABDKMath64x64 is a Solidity library for 64.64-bit binary fixed-point math. Builders import it when a contract needs fixed-point arithmetic that Solidity does not provide natively.

ERC721A is a gas-optimized ERC-721 implementation with cheap consecutive batch minting. Builders import it when an NFT contract mints several tokens to the same address at once and minting cost matters.

ERC721A-Upgradeable is the proxy-upgradeable variant of the ERC721A implementation. Builders import it when a proxy-based NFT contract needs the batch minting design of ERC721A.

Multicall3 is the canonical contract for batching many reads or writes into a single transaction. Builders call it from contracts and scripts to fetch or update state across several contracts in one round trip.

Safe Smart Account is the widely deployed set of modular multisig smart-account contracts behind Safe. Wallet and treasury builders deploy or extend it to add multisignature control and account modules.

SolidState Solidity is an upgradeable-first contract library built around the diamond pattern of EIP-2535. Teams import it when contracts are organized as diamond facets from the start.

Solmate is a modern, opinionated collection of gas-optimized Solidity building blocks and utilities for smart contract development.

A gas-efficient Solidity compiler for Ethereum powered by LLVM from the ZKsync team and collaborators. Works as a drop-in replacement for solc in workflows like Foundry and Hardhat.

weiroll is an operation-chaining scripting language and set of contracts for composing many EVM calls into one transaction. Teams building call-routing or batching systems use it to express the call sequence as a script.

Diamondscaffold is a CLI tool designed to scaffold EIP-2535 diamond projects with an opinionated layout and scripts, making it faster to stand up modular upgradeable proxies.

Blazingly fast, modular Solidity compiler written in Rust by Paradigm. Designed as a contributor-friendly compiler stack for faster builds and better diagnostics.

solidity-docgen generates Markdown documentation for a Solidity project from its NatSpec comments. Teams run it so published docs stay in step with the contract source.

ZK Email provides circuits and SDKs for proving facts about redacted email transcripts onchain. Useful when you want privacy-preserving identity or receipt checks without doxxing inboxes.

Self Protocol provides open identity and proof primitives builders can embed when they need privacy-preserving verification flows tied to wallets or credentials.

zkTLS / TLSNotary is an open protocol for proving properties of TLS sessions with MPC so verifiers can trust transcripts without seeing full plaintext.

Tools for building privacy-preserving applications using Indian government Aadhaar ID cards. Provides ZK circuits, TypeScript, Solidity, and React libraries to enable Aadhaar holders to prove residency without revealing personal data.

Circom is a domain-specific language and compiler for writing and compiling arithmetic circuits used in zero-knowledge proof systems.

gnark-crypto provides elliptic curve and pairing cryptography for BN, BLS12, BLS24, and BW6 curves, and it is the backend of the gnark SNARK library. Go builders import it directly for curve and pairing math.

PSE's re-architected fork of Zcash's Halo2 PLONK proof system, featuring a KZG backend with Solidity verifier for economical L1 verification, support for multiple elliptic curves, and decoupled frontend/backend architecture.

MACI (Minimal Anti-Collusion Infrastructure) uses zero-knowledge proofs to enable collusion-resistant, private voting and signaling systems on Ethereum.

A toolkit that makes client-side zero-knowledge proving on mobile simple. Connects ZK proof systems (Halo2, Circom) to generate iOS, Android, and browser bindings, leveraging mobile GPU for improved performance.

A toolkit for Groth16 Phase 2 Trusted Setup ceremonies. Helps developers create and manage trusted setups for ZK applications, with a companion webapp (DefinitelySetup) for monitoring and participation.

An ongoing (since 2019) zk-SNARK trusted setup ceremony for circuits up to 2^28 constraints, generating 530M+ powers of tau. A multi-party ceremony where security holds as long as one participant is honest.

Semaphore is a zero-knowledge protocol for private group membership proofs, enabling anonymous signaling and authentication without revealing identity.

snarkjs is a JavaScript and CLI toolkit for generating and verifying zkSNARK proofs, and for running common proving workflows in Node.js and the browser.

A modular folding library supporting multiple folding schemes (Nova, HyperNova, ProtoGalaxy, CycleFold) and decider backends (Groth16, KZG) for Incremental Verifiable Computation. Supports Arkworks, Circom, Noir, and Noname frontends.

Private identity verification using zero-knowledge proofs. Verify age, country, or proof of personhood without revealing any personal information. Mobile-first design with SDK for integration and onchain registry contracts.

arkworks algebra is a set of Rust libraries for finite field, elliptic curve, and polynomial arithmetic, and it is the math layer under many SNARK and STARK toolchains. Rust builders add the ark crates when writing proving code from the ground up.

SP1 from Succinct is a zero-knowledge virtual machine that proves correct execution of RISC-V programs, and it is used to generate proofs for rollups and bridges. Teams compile a Rust program with it when a proof must stand in for re-executing that program onchain.

Lambdaworks is a Rust library of SNARK and STARK prover components that can be used piecemeal or assembled into a custom proving system. Teams pull its crates when building their own prover rather than adopting a finished one.

op-succinct is a proving engine that generates SP1 validity proofs for OP Stack rollups. Rollup teams deploy it to turn an OP Stack chain into a validity proof rollup, running it as a separate service.

Plonky3 is a toolkit of polynomial IOP building blocks for constructing custom SNARK and STARK proving systems, and several zkVM projects build on it. Rust builders add the p3 crates when writing their own proving system.

powdr is a toolkit for accelerating and hardening zkVMs by moving specific computations into custom circuits. Teams running a zkVM use it to generate custom precompiles and check constraints, and its authors still describe the code as experimental.

risc0-ethereum holds the integration libraries and verifier contracts for using the RISC Zero zkVM with Ethereum and other EVM chains. Teams proving computation off chain import these crates to settle the resulting proofs onchain.

rsp from Succinct generates zero-knowledge proofs of Ethereum and OP Stack block execution, built on Reth. Its authors describe it as a minimal work in progress that is not meant for production, so it mainly serves teams already building on SP1.

snark-verifier generates gas-efficient onchain verifiers for halo2 SNARKs and is maintained by Axiom, forked from the original PSE repository. halo2 developers import the crate to produce the Solidity verifier that checks their proofs onchain.

A monorepo of reusable zero-knowledge libraries across multiple languages (JavaScript, Solidity, Rust, Noir), offering well-tested implementations of cryptographic primitives like Merkle trees, Poseidon hash, and more.