NFT Marketplace full evm support with connect wallet

Enterprise Multi-Chain EVM NFT Marketplace Source Code

Step into the decentralized economy with a production-grade, highly scalable, and gas-optimized NFT Marketplace codebase engineered specifically for EVM-compatible ecosystems. Designed from the ground up to solve the liquidity fragmentation, steep gas fees, and poor user onboarding experiences that plague standard decentralized applications, this turnkey software solution provides developers, Web3 enterprises, and venture-backed startups with everything required to deploy, operate, and monetize a modern NFT trading hub.

Whether your objective is to build an OpenSea or Blur competitor, deploy an exclusive curated art gallery, create an in-game asset trading house for blockchain gaming, or establish a specialized Real-World Asset (RWA) tokenization exchange, this software delivers battle-tested modularity. Written in modular TypeScript, Next.js, Tailwind CSS, Node.js, and Solidity, every component reflects enterprise-level engineering standards, stringent security paradigms, and clean architectural separation between contract interfaces, decentralized storage indexing, and frontend presentation layers.

Skip twelve to eighteen months of foundational protocol design, contract vulnerability audits, state indexing pipelines, and wallet handshake debugging. With instant digital delivery, complete uncompiled source files, granular installation guides, and full rights for commercial rebranding, you can launch on testnet within an afternoon and take your proprietary marketplace to mainnet in a fraction of traditional development cycles.

Architectural Design & Core Technology Stack

Modern Web3 platforms demand sub-second UI responsiveness paired with deterministic on-chain execution. Our marketplace engine achieves this balance through a decoupled hybrid architecture: fast off-chain indexing powered by reactive database schemas, gasless order book signatures compliant with EIP-712, and autonomous smart contracts that handle asset settlement strictly when value transfers take place.

Technology Stack Breakdown

• Smart Contracts: Solidity (v0.8.20+) compiled using Hardhat and Foundry frameworks, implementing OpenZeppelin enterprise libraries, custom reentrancy locks, upgradeable proxy configurations (UUPS / ERC-1967), and transient storage execution where applicable.
• Frontend Layer: Next.js (App Router architecture), React, TypeScript, and Tailwind CSS. The interface utilizes atomic design principles, Server-Side Rendering (SSR) for lightning-fast search engine indexing, dynamic metadata generation for social sharing, and responsive layouts calibrated for all viewport resolutions.
• Web3 Provider Integration: Powered by Wagmi, Viem, and RainbowKit, ensuring sub-50ms RPC communication, automated chain switching, persistent session caching, and backward-compatible provider failovers.
• Decentralized Metadata & Storage: Native abstraction layers supporting IPFS (via Pinata, Web3.Storage, or private Kubo nodes) and Arweave (Bundlr Network / Irys integration) with automatic content-identifier (CID) hashing, pin-status verification, and media gateways.
• Indexing Engine & Database: Modular microservice utilizing Prisma ORM on top of PostgreSQL, synchronizing block event emissions (transfers, mints, listings, order fills, cancellations) into low-latency relational views optimized for millisecond search queries, multi-attribute filtering, and real-time activity feeds.
• Caching & Real-Time Sync: Redis in-memory storage for high-frequency order book matching, rate-limiting protection, and WebSocket notification channels broadcasting bid updates, sales alerts, and price floor movements directly to connected browser clients.

Universal Multi-Wallet Connection & Onboarding Suite

Friction during wallet connection is the single greatest cause of bounce rates across decentralized applications. This marketplace package integrates a unified connection modal engineered to handle every leading EVM wallet standard seamlessly, eliminating handshake errors, signature timeouts, and mobile deep-linking failures.

Built upon battle-tested connection libraries, the wallet modal provides both desktop browser extensions and universal mobile deep linking:

