Smart contracts are programs stored on a blockchain that execute automatically when predetermined conditions are met. Unlike traditional programs running on centralized servers, smart contracts are:

Immutable - Once deployed, the code cannot be changed (unless designed with upgrade patterns)

Deterministic - The same input always produces the same output

Trustless - Execution is guaranteed by the network, not by any single party

Transparent - Anyone can view the code and verify its behavior

The most popular platform for smart contracts is Ethereum, using the Ethereum Virtual Machine (EVM). Many other chains (Polygon, Arbitrum, Base, BSC) are EVM-compatible, meaning the same code works across multiple networks.

A typical Web3 development environment includes:

1. Code Editor - VS Code with Solidity extensions is the most popular choice

2. Development Framework - Hardhat or Foundry for compiling, testing, and deploying

3. Local Blockchain - A local node for testing (Hardhat Network, Anvil, or Ganache)

4. Wallet - MetaMask or similar for interacting with deployed contracts

5. RPC Provider - Access to blockchain nodes (Alchemy, Infura, or public RPCs)

For beginners, browser-based IDEs like Remix provide everything in one place, requiring no local setup.

Testnets are blockchain networks identical to mainnet but using worthless test tokens. They're essential for development because:

Free to use - Get test ETH from faucets at no cost

Safe to fail - Mistakes don't cost real money

Production-like - Behavior closely mirrors mainnet

Popular Ethereum Testnets:
• Sepolia - Most widely supported, recommended for most development
• Goerli - Being deprecated, but still used by some projects
• Holesky - Newer testnet for staking and validator testing

L2 Testnets:
• Arbitrum Sepolia, Optimism Sepolia, Base Sepolia

Most faucets require either proof of mainnet activity or social verification to prevent abuse.

Hardhat is the most popular JavaScript/TypeScript development framework, known for its flexibility and extensive plugin ecosystem.

Key Features:
• JavaScript/TypeScript native with excellent IDE support
• Hardhat Network with advanced debugging (console.log in Solidity)
• Extensive plugin ecosystem (ethers.js, verification, gas reporting)
• Flexible task system for custom workflows
• Strong community and documentation

Best For:
• Teams with JavaScript/TypeScript experience
• Projects needing extensive customization
• Integration with existing Node.js tooling

Quick Start:
npx hardhat init

Foundry is a blazing-fast Rust-based development toolkit that's becoming the preferred choice for serious smart contract developers.

Key Features:
• Write tests in Solidity (same language as contracts)
• Extremely fast compilation and testing
• Built-in fuzzing for property-based testing
• Powerful cheatcodes for test manipulation
• Cast CLI for interacting with chains
• Chisel for interactive Solidity REPL

Best For:
• Performance-critical development
• Security-focused teams
• Complex testing requirements
• Developers who prefer Solidity over JS

Quick Start:
curl -L https://foundry.paradigm.xyz | bash
foundryup

Remix is a browser-based IDE perfect for learning, quick prototyping, and teaching.

Key Features:
• No installation required - works in browser
• Built-in compiler, debugger, and deployment
• Static analysis and security warnings
• Integration with MetaMask for deployment
• Plugins for additional functionality

Best For:
• Beginners learning Solidity
• Quick prototyping and experiments
• Teaching and workshops
• Simple contract interactions

Limitations:
• Not suitable for large projects
• Limited version control integration
• Less suitable for team collaboration

Hardhat vs Foundry:

Feature	Hardhat	Foundry
Language	JavaScript/TypeScript	Rust/Solidity
Test Language	JS/TS	Solidity
Speed	Good	Excellent
Fuzzing	Plugin	Built-in
Learning Curve	Lower	Higher
Ecosystem	Larger	Growing

Recommendation:

• New developers: Start with Remix, then move to Hardhat

• Teams with JS experience: Hardhat

• Security-focused/Performance needs: Foundry

• Many advanced projects: Use both together

Solidity is the dominant language for EVM-compatible blockchains, designed specifically for smart contracts.

Key Characteristics:
• Statically typed, object-oriented
• Syntax similar to JavaScript/C++
• Supports inheritance, libraries, and complex types
• Extensive tooling and documentation
• Largest developer community in Web3

Current Best Practices:
• Use Solidity 0.8.x for built-in overflow protection
• Follow the Checks-Effects-Interactions pattern
• Use OpenZeppelin contracts for standard implementations
• Enable optimizer for production deployments
• Always include NatSpec documentation

Vyper is a Python-like language for the EVM, designed with security as the primary focus.

Key Characteristics:
• Python-like syntax, easy to read
• No inheritance (intentionally simpler)
• No inline assembly (safer)
• No function overloading
• Built-in overflow protection

Best For:
• Security-critical contracts
• Developers from Python background
• Simple, auditable contracts
• Projects prioritizing readability

