Degen.com Provably Fair Audit: Full Source Code Analysis of 14 In-House Games

1. Methodology

Degen.com is a single-page application built with React and bundled with Vite. The entire frontend — including all fairness algorithms — is delivered as client-side JavaScript. This means the code that determines game outcomes runs in the player’s browser and is fully inspectable.

1.1 Source Extraction

We identified and downloaded the JavaScript modules containing all fairness logic:

The index-Bhe537iM.js chunk contains developer-written, commented verification scripts for all 14 games directly embedded in the code. This provides unparalleled transparency.

1.2 Analysis Approach

For each game, we verified:

• Determinism: Does the same input (server seed, client seed, nonce) always produce the same output?
• Uniformity: Is the output distribution unbiased across the valid range?
• Independence: Are sequential outputs statistically independent?
• Commitment: Is the server seed committed (hashed) before the player makes a decision?

2. Architecture Overview

Most modern crypto casinos standardize on HMAC-SHA256. Degen.com splits its architecture into two distinct models depending on the game type.

3. Shared Cryptographic Primitives

3.1 HMAC-SHA512 Implementation

13 of the 14 games depend on HMAC-SHA512. The core primitive from Degen’s codebase:

async function hmacSHA512(serverSeed, message) {
  const key = await crypto.subtle.importKey(
    'raw', new TextEncoder().encode(serverSeed),
    { name: 'HMAC', hash: 'SHA-512' }, false, ['sign']
  );
  const sig = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(message));
  return bytesToHex(new Uint8Array(sig));
}

Assessment: Correct. Uses the Web Crypto API (crypto.subtle), ensuring native, timing-attack-resistant cryptographic operations directly within the browser engine.

Note: The message format string is {clientSeed}:{nonce}:{cursor}. In single-outcome games (Dice, Limbo, Roulette), the cursor is replaced with a static string (e.g., "DICE" or "LIMBO"). This is valid and mathematically sound.

3.2 Hex to Float Extraction

To convert the 64-byte hex string into a usable decimal number between 0 and 1, Degen uses a standard 32-bit floating-point extraction method:

function bytesToFloat(hash) {
  const b = [0, 2, 4, 6].map(i => parseInt(hash.slice(i, i + 2), 16));
  return b[0] / 256 + b[1] / 65536 + b[2] / 16777216 + b[3] / 4294967296;
}

Assessment: Standard implementation (commonly seen in Stake-derived algorithms). It takes the first 4 bytes (8 hex chars) and maps them to a float with a precision of 1 in 4.29 billion.

4. Permutation Algorithms

4.1 Fisher-Yates Shuffle

Used by: Mines, Keno, Stacks, Chicken Crossing.

For games requiring a unique selection from a finite pool, Degen correctly implements a Fisher-Yates style rejection/splice algorithm. For example, in Mines:

let available = Array.from({ length: 25 }, (_, i) => i);
let mines = [];
for (let cursor = 0; cursor < mineCount; cursor++) {
  const hash  = await hmacSHA512(serverSeed, `${clientSeed}:${nonce}:${cursor}`);
  const float = bytesToFloat(hash);
  const index = Math.floor(float * available.length);
  mines.push(available[index]);
  available.splice(index, 1);
}

Assessment: Textbook-correct implementation. The pool correctly shrinks (splice) ensuring no duplicate values are selected, yielding a uniform distribution.

5. Discovered Flaws & Technical Deviations

Our cryptographic review uncovered a few mathematical deviations from absolute perfection.

5.1 Modulo Bias (No Rejection Sampling)

In games like Roulette (37 outcomes) and Card Games (52 cards), Degen calculates the result by taking the 32-bit float and multiplying it directly:

Math.floor(float * 37)

Because the maximum number of combinations (4,294,967,296) is not perfectly divisible by 37 or 52, a tiny phenomenon known as modulo bias is introduced. Some numbers have exactly a 1 in 4.29 billion higher chance of appearing than others.

Severity: Cosmetic. The bias (approx 2.33 × 10⁻¹⁰ per outcome in Roulette) is statistically undetectable. However, strict cryptographic best practice dictates using Rejection Sampling to eliminate this completely.

5.2 The "Infinite Deck" in Card Games

For Blackjack, Baccarat, Casino War, and Switch variants, Degen.com explicitly states they use an "Infinite Deck". Every card drawn is generated independently using the formula Math.floor(float * 52), without removing the drawn card from a virtual shoe.

Implication: Card depletion effects do not exist. It is entirely possible to see five or more Aces of Spades in a single round if enough cards are drawn across multiple hands. While mathematically fair (every draw has a 1/52 chance), this changes the traditional house edge and optimal basic strategy compared to real-world multi-deck shoes.

Severity: Informational. This is a game design choice, clearly documented in their fairness modal, rather than a cryptographic flaw.

5.3 Crash uses a different HMAC Model

Crash uses HMAC-SHA256 instead of HMAC-SHA512 and doesn't allow players to set their own client seed. Instead, the global client seed is the Bitcoin Genesis block hash. This is the exact same model used by BC.Game and Stake for Crash.

Severity: Informational. This is necessary for multiplayer games to ensure all players receive the same deterministic outcome.

6. Complete Game-by-Game Summary

* Crash applies a 1% house edge mathematically. This is transparent, not a bias in the RNG.

7. Findings

7.1 Strengths

• S1 — Transparency: Degen.com provides complete, readable JavaScript verification algorithms directly on their Provably Fair page, serving as a model for industry transparency.
• S2 — Correct Fisher-Yates implementation: The splice/rejection algorithms used in Mines, Keno, Stacks, and Chicken Crossing are mathematically sound.
• S3 — Web Crypto API usage: All HMAC-SHA512 operations use the browser's native crypto.subtle API.
• S4 — Per-cursor entropy: Games requiring multiple random values per round use unique HMAC hashes via cursor incrementation, preventing correlation.

7.2 Weaknesses

• W1 — Modulo bias in some games: Uses value % N without rejection sampling in games like Roulette and Cards. Bias is negligible in practice but inconsistent with perfect bias elimination. Severity: Low.
• W2 — Infinite Deck model: Card games draw with replacement. While mathematically fair per draw, it fundamentally alters standard strategy expectations. Severity: Informational.

7.3 Recommendations

8. Conclusion

Degen.com operates a highly secure and verifiably fair casino platform. Their client-side cryptographic architecture is robust, utilizing HMAC-SHA512 natively in the browser for almost all original games.

While purists might point out the minor modulo bias in certain games or the "infinite deck" mechanics in card games, none of these affect the fundamental fairness or trustlessness of the platform. Players can confidently verify their bets knowing the house has no backdoor to manipulate outcomes.