• MetaMask: Full desktop extension injection, MetaMask Mobile deep-linking via Universal Links, EIP-1193 event listener bindings for account change, chain switching, and disconnect hooks.
• WalletConnect (v2 Protocol): Zero-configuration QR-code generation and universal bridge relays supporting hundreds of mobile Web3 wallets including Trust Wallet, Rainbow, SafePal, Zerion, Phantom (EVM), and Bitget Wallet.
• Coinbase Wallet SDK: Direct integration with Coinbase Wallet extension, Coinbase Smart Wallet (ERC-4337 passkey authentication support), and mobile app redirects.
• Safe (Gnosis Safe) Multi-Sig Integration: Enterprise-level support for institutional collectors and DAO treasuries executing listings, purchases, and contract adjustments through multi-signature approval queues.
• Automatic Network Detection & Switching: If a user navigates to an asset deployed on Polygon while their provider is locked to Ethereum Mainnet, the interface initiates an inline wallet_switchEthereumChain or wallet_addEthereumChain RPC call, configuring RPC URLs, block explorers, and chain parameters automatically without page reloads.
• Session Persistence & Disconnect Handling: Built-in local storage caches maintain user session states across browser reloads while safeguarding against memory leaks and stale RPC provider references.

Full EVM Ecosystem Compatibility

Deploy on any chain that speaks the Ethereum Virtual Machine protocol without modifying a single line of smart contract code. The contracts and frontend indexing services are configured out of the box with tested parameter presets for the following environments:

• Ethereum (Mainnet & Sepolia Testnet): Maximum liquidity, blue-chip asset standard, and full support for mainnet gas optimization patterns.
• Polygon (PoS & Polygon zkEVM): Ultra-low transactional fees and rapid block finality, perfect for micro-transactions, gaming mints, and mass-market digital collectibles.
• BNB Smart Chain (BSC & BSC Testnet): High-throughput DeFi and retail NFT ecosystem with widespread Trust Wallet and Binance ecosystem adoption.
• Arbitrum One & Optimism (OP Mainnet): Flagship Ethereum Layer 2 rollups delivering sub-cent gas execution with full Ethereum L1 cryptographic security guarantees.
• Base (Coinbase L2): Rapidly growing consumer Web3 ecosystem with direct native on-ramps and frictionless on-chain identity integration.
• Avalanche C-Chain: High-performance subnet architecture and fast deterministic finality.
• Custom EVM Chains & Local Development: Run against local Hardhat, Anvil, or private enterprise consortium testnets (Quorum, Hyperledger Besu) simply by adding RPC endpoints and Chain IDs in the configuration files.

Advanced Trading Mechanics & Smart Contract Standards

The marketplace is equipped with versatile trading modes designed to capture every segment of collector behavior, from instant fixed-price checkouts to high-stakes competitive auctions and gasless listing agreements.

1. Supported Token Standards

• ERC-721 (Non-Fungible Tokens): Complete support for standard ERC-721 and gas-optimized ERC-721A batch minting contracts. Track individual provenance, token metadata, unique trait properties, and historical ownership transfers.
• ERC-1155 (Multi-Token Semi-Fungible Standards): Ideal for gaming items, tickets, recurring editions, and generative utility assets. Enables users to mint and trade multiple quantities of a single token ID in one unified atomic transaction, drastically reducing gas overhead.

2. Fixed Price Direct Sales

Sellers can list individual assets or batch-list multiple items at a defined price point. Buyers can execute purchases in the native chain currency (e.g., ETH, MATIC, BNB) or in ERC-20 stablecoins (e.g., USDT, USDC, DAI) depending on platform configuration. The checkout router automatically manages approval checks, atomic token transfer, platform fee deductions, and creator royalty distributions inside a single execution block.

3. English Auctions (Ascending Reserve Bids)

Host timed competitive auctions with configurable starting prices, reserve thresholds, minimum bid increments, and anti-snipe extensions. If a bid is submitted in the final 5 minutes of an auction, the smart contract automatically extends the deadline by an additional 10 minutes, preventing front-running bots and maximizing seller yield. Outbid funds are held securely or refunded automatically to former bidders upon every new qualifying bid.

4. Dutch Auctions (Declining Price Discovery)

