EXIT

An onchain market where customers collectively fund a competitor to a product they hate.

Companies decide what gets built. EXIT lets customers decide.

EXIT turns customer frustration into a market. Users create an onchain pool for a product they want to replace, commit Monad Testnet MON behind a clear replacement brief, and let developers compete to build the better alternative.

This is a Build Anything Spark hackathon project running on Monad Testnet. Testnet MON is used only for hackathon demonstration and has no real value. A production/live version comes after the hackathon and, ideally, after winning.

The Problem

People complain about bad products constantly:

• pricing gets hostile
• data exports are painful
• platforms lock users in
• support quality collapses
• roadmaps ignore the people paying
• alternatives never quite get funded

The internet is full of complaints, but complaints are not a market. Builders cannot easily tell which pain is worth solving, and users cannot coordinate around the replacement they actually want.

EXIT solves that coordination failure.

The Idea

EXIT lets customers create a credible demand signal for a replacement product.

Instead of saying:

"I hate this product."

Users can say:

"Here is what needs to replace it, here are the acceptance criteria, and here is capital committed by people who want the exit."

That changes the conversation from noise to incentive.

How EXIT Works

1. Create an exit pool A user names the product or company they want to replace, explains the problem, defines the desired replacement, and writes acceptance criteria.

2. Commit testnet MON Contributors commit Monad Testnet MON to the pool. The commitment becomes voting power and proves demand for the replacement.

3. Developers compete Developers register for the pool and submit projects that try to satisfy the pool requirements.

4. Contributors vote Contributors vote for one submitted project or None qualify. Voting power equals the contributor's total committed MON.

5. Settle onchain If a project wins, the winning developer receives 90% of the committed pool and EXIT receives a 10% platform fee. If no project qualifies, contributors can claim refunds.

Market Design

EXIT is designed around one question:

What if users could fund the exit before the replacement exists?

The market is created by combining:

• a public replacement request
• locked user commitments
• developer competition
• contribution-weighted voting
• objective settlement rules
• refund safety when nothing good ships

This makes EXIT different from a feature request board, bounty board, or complaint forum. The pool itself is the demand object.

Contract Rules

The core contract is ExitMarket.

Normal pools:

• 30 day build period
• 10 day final voting period
• contributions and submissions freeze after the build deadline
• votes can be changed until the voting deadline

Hackathon demo pools:

• 60 second build period
• 30 second final voting period
• admin-only creation
• permanently labeled onchain as demo pools

Demo pools exist so judges can see the full lifecycle without waiting 40 days.

Settlement rules:

• contributors cannot also be developers in the same pool
• developers cannot commit or vote in the same pool
• voting power equals total committed MON
• top-ups automatically increase the wallet's active vote weight
• quorum passes at exactly 50% of committed MON participating
• None qualify wins ties for safety
• project ties are won by the earlier original submission
• successful pools pay 90% to the winner and 10% to the treasury
• failed pools use individual refunds to avoid unbounded payout loops

Why Onchain

EXIT uses the chain for the parts that need public trust:

• pool creation
• commitment accounting
• developer registration
• project submissions
• voting
• quorum
• finalization
• payout
• refunds

There is no database acting as the source of truth. The smart contract is the market.

IPFS metadata is used for richer pool and project details. The contract stores metadata URIs and hashes so offchain content can be checked against onchain records.

Current Hackathon Deployment

Item	Value
Network	Monad Testnet
Chain ID	10143
Currency	Testnet MON
Contract	0xE651b144c78E58454E62578a495dE47bDBbFAD64
Explorer	https://testnet.monadscan.com/address/0xE651b144c78E58454E62578a495dE47bDBbFAD64#code
Status	Hackathon testnet build

License

EXIT is source-available for hackathon review, learning, personal experimentation, and non-commercial development.

Commercial use is not allowed without prior written permission from the project owner. That includes operating a production service, launching a paid or monetized derivative, rebranding EXIT, or using the contracts, interface, branding, or market design in a commercial product.

See LICENSE for the full terms.

Product Surface

The web app is a working marketplace, not a landing page.

It includes:

• marketplace tabs for Building, Final Voting, Ready to Finalize, Completed, and Failed pools
• search and category filtering
• structured pool creation
• optional initial commitment during pool creation
• wallet connection through Reown AppKit
• Pinata/IPFS metadata upload through a server-side route
• contributor commit and top-up flows
• developer registration
• project submission and update flows
• role-aware voting
• explicit None qualify voting
• finalization and refund states
• persistent Monad Testnet/test MON labeling

Tech Stack

• Solidity
• Hardhat
• OpenZeppelin
• Next.js
• TypeScript
• Tailwind CSS
• wagmi
• viem
• Reown AppKit
• Pinata/IPFS
• Monad Testnet

Repository Structure

.
├── apps
│   └── web                 # Next.js frontend
├── packages
│   └── contracts           # Hardhat smart contracts
├── pnpm-workspace.yaml
└── package.json

Run Locally

Clone the repository:

git clone https://github.com/SouravBeraAkaSpeed/EXIT.git
cd EXIT

Install dependencies:

pnpm install

Create a root .env file:

cp .env.example .env

For the web app, the important local values are:

NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID=...
NEXT_PUBLIC_EXIT_MARKET_ADDRESS=0xE651b144c78E58454E62578a495dE47bDBbFAD64
NEXT_PUBLIC_MONAD_TESTNET_RPC_URL=https://testnet-rpc.monad.xyz
PINATA_JWT=...

Run the app:

pnpm dev

Open:

http://localhost:3000

Run contract tests:

pnpm test

Build the web app:

pnpm --filter @exit/web run build

Test Coverage

The contract test suite covers:

• normal and demo deadlines
• admin-only demo pool creation
• initial commitments and top-ups
• contributor/developer role exclusion
• submission creation and updates
• build deadline enforcement
• contribution-weighted voting
• vote changes and post-vote top-ups
• exact 50% quorum boundary
• None qualify victory and tie behavior
• project tie resolution
• refund paths for failed pools
• exact 90/10 payout distribution
• double finalization prevention
• double refund prevention
• failed transfers
• reentrancy attempts

Current contract test result:

9 passing

Demo Flow

For a successful demo, use at least two wallets:

• Wallet A: contributor
• Wallet B: developer

The same wallet cannot be both contributor and developer in the same pool. That separation is intentional because contributors decide what qualifies while developers compete for the payout.

Recommended hackathon demo:

1. Create a demo pool.
2. Commit testnet MON with Wallet A.
3. Join as developer with Wallet B.
4. Submit a replacement project with Wallet B.
5. Vote for the project with Wallet A.
6. Finalize after the demo voting deadline.

What Comes After Winning

EXIT is intentionally testnet-only for the hackathon.

After validation, the production path can include:

• live deployment
• mainnet-ready risk controls
• better spam resistance
• richer pool discovery
• milestone-based payouts
• builder reputation
• demand analytics
• multi-asset commitments
• deeper IPFS indexing

Philosophy

EXIT is not a complaint board.

It is a coordination layer for credible exits.

When users hate a product enough to fund its replacement, builders should be able to see that demand, compete for it, and get paid by the people asking for the alternative.