Major protocols like Curve Finance use Vyper for their core contracts.

Cairo (StarkNet):
• Provable computation language for ZK-rollups
• Designed for StarkNet ecosystem
• Rust-like syntax with unique concepts
• Growing rapidly with StarkNet adoption

Move (Sui/Aptos):
• Resource-oriented programming language
• Originally developed by Facebook/Diem
• Strong type system preventing common bugs
• Used by Sui and Aptos blockchains

Rust/Anchor (Solana):
• Solana programs written in Rust
• Anchor framework provides abstractions
• Different execution model than EVM
• High performance but steeper learning curve

Noir/Circom (ZK):
• Domain-specific languages for zero-knowledge circuits
• Used for privacy-preserving applications
• Compile to ZK proofs

Ethers.js:
The classic choice, battle-tested and widely used.
• Clean, intuitive API
• Excellent documentation
• Large ecosystem of examples
• Works with any frontend framework

Viem:
Modern TypeScript-first alternative, gaining rapid adoption.
• Smaller bundle size
• Better TypeScript inference
• Modular architecture
• Built for modern toolchains

Recommendation:
New projects should consider Viem for its modern design. Ethers.js remains excellent for existing projects and teams already familiar with it.

Wagmi provides React hooks for Ethereum, built on top of Viem.

Key Features:
• Automatic caching and request deduplication
• TypeScript support with strong type inference
• Hooks for common operations (useAccount, useBalance, useContractRead)
• Built-in support for wallet connection
• Suspense support for async operations

Example:
const { address } = useAccount()
const { data: balance } = useBalance({ address })

Wagmi has become the standard for React-based dApps, with excellent documentation and growing ecosystem.

RainbowKit:
Beautiful, customizable wallet connection modal.
• Pre-built UI components
• Supports 50+ wallets
• Mobile responsive
• Theme customization
• Built on Wagmi

Web3Modal (WalletConnect):
Universal wallet connection from WalletConnect.
• Works with any framework
• WalletConnect v2 support
• Chain abstraction
• Email/social login options

ConnectKit:
Alternative to RainbowKit with different design philosophy.
• Minimalist design
• Customizable animations
• Small bundle size

All three options work well - choose based on your design preferences and team familiarity.

RPC (Remote Procedure Call) providers give your application access to blockchain data and transaction submission.

Alchemy:
• Industry-leading reliability
• Enhanced APIs (NFT, transfers, webhooks)
• Excellent debugging tools
• Generous free tier

Infura:
• Pioneer in RPC services
• ConsenSys backed
• IPFS integration
• Proven at scale

QuickNode:
• Widest chain support (50+)
• Low latency globally
• Marketplace for add-ons

Public RPCs:
For development only - they're rate-limited and not reliable for production.

Indexers organize blockchain data for efficient querying, essential for displaying historical data.

The Graph:
• Decentralized indexing protocol
• GraphQL queries
• Large library of existing subgraphs
• Community-run network

Goldsky:
• Real-time data streaming
• Mirror subgraphs for redundancy
• Instant subgraph deployment
• Better performance than The Graph hosted service

Envio (HyperSync):
• 100x faster than traditional indexing
• TypeScript-native
• Excellent developer experience
• Great for data-heavy applications

Choose based on your needs: The Graph for decentralization, Goldsky for reliability, Envio for performance.

Moralis:
• NFT APIs (metadata, ownership, transfers)
• Token APIs (prices, balances, transfers)
• DeFi APIs (positions, yields)
• Real-time webhooks

Covalent:
• Unified API for 100+ chains
• Historical data access
• No rate limits on paid plans
• Excellent for multi-chain applications

Transpose:
• SQL-like queries
• Real-time data
• Great for analytics

These APIs save development time by providing pre-indexed, normalized data across chains.

Hardhat Testing:
• Use Chai/Mocha for assertions
• Hardhat Network for fast local testing
• Time manipulation with helpers
• Mainnet forking for integration tests

Foundry Testing:
• Write tests in Solidity
• setUp() for test initialization
• assertEq, assertTrue, expectRevert
• Cheatcodes for state manipulation

Best Practices:
• Test every public function
• Test edge cases and failure conditions
• Test events are emitted correctly
• Test access control thoroughly
• Aim for 100% branch coverage

Tenderly:
• Transaction simulation before sending
• Visual debugger with step-through
• Gas profiler
• Alert monitoring
• Fork mainnet for testing

Hardhat console.log:
• Add console.log to Solidity
• Debug during local development
• No gas cost (development only)

Foundry Traces:
• -vvvv for detailed traces
• See all internal calls
• Gas breakdown per call

Tenderly is especially valuable for debugging transactions that failed on mainnet.