Provide algorithmic price discovery for primary mint drops or high-value secondary listings. The asset price starts at a designated ceiling and steadily decreases over a predefined timeframe until a buyer purchases the item or the reserve floor price is reached.

5. Collection-Wide Bidding & Floor Sweeping

Give power users the tools they expect from elite trading terminals:

• Collection Offers: Buyers lock wrapped native currency (e.g., WETH) into an escrow contract to place a standing bid on any item within a verified collection. Any owner of any item in that collection can instantly accept the offer and cash out.
• Floor Sweeper Cart: An intuitive multi-item shopping cart interface allows traders to select up to 30 floor-priced NFTs across single or multiple collections, execute a single multicall transaction, and batch-purchase every asset in one click to conserve substantial gas fees.

6. Gasless Off-Chain Listings (EIP-712 Typed Structured Signatures)

Sellers do not need to spend gas simply to list an item or lower an asking price. Listings are signed cryptographically using structured typed data signatures via EIP-712. The signed listing is stored in the indexed order book; the only party that spends gas is the buyer when finalizing the transaction, or the seller should they choose to manually revoke an on-chain approval prior to order expiration.

Built-In Monetization: Platform Fees & Creator Royalties

This source code provides comprehensive monetization mechanisms directly under the marketplace owner's governance. Turn your platform into a self-sustaining revenue engine from your very first transaction:

• Configurable Platform Trading Fees: Set a global marketplace fee (e.g., 1.5%, 2.5%, or 5.0%) deducted automatically on every secondary sale. Platform fees are dynamically routed to your specified treasury wallet address, multi-sig vault, or automated profit-sharing smart contract.
• EIP-2981 Standardized Royalty Compliance: Fully compliant with Universal NFT Royalty Standard EIP-2981. Smart contracts query the underlying NFT collection directly to determine creator royalty allocations, protecting original artist earnings across all secondary swaps.
• Custom Platform Royalty Overrides: For legacy collections deployed without on-chain EIP-2981 support, administrators can specify collection-level royalty percentages and designated payout addresses via the marketplace administrative control panel.
• Zero Fee / Promotional Whitelisting: Reward loyal communities or strategic launch partners by exempting specific collections, VIP token holders, or contracted creators from standard platform service fees.

Granular Platform Feature Breakdown

User & Trader Experience

