Final Randomness = keccak256(
  SlotHash(from 300+ validators) ||
  Secret Seed(from Entropy provider) ||
  Sample Number(unique identifier)
)

1. Asset sold at slot 1000
2. Validators produce SlotHash(1005) = 0xABCD...
3. Entropy provider sees slot hash
4. Provider tests different seeds to find favorable outcome
5. Provider submits seed → OUTCOME MANIPULATED

1. Provider generates seed before any slots
2. Provider commits to hash of seed
3. Asset sells at slot 1000
4. Validators produce SlotHash(1005) = 0xABCD... (unknown before commit)
5. Provider reveals seed (cannot change it now)
6. Chain verifies: keccak256(revealed_seed) == original_commit
7. Final value cannot be predicted or controlled

// Entropy provider submits:
pub struct OpenVar {
    pub commit: [u8; 32],  // Hash of secret seed
    pub samples: u64,      // Number of drawings allowed
}

// Admin submits after asset sold out:
pub struct UpdateEndAt {
    pub end_at: u64,  // current_slot + 10
}

// Anyone can call (or backend automation):
// - Reads: SlotHashes sysvar
// - Stores: slot_hash in Var account
// - Timing: Requires current_slot >= end_at

// Entropy provider submits:
pub struct RevealVar {
    pub seed: [u8; 32],  // Matches original commitment
}

// Program validates:
require(keccak256(seed) == var.commit);

// Computes:
var.value = keccak256(var.slot_hash || seed || var.samples)

// Program uses random value:
let winning_token = (var.value % total_tokens) + 1;

// Distributes proceeds:
// - 1.5% → Platform fee account
// - 98.5% → Asset owner

// If winner doesn't claim:
pub struct NextVar {
    pub new_commit: keccak256(previous_seed),
}

// Seed chain prevents provider from choosing new seed

Admin calls: create_asset + open_var (BATCHED)
  ├─ Input: commit from entropy service
  ├─ Creates: Asset PDA with status=ACTIVE
  ├─ Creates: Var PDA with commit stored
  └─ Backend stores: encrypted_seed for later reveal

User 1: init_user + buy_token (BATCHED)
User 2-N: buy_token (SEQUENTIAL)
  └─ Auto-status: SOLD_OUT when all sold

Event: assetSoldOut
  ↓ [5s safety buffer]
TX: update_end_at(current_slot + 10)
  ↓ [Event: varEndAtUpdated]
TX: sample_var (PERMISSIONLESS)
  ↓ [~5 seconds for slot to progress]
TX: reveal_var (Entropy provider)
  ├─ Backend retrieves: stored encrypted_seed
  ├─ Program validates: keccak256(seed) == commit
  ├─ Computes: final_value = keccak256(slot_hash || seed || samples)
  └─ Event: varRevealed

TX: pick_winner
  ├─ Calculates: winning_token = (final_value % total) + 1
  ├─ Distributes: 1.5% fee, 98.5% to owner
  ├─ Updates: Asset.status = COMPLETED
  └─ Event: WinnerSelected

TX: settle_winner
  ├─ Records: winner_address for transparency
  └─ Event: WinnerSettled

// Backend entropy service:
fn generate_seed() -> [u8; 32] {
  use crypto::rand::thread_rng;
  thread_rng().gen::<[u8; 32]>()
}

Encrypted = IV (16) || AuthTag (16) || Ciphertext
  ├─ IV: Random initialization vector
  ├─ AuthTag: Authentication verification
  └─ Ciphertext: AES-256 encrypted seed

1. Generate:   seed = random(32 bytes)
2. Commit:     commit = keccak256(seed)
3. Store:      database.encrypted_seed = AES256_encrypt(seed)
4. Submit:     on_chain.commit = submit_open_var(commit)
5. Secure:     seed locked until reveal (cannot change)
6. Reveal:     encrypted_seed → decrypt → submit to reveal_var
7. Verify:     program checks keccak256(revealed) == commit
8. Complete:   seed used to compute final random value

// Asset created with numberOfTokens = 100
asset.tokensSold = 0

// Each token purchase:
let token_number = asset.tokensSold + 1;  // 1, 2, 3, ..., 100
asset.tokensSold += 1;

// When sold out:
asset.tokensSold == 100 (all tokens sold)

// Get random value from Var account
let random_value = var.value;

// Extract first 8 bytes as u64
let random_u64 = u64::from_le_bytes(random_value[0..8]);

// Select winning token (1-based)
let winning_token_number = (random_u64 % asset.tokensSold) + 1;

random_u64 = 0x123456789ABCDEF0 (some large number)
random_u64 % 100 = 45 (range: 0-99)
+ 1 = 46 (range: 1-100) ✓

1. Random value computed, winner identified
2. Winner doesn't claim within deadline
3. Need to select backup winner from same asset

// First seed was locked:
original_commit = keccak256(original_seed)

// For backup, create new commit:
new_commit = keccak256(original_seed)  // Previous seed becomes new commit!

// This prevents provider from choosing new seed
// Provider is locked into: keccak256(original_seed)

Availability: Last 150 slots (~75 seconds)
Fallback: If older, program uses deterministic hash
Risk: Reduced entropy quality if outside window

[Asset Sold Out]
  ↓ 5 second buffer
[update_end_at] → set end_at = current_slot + 10
  ↓ ~5 seconds (slot progression)
[sample_var] → capture SlotHash(end_at)
  ↓ immediate
[reveal_var] → derive random value
  ↓ immediate
[pick_winner] → select winner