The NFT lottery that publishes its odds

Most NFT lottery products hide the odds. Fake World Assets puts them onchain and documents them. If you build on Solana — games, NFT finance, pack rips, fair random allocation — FWA is a reference design worth learning, then rebuilding with Solana-native tools.

Product: fwa.fun. Docs start: How it works.

Click to zoom

What FWA is

Fake World Assets (Ethereum) works like this:

1. Depositors list an NFT and lock ETH beside it (the backing).
2. Backing funds a standing bid to buy the NFT back, and makes heavier deposits harder to win.
3. Anyone can pay a pool price for one random position from the pool.
4. Chainlink VRF picks which position.
5. The winner keeps the NFT or takes the bid (ETH / $FWA). Not both.

Depositors earn fee share while their NFT stays unselected. Main risk: selected early, fee life ends sooner than expected.

Read: Overview · Roles.

Concepts to teach

Position = NFT + exclusive backing

Each listing pairs one NFT with its own ETH. That ETH is not pooled or lent across positions. It pays the standing bid, sets draw weight, and is the depositor stake.

Docs: Positions and weighting.

Weight: less backing, drawn more often

Light positions fill most outcomes. Heavy positions are rare draws and tend to stay in the pool longer, so they can earn fees across more acquisitions.

Docs: Positions and weighting.

Price tracks what you usually get

Acquisition price is roughly the expected value of the position you are likely to receive (skewed cheap), plus a surcharge (about 10% default), plus a separate VRF fee. Buyers can set bounds so a moving pool does not fill a stale quote.

Docs: Pricing and allocation.

Fairness is VRF plus queue order

Chainlink VRF supplies randomness. Requests finish in creation order. New deposits wait while requests are open so they cannot jump into an in-flight draw. Missing VRF words can expire; pool fee can refund, VRF service fee stays with the service.

Docs: Pricing and allocation · Safety.

After the draw: keep or take the bid

Keep the NFT, or sell back into the depositor standing bid for most of the backing. Exclusive choice — the moment users remember.

Docs hub: fwa.fun/docs.

How depositors earn

Acquisition fees (after protocol cut) split equally across active positions — not “bigger backing gets bigger share per fee.” Bigger backing still tends to earn more over a full life because it stays unselected longer. Early selection is the depositor risk the docs call out.

Docs: Fees and protocol revenue.

Deal or No Deal — useful analogy

Same shape people already know:

• Sealed value (briefcase vs NFT + backing)
• After reveal: take the offer or keep the prize — not both
• A third-party deal price (banker vs standing bid)

Different for builders:

• FWA is a live two-sided pool, not a fixed TV board
• Odds are weighted by backing, not uniform
• The bid is fully funded onchain
• Depositors earn over time until selected

Workshop line: Deal or No Deal where the cases are NFT+ETH pairs, the banker offer is a pre-funded bid, and the host is verifiable randomness.

Product links

• App — fwa.fun
• Docs hub
• Overview
• Deployments / contracts

Use the deployments page for Etherscan addresses when you need contract-level truth.

Rebuild on Solana: what to use

Same user loop and fairness rules. Solana-native stack — not a line-by-line Ethereum clone. Inspired by FWA mechanics; use your own brand.

Onchain program

Minimum instructions builders need:

• deposit NFT + SOL backing
• request acquisition (pay price + randomness fee)
• process fulfilled randomness (anyone can crank)
• settle keep or accept bid
• withdraw when the queue is idle
• admin: collection whitelist, pause, fee settings

Keep each position’s SOL separate. Do not merge backing into one shared pot.

Randomness APIs

FWA uses Chainlink VRF on Ethereum. On Solana, wire request → fulfill → process with:

• Switchboard on-demand randomness (common default; buyer pays)
• Orao VRF (alternative)
• Chainlink on Solana — check what is live before you hard-depend on a specific API

Keep the queue rule: open requests settle in order; new deposits stage until the queue is clear. Randomness without that rule is not enough.

DevRels: Switchboard. Vendor: docs.switchboard.xyz.

MagicBlock

Use when the product should feel instant around a slower base settle:

• Session keys so rip-again is not a popup farm
• Ephemeral Rollups for live UI, spectate, pack animation
• Optional private ER for entertainment-only intermediate state

NFT custody and SOL backing stay on base Solana for settlement. MagicBlock speeds the experience; it is not the bank.

DevRels: MagicBlock real-time · examples · Builders. Vendor: docs.magicblock.gg.

Proof Network

Make the pool readable to dashboards and agents:

• Clear pool and position views
• MCP / skills so tools can read odds and status without scraping HTML

DevRels: ProofNetwork MCP.

NFT and indexer APIs

• Metaplex Token Metadata or Core for deposit escrow
• Helius DAS (or similar) to list wallet NFTs and collection metadata in UI
• Collection allowlist at deposit

DevRels: DAS API · Metaplex Core. Vendor: developers.metaplex.com.

Price feeds (optional)

FWA prices off backing, not NFT floor oracles. If you add Pyth or Switchboard prices, use them for UI context — not as a silent replacement for the pool formula unless you mean to redesign the product.

DevRels: Pyth.

A sensible Solana MVP

• One collection whitelist
• SOL only — no reward token on day one
• Deposit, acquire, randomness, keep or sell-back
• Equal fee share while active
• Docs that state early-selection risk in plain language
• Own brand — inspired by FWA mechanics, not a TokenWorks skin

Builder path this week

1. Open fwa.fun and walk the UI (or docs if a flow is gated).
2. Read overview → weighting → pricing → fees → safety.
3. Use deployments for contract addresses.
4. Write your Solana instruction list from the MVP above.
5. Pick randomness (start with Switchboard docs) and implement request / fulfill / process first.
6. Add MagicBlock for UX and Proof Network for agent-readable pool state after the base loop works.

Resources

• fwa.fun
• FWA docs hub
• How it works
• Positions and weighting
• Pricing and allocation
• Fees
• Safety
• Roles
• Deployments
• MagicBlock docs
• Switchboard docs
• Metaplex docs
• DevRels — MagicBlock
• DevRels — ProofNetwork
• DevRels — Switchboard
• DevRels — DAS API

Bottom line

FWA is a clear pattern: depositors supply NFT inventory with locked bids, purchasers buy a weighted random ticket, settlement is keep-or-bid, and randomness is queued so it cannot be steered. On Solana, rebuild that loop with Anchor, a VRF provider, and honest docs — then layer MagicBlock for feel and Proof Network for readability. Start from the FWA doc pages; ship the loop; point builders at your own docs the same way.