Lock Slot

Provably Fair

Every spin on Lock Slot is cryptographically verifiable. You can independently verify that outcomes are fair and unmanipulated.

SHA-256 Hashing
Commit-Reveal Scheme
Open Source
What Does Provably Fair Mean?

Provably fair means you can mathematically verify that every spin outcome was determined fairly, without any possibility of manipulation by us or anyone else.

Unlike traditional casinos where you must trust the house, Lock Slot uses cryptographic techniques that allow you to independently verify every single spin result after the fact.

Server Seed

We generate a secret seed before each epoch and publish its hash as a commitment.

Client Seed

You provide your own random seed, ensuring we cannot predict or manipulate your outcome.

Combined Hash

Both seeds combine with a nonce to create a deterministic, verifiable outcome.

How It Works

1

Epoch Begins - Server Commits

At the start of each epoch (21-day period), we generate a random serverSeed and publish its SHA-256 hash. This hash is our commitment - we cannot change the seed without changing the hash.

// Server seed hash (published before epoch)
serverSeedHash = SHA256(serverSeed)
2

You Spin - Client Seed Generated

When you spin, your browser generates a random clientSeed. This seed is sent to our server along with your spin request. Since you generate this seed, we cannot have predicted it in advance.

// Client seed (generated by your browser)
clientSeed = randomBytes(16).toHex()
3

Outcome Calculated Deterministically

The server combines both seeds with your spin number (nonce) using SHA-256 hashing. The resulting hash deterministically determines your tier, lock duration, and multiplier.

// Combined hash calculation
combinedHash = SHA256(serverSeed + clientSeed + nonce)
// First 8 hex chars → roll value (0-1)
rollValue = parseInt(hash.slice(0,8), 16) / 0x100000000
4

Epoch Ends - Server Seed Revealed

When the epoch ends, we reveal the original serverSeed. You can now hash it yourself and verify it matches the commitment we published at the start. Then you can recalculate any spin result independently.

// Verification
SHA256(revealedServerSeed) === publishedHash // Must be true!

Outcome Probabilities

TierRoll RangeProbabilityLock DurationBonus Eligible
BRICK0.00 - 0.4545%36-48 hoursNo
MID0.45 - 0.7328%18-36 hoursNo
HOT0.73 - 0.8815%8-18 hoursNo
LEGENDARY0.88 - 0.979%3-8 hours✓ Yes
MYTHIC0.97 - 1.003%1-3 hours✓ Yes

Win rate (Legendary + Mythic): 12% of all spins

Verification Code

JavaScript Verification
// Verify a Lock Slot spin result
const crypto = require('crypto');

function verifySpin(serverSeed, clientSeed, nonce) {
  // Step 1: Generate combined hash
  const combined = `${serverSeed}:${clientSeed}:${nonce}`;
  const hash = crypto.createHash('sha256').update(combined).digest('hex');
  
  // Step 2: Convert first 8 hex chars to roll value (0-1)
  const rollValue = parseInt(hash.substring(0, 8), 16) / 0x100000000;
  
  // Step 3: Determine tier from roll value
  const tiers = [
    { name: 'brick', threshold: 0.45 },
    { name: 'mid', threshold: 0.73 },
    { name: 'hot', threshold: 0.88 },
    { name: 'legendary', threshold: 0.97 },
    { name: 'mythic', threshold: 1.00 }
  ];
  
  let tier = 'brick';
  for (const t of tiers) {
    if (rollValue < t.threshold) {
      tier = t.name;
      break;
    }
  }
  
  return { hash, rollValue, tier };
}

// Verify server seed commitment
function verifyServerSeed(revealedSeed, publishedHash) {
  const calculatedHash = crypto.createHash('sha256')
    .update(revealedSeed)
    .digest('hex');
  return calculatedHash === publishedHash;
}

// Example usage:
const result = verifySpin(
  'your_server_seed_here',
  'your_client_seed_here',
  1  // your spin nonce
);
console.log(result);

Open Source

Lock Slot is fully open source. You can audit our RNG implementation, smart contracts, and verification logic yourself. We have nothing to hide.

Frequently Asked Questions

Can you manipulate my spin results?

No. Because we commit to the server seed hash before you spin, and you provide your own client seed, neither party can manipulate the outcome. The result is determined by both inputs combined.

When can I verify my spins?

You can verify all your spins after the epoch ends, when we reveal the server seed. This delay is necessary to prevent you from finding favorable client seeds in advance.

What if the revealed seed doesn't match the hash?

If SHA256(revealedSeed) does not equal the published hash, it would prove we cheated. This has never happened and never will - it would destroy all trust in our platform instantly.

Why use SHA-256?

SHA-256 is a cryptographic hash function used by Bitcoin and countless security systems worldwide. It is computationally infeasible to reverse (find the input from output) or find collisions (two inputs with same output).