Web3
Web3 Development for Teams Ready to Build on the Open Internet
Web3
Web3 development bridges traditional web applications to blockchain — wallets, smart contracts, token standards, and decentralized protocols. The 2026 stack: ethers.js (most downloaded, 70% Solidity dev usage), viem (TypeScript-native, 35KB bundle, 39% adoption), wagmi (React hooks abstraction, 33% adoption). Critical note: Web3.js was officially archived March 4, 2025 — all new projects should migrate to ethers.js or viem. WalletConnect v2 handles cross-platform wallet connectivity. Web3 developers grew 40% YoY to 28,000 active in Q1 2025, with 3,500+ live dApps on Ethereum and Solana combined.
Build with Web3Backend Development
Who Should Use Web3 Development Services?
Web3 development is appropriate for any team building user-facing applications that connect to blockchain — DeFi trading interfaces, NFT collection minting sites, DAO governance dashboards, token holders dashboards, and crypto wallet interfaces. The frontend library layer (ethers.js/viem/wagmi) is language-agnostic relative to which chain you're targeting: Ethereum, Arbitrum, Base, Optimism, and all EVM-compatible chains use the same library set. Solana uses @solana/web3.js, a different library from the archived Web3.js.
DeFi Interface Development
Swap interfaces, lending dashboards, yield farming UIs, and liquidity management portals use wagmi hooks to read protocol state, handle multi-step transactions, and manage user wallet connections with real-time balance updates.
NFT Marketplace & Mint Sites
NFT collection minting pages, marketplace interfaces, and portfolio viewers use ethers.js/viem to interact with ERC-721/1155 contracts, Seaport marketplace protocol, and IPFS metadata — plus wallet connection via RainbowKit.
DAO Governance Dashboards
Governance portals display proposals, voting status, and treasury analytics by reading Governor contract state via wagmi hooks — allowing token holders to vote from their wallets without leaving the application.
Token & Portfolio Analytics
Token holder dashboards, vesting schedule viewers, and multi-chain portfolio trackers read on-chain state across Ethereum and L2s using ethers.js multicall patterns to batch RPC requests efficiently.
Wallet Integration
Applications adding Web3 wallet authentication (Sign-In With Ethereum, ERC-4337 smart wallets) alongside or replacing traditional email/password login — WalletConnect v2 + wagmi handles the full connection and signature flow.
Cross-Chain Applications
Multi-chain dApps switching between Ethereum mainnet, Arbitrum, Base, and Optimism use wagmi's chain switching, viem's chain configuration, and bridge protocol integrations (Across Protocol, LayerZero) to provide unified UX.
When Web3 Might Not Be the Best Choice
We believe in honest communication. Here are scenarios where alternative solutions might be more appropriate:
Applications with no blockchain integration — standard web development stacks are simpler and more appropriate when decentralization provides no user benefit
Solana applications — @solana/web3.js v2 (Solana's SDK) is architecturally different from ethers.js/viem and requires Solana-specific development patterns
Backend-only smart contract interaction without user wallets — server-side scripts using ethers.js with a private key signer are simpler than full dApp architecture
Projects expecting sub-100ms UX without RPC optimization — public RPC endpoints introduce latency; dedicated Alchemy/Infura/QuickNode nodes are required for production performance
Still Not Sure?
We're here to help you find the right solution. Let's have an honest conversation about your specific needs and determine if Web3 is the right fit for your business.
Why Choose Our Web3 Development Team?
Web3 development in 2026: ethers.js leads at 70% Solidity dev adoption, viem is TypeScript-native at 35KB (39% adoption), wagmi provides React hooks abstraction (33%). Web3.js archived March 4, 2025 — do not use for new projects. WalletConnect v2 handles cross-platform wallet connectivity. For dApps, DeFi interfaces, NFT marketplaces, and token dashboards, the ethers.js/viem + wagmi + RainbowKit stack covers 90% of requirements.
70%
ethers.js Adoption
Solidity Developer Survey 202539%
viem Adoption
Solidity Developer Survey 202528,000+
Active Web3 Devs
Web3 developer count Q1 2025 (+40% YoY)Archived
Web3.js Status
Web3.js GitHub, March 4, 2025ethers.js v6 (70% Solidity developer adoption) provides the most mature, battle-tested Ethereum interaction library with comprehensive TypeScript support
viem's TypeScript-native design with 35KB bundle (40% smaller than ethers.js) and strict ABI-derived types catches interface errors at compile time, not at runtime
wagmi's React hooks (33% adoption) abstract contract reads, writes, wallet state, and transaction lifecycle into composable hooks reducing boilerplate by 60%+
WalletConnect v2 provides universal wallet connectivity — MetaMask, Coinbase Wallet, Rainbow, Ledger, and 300+ wallets through a single integration
RainbowKit provides a polished wallet connection UI covering all major wallets with customizable themes — eliminates weeks of wallet UI development
Web3 developer ecosystem grew 40% YoY to 28,000 active developers Q1 2025 — talent availability is improving across all blockchain stacks
EIP-1193 provider standard means wallet integration code works across MetaMask, Phantom (EVM mode), and all WalletConnect-compatible wallets uniformly
The Merge (2022) and L2 ecosystem maturity mean Web3 UX is now viable for mainstream users — sub-$0.01 L2 fees make transaction-heavy apps economically practical
Web3 in Practice
DeFi Swap Interface
DEX aggregator interface built with viem + wagmi — reads liquidity data from Uniswap V3/V4 pools via multicall, displays real-time quotes, handles approval + swap as sequential transactions, and shows gas estimates before submission. Slippage protection and deadline parameters prevent front-running losses.
Example: viem + wagmi DEX interface: Uniswap V3/V4 multicall reads, approval+swap transactions, slippage protection
NFT Collection Mint Site
NFT collection launch site uses RainbowKit for wallet connection, ethers.js for ERC-721 contract interaction, and IPFS for metadata display. Allowlist verification via Merkle proof, public mint phase, and live mint counter — optimistic UI shows mint status before on-chain confirmation.
Example: RainbowKit + ethers.js NFT mint: Merkle allowlist, public mint, IPFS metadata, optimistic UI updates
DAO Governance Portal
Governance dashboard built with wagmi + viem reads Governor contract state — active proposals, voting deadlines, quorum progress, and delegate balances. Token holders connect wallets, cast votes, and delegate voting power in-app. Snapshot integration displays off-chain polls alongside on-chain proposals.
Example: wagmi Governor portal: proposals, on-chain voting, delegation, Snapshot integration — multi-wallet support via WalletConnect
Multi-Chain Portfolio Dashboard
Wallet portfolio tracker reads token balances and NFT holdings across Ethereum, Arbitrum, Base, and Optimism simultaneously using viem's multicall with chain-specific configurations — aggregated portfolio value with live price feeds from Chainlink and CoinGecko.
Example: viem multicall: Ethereum + 3 L2s token/NFT balances aggregated in parallel, Chainlink price feeds
Sign-In With Ethereum (SIWE)
B2C application replaces email/password with Sign-In With Ethereum authentication — users sign a nonce message with their wallet, server verifies the signature, issues a JWT. WalletConnect v2 enables mobile wallet users to authenticate without browser extension.
Example: SIWE: wallet signature → server JWT verification → session authentication, WalletConnect mobile support
Token Vesting Dashboard
Team and investor token vesting portal reads vesting contract state via wagmi — displays each beneficiary's vested amount, claimable tokens, and cliff/end dates. Claim button sends transaction; ethers.js formats token amounts with correct decimals across ERC-20 tokens.
Example: wagmi vesting portal: per-beneficiary schedules, claimable amounts, ERC-20 decimal formatting, transaction status
Web3 Pros and Cons
Every technology has its strengths and limitations. Here's an honest assessment to help you make an informed decision.
Advantages
viem TypeScript Safety
viem generates TypeScript types directly from contract ABIs — calling a contract function with wrong parameter types is a compile error, not a runtime failure. This eliminates entire categories of bugs common in less type-safe Ethereum SDKs.
wagmi Reduces Boilerplate
wagmi's React hooks (useReadContract, useWriteContract, useWatchContractEvent, useAccount, useBalance) abstract wallet state management, transaction lifecycle, and block subscription into clean, composable hooks that reduce dApp component code by 60%+.
WalletConnect v2 Universal Support
WalletConnect v2 connects 300+ wallets — MetaMask, Coinbase Wallet, Rainbow, Ledger hardware, mobile wallets — through a single integration with QR code and deep link pairing. Users aren't required to have a specific browser extension.
ethers.js Ecosystem Maturity
ethers.js is battle-tested across thousands of production dApps — deeply documented, with extensive community examples, Stack Overflow answers, and tutorial coverage. When something breaks, the solution is findable.
L2 Fee Reality
Arbitrum, Base, and Optimism transactions below $0.01 make transaction-heavy dApp UX economically viable in 2026. The barrier that killed most Web3 consumer apps in 2021-2022 is largely resolved for EVM L2 deployments.
RainbowKit UX Polish
RainbowKit provides a production-ready wallet connection modal with multi-wallet support, chain switching UI, and transaction confirmation flows — eliminating weeks of wallet UX development and providing a consistent, polished first impression.
Limitations
RPC Endpoint Reliability
Public RPC endpoints (Cloudflare, Alchemy public, Infura free) rate-limit and experience downtime. Production dApps that rely on public RPCs fail under load or during network congestion.
We configure production dApps with dedicated RPC providers (Alchemy, Infura, QuickNode) with fallback providers and automatic retry logic. For high-stakes trading interfaces, we implement multiple parallel RPC providers and route to the fastest responding one.
Transaction UX Complexity
Multi-step transactions (approve + swap, approve + stake + claim) and wallet confirmation popups create UX friction for non-crypto-native users. Each transaction requires a separate wallet signature and on-chain confirmation wait.
We design optimistic UI patterns that show expected outcomes immediately while awaiting confirmation, implement ERC-4337 session keys to batch approvals for power users, and use permit2 (Uniswap) to eliminate separate approval transactions for supported tokens.
Cross-Chain State Complexity
Applications operating across multiple chains (Ethereum + 3 L2s) must handle chain switching, bridging state, and per-chain RPC management simultaneously — significantly more complex than single-chain applications.
We use wagmi's multi-chain configuration with viem's chain registry, implement explicit chain-switching UX rather than silent fallbacks, and use cross-chain indexers (Alchemy, The Graph) to provide unified data access across chains.
Key Management & Security
User-controlled wallets mean there's no 'forgot password' — lost private keys mean permanent asset loss. Web3 applications can't recover user funds when wallets are compromised.
We implement ERC-4337 smart wallets with social recovery for consumer applications where key management complexity would exclude mainstream users. For financial applications, we provide clear key security guidance and recommend hardware wallet usage for large holdings.
Web3 Alternatives & Comparisons
We use all of these in production — the right choice depends on your project's constraints, team familiarity, and scale requirements.
Web3 vs Ethereum
Learn More About EthereumEthereum Advantages
- •Ethereum is the primary chain Web3 frontend libraries connect to
- •All EVM-compatible chains (Arbitrum, Base, Optimism) use the same ethers.js/viem APIs
- •Ethereum's 88M+ smart contracts provide the deepest protocol composability for frontend integration
- •EIP-1193 provider standard ensures uniform wallet interaction across all Ethereum wallets
Ethereum Limitations
- •Ethereum is the blockchain layer; ethers.js/viem is the frontend library — complementary, not competitive
- •Ethereum mainnet gas costs affect transaction UX; L2s resolve this for most consumer applications
- •Smart contract logic lives on-chain; Web3 frontend libraries only communicate with it
- •Chain selection determines what contracts are available; library choice affects developer experience only
Ethereum is Best For:
- •All Ethereum and EVM-compatible chain dApp frontend development
- •DeFi protocols, NFT marketplaces, and DAO frontends on Ethereum and L2s
- •Any application requiring wallet connection and smart contract interaction
When to Choose Ethereum
Ethereum and Web3 frontend libraries (ethers.js/viem/wagmi) are used together — Ethereum provides the smart contracts, ethers.js/viem provides the JavaScript interface to them. Choose Ethereum (vs Solana) for the chain; choose viem (vs ethers.js) for the frontend SDK. Both decisions are independent.
Web3 vs Solana
Learn More About SolanaSolana Advantages
- •@solana/web3.js v2 is Solana's equivalent frontend SDK — different API but similar purpose
- •Solana's Wallet Adapter provides unified wallet connectivity analogous to WalletConnect
- •Anchor's TypeScript client provides type-safe Solana program interaction like viem for Ethereum
- •Solana's $0.00025 fees make high-frequency dApp interactions economically viable
Solana Limitations
- •@solana/web3.js is not the same as Web3.js (Ethereum) — they're unrelated libraries
- •Solana frontend patterns differ significantly from EVM — account model, transaction structure, instruction format
- •Solana dApp development requires learning Solana-specific concepts even for frontend-only developers
- •DeFi composability options are narrower than Ethereum's $99B TVL ecosystem
Solana is Best For:
- •Consumer dApps targeting Solana's 2.2M daily active wallet user base
- •NFT projects using Metaplex standard and Magic Eden/Tensor marketplaces
- •High-frequency trading interfaces requiring sub-second confirmation UX
When to Choose Solana
Choose @solana/web3.js + Anchor client + Wallet Adapter when building on Solana. Choose ethers.js/viem + wagmi + WalletConnect when building on Ethereum or EVM L2s. The library choice follows the chain choice — they're both frontend SDKs for their respective ecosystems.
Web3 vs IPFS
Learn More About IPFSIPFS Advantages
- •IPFS stores NFT metadata and large assets that Web3 dApps reference via content-addressed URIs
- •js-ipfs and @helia/ipfs provide JavaScript libraries for IPFS interaction in Web3 frontends
- •Pinata's JavaScript SDK simplifies NFT metadata upload from dApp frontends without running IPFS nodes
- •IPFS URIs resolve in Web3 browsers (Brave) and via public gateways (Cloudflare, Pinata)
IPFS Limitations
- •IPFS is a storage protocol, not a blockchain interaction library — complementary to ethers.js/viem
- •IPFS handles off-chain storage; ethers.js/viem handles on-chain state — they serve different layers
- •Most Web3 dApps use IPFS for NFT metadata without deep frontend IPFS integration
- •HTTP gateway access to IPFS content is sufficient for most dApp display requirements
IPFS is Best For:
- •NFT dApps uploading and displaying IPFS-stored artwork and metadata
- •dApps storing user-generated content off-chain with on-chain content hash proofs
- •Applications requiring censorship-resistant content storage referenced from smart contracts
When to Choose IPFS
Use IPFS alongside ethers.js/viem/wagmi for NFT metadata and large asset storage. The Web3 frontend layer handles blockchain interaction; IPFS handles decentralized off-chain storage. They're both needed in a complete NFT or content-heavy Web3 application.
Why Choose Code24x7 for Web3 Development?
We've built DeFi interfaces handling millions in daily volume, NFT mint sites processing thousands of transactions in minutes, and DAO governance portals used by token communities. We write Web3 frontends with the 2026 standard stack — viem + wagmi + RainbowKit — not deprecated Web3.js. We know how to handle RPC rate limits under load, design multi-step transaction UX that doesn't frustrate users, and implement cross-chain state management that doesn't introduce data consistency bugs. Our Web3 frontends are production-grade: error handling, loading states, and transaction status are first-class citizens, not afterthoughts.
DeFi Interface Development
We build DeFi frontends with viem + wagmi — swap interfaces, lending dashboards, yield farming portals, and liquidity management UIs with real-time contract state, transaction simulation, and gas estimation.
NFT Marketplace & Mint Sites
We develop NFT collection mint sites and marketplace interfaces with RainbowKit wallet connection, ERC-721/1155 contract interaction, IPFS metadata display, and Seaport/Blur marketplace integration.
Wallet Integration
We implement WalletConnect v2 + wagmi for multi-wallet support covering 300+ wallets, EIP-1193 provider handling, chain switching UX, and Sign-In With Ethereum authentication flows.
Smart Contract Frontend Bindings
We generate type-safe TypeScript clients from contract ABIs using viem + wagmi — useReadContract, useWriteContract, and useWatchContractEvent hooks with automatic TypeScript inference for all contract parameters and return values.
Cross-Chain dApps
We build multi-chain applications across Ethereum, Arbitrum, Base, and Optimism with wagmi's chain configuration, chain switching UX, per-chain contract addresses, and cross-chain bridge integrations.
RPC Infrastructure Setup
We configure production RPC infrastructure with Alchemy or Infura primary providers, fallback provider chains, multicall optimization to batch on-chain reads, and caching layers for public data that doesn't change per-block.
Services That Use This Technology
Questions from Developers and Teams
Web3.js (the Ethereum library at web3js.org) was officially archived on March 4, 2025. Do not use it for new projects. The standard replacements: viem (TypeScript-native, 35KB, strict ABI-derived types — recommended for new projects in 2026), ethers.js v6 (most widely used, 70% of Solidity devs, comprehensive ecosystem). wagmi is the React hooks layer that can use either underneath. For existing Web3.js projects, migration to ethers.js is lower-risk (more similar API); migration to viem provides stronger TypeScript safety.
wagmi is a React hooks library for Ethereum that abstracts wallet management, contract reads/writes, and transaction lifecycle into composable hooks. Without wagmi: manually manage wallet connection state, poll for balance updates, track transaction confirmations, handle chain switching events. With wagmi: useAccount() for wallet state, useReadContract() for contract reads (auto-caches, refetches on block), useWriteContract() for transactions with built-in pending/success/error states, useWatchContractEvent() for real-time events. wagmi uses either ethers.js or viem underneath — your choice.
ethers.js v6: mature, 70% adoption, comprehensive documentation, works everywhere. Slightly larger bundle. viem: TypeScript-native (strict ABI-derived types catch errors at compile time), 35KB bundle (40% smaller than ethers.js), modern API design inspired by ethers.js but with stricter safety. viem is increasingly the default for new TypeScript-first projects; ethers.js remains valid for projects prioritizing ecosystem compatibility and documentation depth. Both work with wagmi as the React layer on top.
WalletConnect v2 is a protocol that connects dApp frontends to crypto wallets across devices — browser extension wallets (MetaMask), mobile wallets (Rainbow, Trust Wallet), and hardware wallets (Ledger). The dApp displays a QR code or deep link; the wallet scans it and establishes an encrypted WebSocket session. WalletConnect v2 uses a relay server for message routing — dApp and wallet communicate without direct network connectivity. wagmi's createConfig with WalletConnect connector handles the integration with one package installation.
RainbowKit is a React library providing a polished wallet connection modal — it displays available wallets, handles WalletConnect QR codes, shows network switching UI, and provides customizable themes. It's built on top of wagmi + viem. Use it for: any consumer dApp where wallet UX quality matters, projects that don't want to build wallet connection UI from scratch, and applications targeting non-technical users who need clear wallet selection guidance. The customization options cover most brand requirements without forking.
Sign-In With Ethereum (EIP-4361) is a standard for wallet-based authentication — users sign a nonce message with their wallet, proving ownership of an Ethereum address. Implementation: (1) Frontend requests a nonce from your backend. (2) User signs a structured SIWE message with their wallet via wagmi's useSignMessage. (3) Backend verifies the signature using ethers.js or viem's verifyMessage. (4) Backend issues a session JWT tied to the verified Ethereum address. The siwe npm library handles message construction and verification according to the EIP-4361 standard.
Transaction lifecycle has three distinct states: (1) Submitted — transaction sent to mempool, not yet mined. (2) Confirmed — transaction included in a block. (3) Failed — transaction reverted on-chain. wagmi's useWriteContract provides isPending, isSuccess, isError, and the transaction hash for each state. For UX: show optimistic state immediately (assume success for most interactions), provide clear pending feedback with block explorer link, handle rejection gracefully (user can cancel in wallet), and display revert reasons from contract custom errors.
Don't use public RPCs in production — they rate-limit aggressively and experience downtime during high network usage. Production options: Alchemy (most popular, generous free tier, comprehensive API), Infura (Ethereum's original infrastructure, reliable), QuickNode (fastest raw performance), Drpc (decentralized, multi-provider aggregation). Configure primary + fallback providers in viem's createPublicClient with multiple transport fallbacks. Use Alchemy's Enhanced APIs for token balances, NFT data, and transaction simulation to reduce RPC call volume.
Multicall batches multiple read calls into one RPC request — instead of 10 separate eth_call requests, one call returns all 10 results. Wagmi uses multicall by default for useReadContracts. Use multicall when: displaying token balances for multiple tokens simultaneously, reading state from multiple contracts (DeFi protocol TVL across pools), or loading a list of NFT token URIs. Performance impact: reduces dashboard load time from 1-2 seconds (10 serial requests) to 100-200ms (one batched request).
We offer support covering: library updates as ethers.js, viem, wagmi, and RainbowKit release breaking-change versions, wallet compatibility updates as wallet providers change their APIs, RPC provider migrations, new contract integration as protocols expand, UI updates for new chain additions, and performance monitoring for RPC call patterns that create latency. We also provide rapid incident response if contract upgrades change ABIs that break the frontend.
Still have questions?
Contact Us
What Makes Code24x7 Different
We ship Web3 frontends that handle the failure modes crypto users encounter in production: RPC timeouts, stuck transactions, wallet disconnects mid-flow, and chain switches at the wrong moment. Loading states, error messages, and transaction retry flows are designed from day one — not added as an afterthought. We've debugged MetaMask gas estimation failures, WalletConnect session drops, and multicall revert propagation at 11 PM before a launch. That experience is baked into how we build, not just how we test.