• Customizable User Profiles: Decentralized profile pages featuring banner artwork, avatars, custom usernames, bio information, linked Twitter/Discord social handles, verified email notifications, and ENS (Ethereum Name Service) reverse resolution.
• Personalized Asset Dashboard: Filter and view assets currently held, active listings, submitted bids, auction participations, and comprehensive wallet transaction history.
• Watchlist & Favorites: Bookmark favorite NFTs and follow collections with real-time browser alerts when floor prices drop or new bids are placed.
• Dynamic Trait & Attribute Filtering: Deep metadata parsing allows users to filter items by rarity, background color, weapons, clothing traits, listing status (Buy Now, On Auction, Has Offers), and price ranges (min/max).
• Rarity Score Calculation Engine: Automatic statistical rarity computation using the "Rarity Score" algorithm, presenting item rankings (e.g., #12/10,000) directly on asset detail cards.
• Interactive On-Chain Activity Feeds: Detailed transaction graphs displaying complete provenance, historical sales prices, minting origins, transfer logs, and interactive price-over-time visual charts.

Creator & Launchpad Features

• No-Code Studio Minting: Creators can upload image, audio, video, 3D model (GLTF/GLB), and HTML5 interactive files to mint 1-of-1 NFTs or multi-edition collections without writing any code.
• Automated IPFS Uploads: Background workers optimize media files, generate responsive thumbnails, pin raw assets to decentralized storage clusters, and compile compliant metadata JSON schemas.
• Custom Collection Deployment: Launch verified ERC-721 or ERC-1155 smart contracts directly from the UI, specifying collection names, ticker symbols, royalty splits, and max supply limits.

Security & Smart Contract Safeguards

• Reentrancy Guards: All state-changing payment processing and asset transfer functions are safeguarded with OpenZeppelin's standard nonReentrant execution modifiers.
• Checks-Effects-Interactions Pattern: State variables and balances are updated prior to any external ether or token transfers, eliminating entire categories of reentrancy and drainage exploits.
• Emergency Circuit Breakers (Pausable Contracts): The contract owner can immediately pause trading operations in the event of an upstream zero-day vulnerability or external bridge compromise.
• Pull-Over-Push Payment Architecture: Excess funds, failed auction returns, and uncollected royalties can be isolated in an escrow withdrawal pattern, safeguarding contracts against denial-of-service (DoS) attack vectors caused by recipient gas exhaustion.
• Strict Access Control: Role-based access control (RBAC) powered by AccessControlUpgradeable ensures that only authenticated governance keys can modify platform fee parameters, whitelist registries, or paused states.

Comprehensive Back-Office Administration Panel

Managing your marketplace requires zero direct terminal interaction once deployed. The included administrative dashboard gives your operations team total oversight of platform parameters:

• Financial Management: Update the global platform fee percentage, change payout treasury addresses, and view real-time calculations of generated gross merchandise volume (GMV) and accumulated protocol fees.
• Collection Verification: Grant blue verification checkmarks to authenticated collections, hide fraudulent copycat drops, and manage curated featured spots on the homepage slider.
• Content Moderation & DMCA Takedowns: Instantly flag, shadowban, or hide stolen media, abusive uploads, or illegal metadata from appearing on the frontend indexer while preserving decentralized on-chain immutability.
• Category & Taxonomy Customization: Create and manage navigation taxonomies such as Digital Art, Gaming, Photography, Memberships, PFPs, Music, and Real-World Assets.
• Banner & Marketing Management: Manage hero promotional banners, featured drop announcements, custom markdown landing pages, and launchpad countdown timers without rebuilding the frontend bundle.

Codebase Architecture & File Structure

The package is delivered as a clean, unified monorepo organized for maximum maintainability and modular testing:

├── contracts/                  # Solidity smart contracts
│   ├── core/                   # Marketplace settlement & escrow contracts
│   ├── tokens/                 # ERC-721, ERC-721A, and ERC-1155 implementations
│   ├── interfaces/             # Standard interfaces (IERC721, IERC1155, IERC2981, IMarket)
│   ├── scripts/                # Deployment and network verification scripts
│   └── test/                   # Hardhat and Foundry unit/integration test suites
│
├── frontend/                   # Next.js App Router presentation layer
│   ├── src/
│   │   ├── app/                # Route handlers, dynamic asset pages, profile routers
│   │   ├── components/         # Atomic UI library (Modals, Cards, Filters, Navbar)
│   │   ├── hooks/              # Web3 hooks, contract readers, approval orchestrators
│   │   ├── lib/                # Wagmi configs, Viem clients, IPFS upload utilities
│   │   ├── styles/             # Tailwind utility styles and theming tokens
│   │   └── types/              # TypeScript interfaces and auto-generated contract ABIs
│
├── backend/                    # Node.js event sync microservices & indexing API
│   ├── src/
│   │   ├── indexer/            # Real-time blockchain block & event listener
│   │   ├── controllers/        # RESTful API endpoints for assets, activity, stats
│   │   ├── services/           # Metadata caching, IPFS pinning, order book matching
│   │   └── prisma/             # Relational database schema, migrations, seeders
│
└── docs/                       # Complete architectural diagrams & deployment documentation

Step-by-Step Deployment & Configuration Guide

Deploying the platform requires standard Node.js and database tooling. Follow these streamlined steps to go from zero to a live, production-ready marketplace:

Phase 1: Environment Preparation

1. Clone or unpack the delivered repository into your secure local environment or cloud instance (Ubuntu 22.04 LTS / Debian recommended).
2. Ensure Node.js (v18.x or v20.x LTS), pnpm/yarn, and Docker (optional, for rapid local database provisioning) are installed.
3. Provision a PostgreSQL database instance and a Redis instance (via local Docker or managed services like Supabase, AWS RDS, and Upstash).

Phase 2: Smart Contract Configuration & Deployment

1. Navigate to the /contracts directory and run npm install.
2. Copy .env.example to .env and supply your deployer private key, RPC endpoint URL (Alchemy, Infura, or QuickNode), and your Etherscan/Polygonscan API key for automated source verification.
3. Run the test suite to verify contract integrity: npx hardhat test.
4. Deploy the core marketplace contract to your target EVM network:

   npx hardhat run scripts/deploy.js --network polygon

5. Verify contract source code automatically on block explorers:

   npx hardhat verify --network polygon <DEPLOYED_CONTRACT_ADDRESS> <CONSTRUCTOR_ARGUMENTS>

Phase 3: Database & Indexer Service Initialization

1. Navigate to the /backend directory and install dependencies: npm install.
2. Configure the .env file with database connection strings, marketplace contract address, starting block number, and your Pinata/Arweave API keys.
3. Execute database schema migrations:

   npx prisma migrate deploy

4. Start the background indexer to listen for real-time contract events:

   npm run start:indexer

Phase 4: Frontend Application Deployment

1. Navigate to the /frontend directory and install packages: npm install.
2. Set public environment variables in .env.local (Marketplace Contract Address, Default Chain ID, WalletConnect Project ID, Indexer API URL).
3. Compile the production build:

   npm run build

4. Deploy to your preferred hosting provider: Vercel, AWS Amplify, Cloudflare Pages, or a self-hosted Nginx reverse-proxy setup.

Why Buy This Source Code vs. Building From Scratch

Frequently Asked Questions & Technical Specifications

Is this source code completely uncompiled and white-labeled?

Yes. You receive 100% full, unminified, and uncompiled source code across the entire stack. There are no obfuscated files, no third-party licensing phone-homes, and no hidden dependencies. You are free to adapt, customize, rebrand, and reskin the user interface, extend the smart contracts, or incorporate custom tokenomic models to fit your company's branding.

Are gas-optimization standards implemented in the smart contracts?

The Solidity contracts have been written following strict EVM storage optimization patterns. This includes bit-packing struct variables within standard 32-byte storage slots, leveraging immutable and constant variable designations for immutables, utilizing memory arrays over storage arrays where appropriate, and employing custom errors instead of verbose revert strings to save significant gas during execution reverts.

How does the indexing service prevent missed blocks or RPC dropouts?

The backend sync service implements an idempotent block-tracker worker. It saves the last successfully indexed block height into persistent storage. If your RPC connection drops or restarts, the worker calculates the delta between the last processed block and the current network tip, pulling logs in manageable batches with automatic rate-limit throttling to ensure zero missed sales or transfer records.

Can I accept custom ERC-20 tokens for NFT payments?

Yes. The marketplace contract includes an administrative whitelist mapping for ERC-20 tokens. You can authorize any ERC-20 token (such as your own native project token, USDC, or DAI) to be used as a valid settlement currency alongside native chain coins.

What level of technical expertise is required to deploy?

Familiarity with standard modern web development practices (Node.js, TypeScript, PostgreSQL) and basic smart contract deployment workflows using Hardhat is all that is required. The included comprehensive setup manual guides you step-by-step through environment variables, RPC setups, contract compiling, and production web deployment.

What Is Included in Your Download Package

• Complete Hardhat/Foundry Smart Contract Repository: Includes core marketplace, escrow vaults, ERC-721/ERC-1155 tokens, automated deploy scripts, and 100% passing unit tests.
• Production Next.js TypeScript Frontend: Full client application with App Router, Tailwind CSS UI components, dark/light theme support, and responsive layouts.
• Node.js Event Indexer & REST API: Complete synchronization service, Prisma ORM schemas, and PostgreSQL migration scripts.
• Step-by-Step Documentation: Comprehensive technical guide covering environment setup, testnet/mainnet deployment, RPC configurations, Pinata IPFS keys, and server hardening.
• Lifetime Script Access: Download archive containing full updates and modular improvements.