Fuzz testing automatically generates random inputs to find edge cases you might miss.

Foundry Fuzzing:
function testFuzz_Deposit(uint256 amount) public {
vm.assume(amount > 0 && amount < type(uint128).max);
// test with random amounts
}

Invariant Testing:
• Define properties that must always be true
• Foundry attempts to break invariants
• Catches bugs traditional tests miss

Best Practices:
• Use bound() to constrain inputs realistically
• Define meaningful invariants
• Run with high iteration counts before deployment
• Consider formal verification for critical contracts

Verification makes your source code public and readable on block explorers.

Why Verify?
• Users can read your code before interacting
• Enables Read/Write tabs on Etherscan
• Builds trust with your community
• Required for many integrations

Etherscan Verification:
• Most common method
• Automated with Hardhat/Foundry plugins
• Works for single and multi-file contracts

Sourcify:
• Decentralized verification
• Stricter matching requirements
• Stores source code on IPFS
• Preferred for long-term preservation

Always verify your contracts immediately after deployment.

Deployment Checklist:
• All tests pass
• Security audit completed (for production)
• Gas optimization reviewed
• Constructor parameters verified
• Multi-sig ownership configured
• Emergency pause mechanism ready

CREATE2 Deployments:
• Deterministic addresses across chains
• Same address on all EVM chains
• Useful for multi-chain protocols

Deployment Scripts:
• Use scripts, never deploy manually
• Version control all deployment data
• Log addresses to JSON files
• Test scripts on testnet first

Proxy Patterns:
• Transparent Proxy - OpenZeppelin standard
• UUPS Proxy - More gas efficient
• Diamond Pattern - For complex systems

Considerations:
• Storage layout must be preserved
• Initialization replaces constructor
• Upgrade authority is a trust assumption
• Some protocols are intentionally non-upgradeable

Best Practices:
• Use OpenZeppelin Upgrades plugin
• Test upgrade path thoroughly
• Consider time-locks on upgrades
• Document upgrade procedures

Upgradeability is a trade-off between flexibility and trust. Many DeFi protocols prefer immutable contracts.

Chainlink Price Feeds:
• Industry standard for DeFi
• Decentralized node operators
• Deviation and heartbeat triggers
• Available on most EVM chains

Pyth Network:
• Sub-second updates
• Pull-based model (lower cost)
• Strong on non-EVM chains
• High-frequency trading use cases

Integration Example:
AggregatorV3Interface feed = AggregatorV3Interface(address);
(, int256 price,,,) = feed.latestRoundData();

Safety Checks:
• Verify price is not stale
• Check for negative prices
• Handle sequencer downtime (L2)
• Consider price manipulation attacks

Blockchain-native randomness is predictable. VRF provides provably fair random numbers.

Chainlink VRF:
• Cryptographically proven randomness
• Request-response pattern
• Used for lotteries, NFT mints, gaming
• V2.5 with direct funding option

How It Works:
1. Your contract requests randomness
2. VRF nodes generate proof off-chain
3. Proof verified on-chain
4. Callback delivers random number

Use Cases:
• Fair NFT trait assignment
• Lottery and raffle winners
• Random game outcomes
• Any selection that must be unbiased

CryptoZombies:
• Learn Solidity by building a game
• Free, gamified lessons
• Covers basics to advanced
• Great for complete beginners

SpeedRunEthereum:
• Challenge-based learning
• Build real projects
• Community feedback
• From Austin Griffith (Scaffold-ETH)

Solidity by Example:
• Concise code examples
• Common patterns explained
• Copy-paste ready code
• Great reference resource

Alchemy University:
• Comprehensive curriculum
• Free certification
• JavaScript and Solidity tracks

Scaffold-ETH 2:
• Full-stack Ethereum development
• Pre-configured Hardhat + Next.js
• Hot reload for contracts
• Debug UI built-in
• Best for rapid prototyping

thirdweb:
• No-code contract deployment
• Pre-built contract templates
• React/Unity SDKs
• Managed infrastructure

Create Web3 DApp:
• Modern templates
• Viem + Wagmi + RainbowKit
• Multiple framework options

Start with a template to learn patterns, then customize as you understand more.

Must-Read Docs:
• Solidity Documentation - Language reference
• OpenZeppelin Docs - Secure contract patterns
• EIPs (ethereum.org) - Standard proposals
• Viem/Wagmi Docs - Frontend integration

EVM Deep Dives:
• EVM Codes - Interactive opcode reference
• Ethereum Yellow Paper - Technical specification
• Understanding the EVM (blog series)

Security Resources:
• SWC Registry - Smart contract weaknesses
• Consensys Best Practices - Security guidelines
• Rekt News - Learn from hacks

Bookmark these and refer to them often. The best developers know where to find answers quickly.