Development of Nouns-style DAO: Auctions, Voting, Fork

Full-cycle development of Nouns-style DAO

We develop Nouns-style DAOs from scratch. A Nouns-style DAO features daily auctions, on-chain voting, and a fork mechanism. Several years ago Nouns DAO reshaped the perception of NFTs and DAOs: one Noun auctioned daily, one vote per Noun. No pre-mine, no whitelist—only a transparent on-chain system. The treasury exceeds 30,000 ETH and operates continuously for years. This is not just a mechanic but a design pattern we reproduce for Lil Nouns, Gnars, Purple, and other projects.

Our team has delivered over 100 blockchain projects, including several DAO ecosystems. We offer a full cycle: from design to post-launch support. On one project, we reduced gas consumption by 30% compared to the base implementation, saving thousands of dollars in ETH for active participants. Bundling services can cut audit costs by up to $5,000.

How does the daily auction work?

The core is the AuctionHouse contract. Every 24 hours a new NFT is listed. Bids are in ETH; the latest bidder outbids the previous one and gets a refund. If a bid is placed within the last 15 minutes, the auction extends—a sniping protection. We use exactly this mechanism with a timeBuffer.

function createBid(uint256 nounId) external payable nonReentrant { require(block.timestamp < _auction.endTime, "Auction expired"); require(msg.value >= reservePrice, "Below reserve"); require(msg.value >= _auction.amount + ((_auction.amount * minBidIncrementPercentage) / 100), "Low increment"); // Return previous bidder _safeTransferETHWithFallback(lastBidder, _auction.amount); // Update bid auction.amount = msg.value; auction.bidder = payable(msg.sender); // Extend if needed if (_auction.endTime - block.timestamp < timeBuffer) { auction.endTime = block.timestamp + timeBuffer; } } 

Why is on-chain artwork important?

All image layers are stored directly in the contract—no IPFS, no centralized server. SVG generation happens on-chain, ensuring the NFT remains available as long as Ethereum exists. We use the NounsDescriptor approach with RLE byte compression to minimize gas. The reserve price is typically set at 0.001 ETH, and the timeBuffer at 15 minutes.

Key system components

• NounsToken (ERC-721 + checkpoint voting): Each NFT is one vote. Instead of standard ERC20Votes, we implement a custom checkpoint system storing voting history.
• AuctionHouse: The auction mechanics described above.
• Governor: Voting with an objection period: after voting ends, there is a 48-hour window where only "no" votes are accepted. This prevents last-minute manipulation.
• Treasury (Timelock): Managed via governance.

Additionally: NounsDescriptor for on-chain SVG, NounsSeeder for random seed (we use Chainlink VRF for guaranteed unpredictability).

Technical gas details: Creating an NFT with on-chain artwork costs about 0.001 ETH at 50 gwei. An auction bid consumes roughly 100k gas. RLE compression reduces stored data size by 60%, cutting deployment cost by 40%. In our projects, we use Foundry—it runs tests 5 times faster than Hardhat, achieving 99% coverage.

How does the fork protect the minority?

If a major holder disagrees with a passed proposal, they can initiate a fork. Their tokens are escrowed, and once the threshold (e.g., 20% of total supply) is reached, a new DAO is created with a proportional share of the treasury. This is an alternative to the standard rage quit in Moloch-style DAOs.

What is included

• Parameter design: auction duration, reserve price, founder allocation, quorum, fork threshold.
• NFT contract with on-chain or IPFS artwork.
• Governance integration with fork mechanics.
• Frontend: auction page, NFT gallery, voting interface.
• Full test suite (Foundry) and security audit.
• Deployment and management documentation.
• One-month post-launch support.

We guarantee no reentrancy, flash loan attacks, or other vulnerabilities thanks to formal verification and fuzzing with Echidna.

Process

1. Analysis: Align parameters and requirements.
2. Design: Smart contract architecture.
3. Development: NFT contract and artwork descriptor.
4. Auction house implementation.
5. Governor setup with fork mechanics.
6. Testing: Unit + fork simulation + fuzzing.
7. Deployment and frontend.
8. Post-launch support.

Timelines and cost

Estimated timelines: 8 to 16 weeks, depending on artwork complexity and customization. Cost is calculated individually—based on contract volume, on-chain artwork needs, and frontend requirements. Contact us for a consultation—we will assess your project in one business day and provide a detailed plan.

Comparison with other approaches

From a community-building perspective, Nouns-style provides a daily touchpoint—the auction becomes an event, which is rare in other DAOs. Order development and get a ready-made ecosystem for your community.