HomeCollectionRoadmapTokenomicsAboutCommunity
Join Community
Draw Activates at Sellout

The Lottery

10,000 NFTs. One monumental draw. Three life-changing prize winners. Transparent, verifiable, and built on provably fair mechanics.

Lottery Status: Pending Sellout

6,847 / 10,000 NFTs Minted

3,153 NFTs remaining before lottery activation

68.47% sold
Mechanics

How the Draw Works

STEP 01

Activation Trigger

The lottery activates automatically when all 10,000 NFTs are sold. No manual trigger, no admin override.

STEP 02

Eligibility Check

Every NFT holder at the snapshot block is eligible. One NFT = one entry. Multiple NFTs = multiple entries.

STEP 03

Point Weighting

Engagement points (tasks, referrals, community activity) increase your entry weight. Formula is fully published.

STEP 04

Provably Fair Draw

The winning selection uses verifiable on-chain randomness. All inputs are publicly auditable before and after draw.

STEP 05

Prize Distribution

Top 3 winners receive cash prizes split 60/25/15. Distributed within 48 hours of verified winner announcement.

STEP 06

Reuse & Future Draws

Each NFT is consumed per draw. Buy additional NFTs to participate in future lottery events.

Entry Weight System

Fully Transparent · Publicly Auditable

Each NFT gives you 1 base entry. Engagement points multiply that entry weight. The formula is published and cannot change after lottery activation.

1 NFT Held+1.0x base entry
Level 5+ Account+0.2x multiplier
100+ Referral Points+0.15x multiplier
Task Completion Streak+0.1x multiplier
Community Verified Badge+0.05x multiplier

Max weight cap is 3.0x per NFT. All multipliers are disclosed before lottery activation.

Prize Structure

1
1st Place
60% of prize pool
2
2nd Place
25% of prize pool
3
3rd Place
15% of prize pool

Important Disclosures

  • ·Winning is not guaranteed
  • ·Prize amount depends on total mint revenue
  • ·Each NFT can only be used once per draw
  • ·Non-winners retain ownership and utility
  • ·The platform helps resale but cannot guarantee it
Provably Fair

The Draw Algorithm

Every line of the lottery engine is transparent. Below is the exact logic that selects winners — reproducible by anyone with the public VRF seed and entry hashes.

Entry Hashing

Every entry (user + NFT) is hashed with SHA-256 before the draw. This commits all participants publicly without revealing VRF inputs.

VRF Seed Commitment

Chainlink VRF generates a cryptographically secure random seed that is verifiable on-chain. Anyone can audit the seed post-draw.

Cumulative Weighting

Entries are mapped to a cumulative weight distribution. Higher engagement = larger slice. The cap at 3.0x prevents whale dominance.

Binary Search Selection

A random point lands on the cumulative curve. Binary search finds the winner in O(log n) time. Every step is reproducible.

No Replacement Draw

Once a winner is selected, their index is excluded. 1st place is drawn first, then 2nd, then 3rd — guaranteeing unique winners.

Public Verification

All inputs (entry hashes, VRF seed, weights) are published. Any developer can run the same code and get identical results.

Lottery Engine Source Code

Run this yourself with the public VRF seed and entry list to verify any draw.

lottery_draw.py
python
1
import hashlib
2
import secrets
3
import random
4
from typing import List, Dict, Tuple
5
 
6
def weighted_lottery_draw(
7
entries: List[Dict],
8
vrf_seed: str,
9
num_winners: int = 3,
10
max_weight_cap: float = 3.0
11
) -> List[Tuple[str, int, float]]:
12
"""
13
Provably fair weighted lottery draw.
14
15
Args:
16
entries: List of {user_id, nft_id, base_weight, bonus_weight}
17
vrf_seed: Chainlink VRF seed (hex string)
18
num_winners: How many winners to draw (default 3)
19
max_weight_cap: Maximum weight multiplier per entry
20
21
Returns:
22
List of (user_id, place, total_weight) tuples
23
"""
24
# 1. Compute total weight per entry with cap
25
weighted_entries = []
26
for e in entries:
27
total = min(
28
e["base_weight"] + e["bonus_weight"],
29
max_weight_cap
30
)
31
weighted_entries.append({
32
"user_id": e["user_id"],
33
"nft_id": e["nft_id"],
34
"weight": total,
35
"hash": hashlib.sha256(
36
f"{e['user_id']}:{e['nft_id']}".encode()
37
).hexdigest()
38
})
39
40
# 2. Build cumulative weight distribution
41
cumulative = []
42
running_sum = 0.0
43
for e in weighted_entries:
44
running_sum += e["weight"]
45
cumulative.append(running_sum)
46
47
total_weight = cumulative[-1]
48
49
# 3. Deterministic random from VRF seed
50
# Anyone can reproduce this with the same seed
51
random.seed(vrf_seed)
52
53
winners = []
54
used_indices = set()
55
56
# 4. Draw winners sequentially without replacement
57
for place in range(1, num_winners + 1):
58
# Generate verifiable random point on weight distribution
59
rand_val = random.uniform(0, total_weight)
60
61
# Binary search for selected entry
62
left, right = 0, len(cumulative) - 1
63
selected_idx = 0
64
while left <= right:
65
mid = (left + right) // 2
66
if cumulative[mid] >= rand_val:
67
selected_idx = mid
68
right = mid - 1
69
else:
70
left = mid + 1
71
72
# Skip if already won (no replacement)
73
while selected_idx in used_indices:
74
rand_val = random.uniform(0, total_weight)
75
left, right = 0, len(cumulative) - 1
76
while left <= right:
77
mid = (left + right) // 2
78
if cumulative[mid] >= rand_val:
79
selected_idx = mid
80
right = mid - 1
81
else:
82
left = mid + 1
83
84
used_indices.add(selected_idx)
85
winner = weighted_entries[selected_idx]
86
87
winners.append((
88
winner["user_id"],
89
place,
90
winner["weight"]
91
))
92
93
return winners
94
 

How to Verify a Draw

  1. Download the published entry list (user_id, nft_id, base_weight, bonus_weight) from the public audit log.
  2. Copy the VRF seed from the on-chain event after draw execution.
  3. Run the code above with those exact inputs. The output winner list must match the official announcement exactly.
  4. If even one character differs, the draw is provably invalid — but this has never happened.

Ready to Enter the Draw?

Mint your NFT to secure your entry before sellout.