Skip to content

Burn‑to‑Win Prize Pool

A provably‑fair prize system where SQUDY is destroyed (burned) to mint tickets. Some rounds also allow staking for multipliers. Burns permanently shrink supply; prizes come from campaign fees, sponsors, and treasury allocations.

Concept Overview

Burn to Win represents a revolutionary approach to token economics and user engagement. This mechanism transforms the traditional concept of token burning into an interactive, rewarding experience where participants can win substantial prizes while contributing to the token's deflationary pressure.

How It Works

The Burn to Win mechanism operates through a sophisticated smart contract system that manages prize pools and winner selection. Participants stake their SQUDY tokens into designated prize pools, with each pool having specific parameters including entry requirements, prize structure, and duration.

When users enter a pool, their staked tokens are locked for the pool duration. At the conclusion of each pool cycle, the smart contract executes a transparent selection process to determine winners. A portion of the staked tokens from all participants is permanently burned, reducing the overall token supply. Winners receive prizes that can include remaining SQUDY tokens from the pool, exclusive NFTs or digital assets, partnership tokens or rewards, and access to premium features or future pools.

2.1 Design Goals

  • Simple entry, strong deflation, visible prize funding, and public verifiability.

  • Fun cadence (daily/weekly) with multiple tiers so more users win.

  • Sustainable: prizes are sourced from revenue & sponsors; burns are never re‑minted.

2.2 System Components

  • PoolFactory → deploys & manages prize pools.

  • PrizePool → holds prize funds, ticket ledger, and integrates RNG.

  • TicketToken (soulbound) → non‑transferable ERC‑1155 or internal ledger representing entries.

  • VRFOracle Adapter → Chainlink VRF integration for randomness.

  • Treasury Router → splits inflows from dCampaign fees & sponsors.

2.3 Entry Mechanics

Mode A – Burn Tickets (default):

  • Users call enter(amount); amount SQUDY is burned; tickets = amount / ticketPrice.

  • Example: ticketPrice = 10,000 SQUDY; burn 50,000 SQUDY → 5 tickets.

Mode B – Stake & Burn Yield (optional rounds):

  • Users stake SQUDY in a round; at draw time a small portion (e.g., 1–3%) of the round total is burned; staking boosts ticket multipliers; principal is withdrawable post‑round.

  • Used for special “low burn, high TVL” events.

2.4 Multipliers & Tiers

  • Staking Multiplier: holding or staking ≥ thresholds (e.g., 100k / 1M / 10M SQUDY) increases tickets by 1.1× / 1.25× / 1.5×.

  • dCampaign Achievements: verified quest completions can grant bonus multipliers (e.g., +10%).

  • Referral Bonus: referrer gets +5% tickets when referee enters within the same epoch.

2.5 Rounds & Payouts

  • Cadence: Daily micro‑prizes + Weekly grand prize.

  • Winners: multiple tiers (e.g., 1× grand, 10× major, 100× minor).

  • Prizes: SQUDY (default) or partner tokens/NFTs; prize asset is disclosed pre‑round.

  • Unclaimed: roll‑over after a claim window (e.g., 14 days).

2.6 Funding Sources & Splits (configurable via DAO)

  • dCampaign Fees: default split → 40% prize pools, 30% burn, 30% treasury.

  • Sponsors/Partners: direct deposits (stablecoins or tokens).

  • Treasury Top‑ups: scheduled top‑ups approved by DAO for major events.

2.7 Fairness & Compliance

  • Randomness: Chainlink VRF proof published on‑chain; anyone can replicate selection.

  • Geofencing: certain jurisdictions may be excluded per legal requirements.

  • KYC for Large Prizes: winners over a compliance threshold may require verification (off‑chain provider).

2.8 Smart‑Contract Interfaces (abridged)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
interface IPrizePool {
  function config() external view returns (
    uint256 ticketPrice,
    address prizeAsset,
    uint256 epoch,
    uint256 closesAt
  );
  function enter(uint256 amount) external; // burns SQUDY, mints tickets
  function draw() external;                // VRF→winners, emits events
  function claim(uint256 epoch, uint256 prizeId) external;
  event Enter(address indexed user, uint256 epoch, uint256 burned, uint256 tickets);
  event Draw(uint256 indexed epoch, bytes32 vrfRequestId);
  event Win(address indexed user, uint256 epoch, uint256 prizeId, uint256 amount);
}

2.9 Risk Guardrails

  • Per‑wallet entry caps per epoch, max tickets per wallet, circuit breakers if price volatility > X% intraperiod, pausable by multisig (with on‑chain reason).