Gamwiz LogoGamwiz Logo

Gaming Wizardry

X logoX logo
Gamwiz LogoGamwiz Logo

Gaming Wizardry

Getting Started

  • Create Account
  • First Deposit
  • Personalize Gamwiz
  • News

Account

  • Password Security
  • Account Recovery
  • Close Account

Safeplay

  • Deposit Limits
  • Self-Exclusion
  • Responsible Gaming

Payments

  • Supported Crypto
  • Withdraw Funds
  • Deposit with USDT

Legal

  • Terms & Conditions
  • Betting Rules
  • Responsible Gaming
  • KYC Policy
X logoX logo
Responsible Gaming
18+ Age Restriction18+ Age Restriction
BeGambleAwareBeGambleAware
NCPGNCPG

Gamwiz.com is owned and operated by Gamwiz Inc. Registration number: C62780, registered address: Unit 207, Heritage Plaza II, Main Street, Charlestown, Nevis. Contact us: support@gamwiz.com. Gamwiz.com is licensed and regulated by the Government of the Autonomous Island of Anjouan, Union of Comoros, and operates under License No. ALSI-202602039-FI2. Gamwiz.com has passed all regulatory compliance and is legally authorized to conduct gaming operations for any and all games of chance and wagering.

Copyright © 2026 Gamwiz.com. All rights reserved.

    • Slots
    • Blackjack
    • Roulette
    • Baccarat
    • Parties
    • Roll For Cashback
    • Missions
    • Shard Shop
    • Rewards & Loyalty
    • Wager Wars
    • Affiliate Program
    Roll for Cashback
    Loading…
    Gamwiz LogoGamwiz Logo
    Gamwiz LogoGamwiz Logo
    Loading…
    Gamwiz LogoGamwiz Logo
    Gamwiz Casino
    Loading…
    Gamwiz LogoGamwiz Logo
    Gamwiz LogoGamwiz Logo

    Provably fair, checked by you

    Don't take our word for the result. Recalculate it.

    Use the disclosed proof values to reproduce one calculated result.

    Check it on this device, or download readable Python code that runs on your computer and makes no network requests.

    Set up local verificationCheck proof on this device

    No Gamwiz account is needed to check proof values you already have. Opening a private Gamwiz game record still requires the account that owns it.

    Disclosed proof values

    Seed, hash, nonce, label and range

    Your device runs the math

    No callback decides the answer

    One reproducible result

    Matched, mismatched or not checked

    The calculation is the evidence

    A badge can repeat an operator's claim. Reproducible proof lets you use the disclosed inputs to reach the same result in an environment you control.

    A claim you receive

    “Trust us” is not verification

    An operator or integrated checker can report that a result passed. That is still a claim until the disclosed inputs reproduce the outcome in an environment you control.

    Evidence you reproduce

    Run the disclosed calculation yourself

    The same inputs must produce the same output in your browser or in the readable file you save to your computer.

    What this check proves — and what it doesn't

    Provably fair has a precise scope. This page keeps each part of the evidence separate so a partial check is never presented as a complete one.

    Seed commitment

    A revealed server seed produces the supplied SHA-256 hash. This is meaningful only if that hash was recorded before the result.

    Reproducible calculation

    The disclosed server seed, client seed, nonce, label and modulo reproduce one deterministic HMAC-SHA256 output.

    Recorded outcome

    If you supply the result you received, the verifier compares it with the recalculated one and reports a match or mismatch.

    This is not a blanket certificate for a casino

    It does not prove that seeds were selected randomly, that every game uses this method, that published odds or historical prize tables were accurate, or that an operator is legal, solvent, secure or reliable at withdrawals.

    On-device calculation

    No calculation request sent

    Check proof on this device

    Paste the disclosed values below. The supported HMAC-SHA256 calculation runs in this browser; values you type here are not submitted to Gamwiz for calculation.

    The revealed secret seed, written as hexadecimal.

    Optional. Add the hash recorded before the result to check the commitment.

    The client value included in the disclosed calculation.

    The zero-based use number for this seed and calculation format.

    Choose the exact message label format used by the proof.

    The size of the bounded number range used by this calculation.

    This becomes part of the signed message and must match exactly.

    Optional. Enter the one-based result you received to compare it with the calculation.

    After this page loads, values you type stay in this browser while it calculates. Values included in a shared page URL are part of that page request and may remain in browser history or server logs. The separate saved-game lookup above, when present, is account-backed and networked.

    Your evidence will appear here

    Enter the disclosed proof values. Each completed check will report matched, mismatched or not checked.

    Standalone verifier

    Run the same calculation outside Gamwiz

    Download a readable Python file, inspect every line, then run it on your computer with no account, callback or network request.

    Makes no network requests
    Readable before you run it
    No Gamwiz account required

    The full walkthrough is clearer on a computer

    You can still check proof and download the file on this phone. On desktop, this section also shows the complete source, a platform selector and the exact command to run.

    1. 1Download the Python verifier to this device or copy this page link.
    2. 2Open the page on a computer and inspect the complete source before running it.
    3. 3Run one command and compare the reported checks with your proof.

    Save the verifier

    Choose your computer, then download gamwiz-pf-verifier.py. Values from the form above are included when available.

    Your computer

    The file stays on your computer. Empty required values are requested in the terminal when it starts.

    Run one command

    python3 gamwiz-pf-verifier.py

    The script reports the commitment check, calculated pointer, one-based outcome and optional recorded-outcome comparison separately.

    Read it before you run it

    The file uses only Python's standard hashlib and hmac libraries. There is nothing to install and no hidden service call.

    Inspect the complete sourcePython 3
    #!/usr/bin/env python3
    """Gamwiz compatible provably fair verifier.
    
    Runs locally with Python's standard library. This file makes no network calls.
    It checks one HMAC-SHA256 calculation format only; other formats need their own verifier.
    """
    
    import hashlib
    import hmac
    
    SERVER_SEED_HEX = ""
    SERVER_SEED_HASH = ""
    CLIENT_SEED = ""
    NONCE = "0"
    LABEL = ""
    MODULO = "6"
    RECORDED_OUTCOME = ""
    
    
    def required(value: str, prompt: str) -> str:
        return value.strip() or input(prompt).strip()
    
    
    server_seed_hex = required(SERVER_SEED_HEX, "Server seed (hex): ")
    server_seed_hash = SERVER_SEED_HASH.strip()
    client_seed = required(CLIENT_SEED, "Client seed: ")
    nonce = int(required(NONCE, "Nonce: "))
    label = required(LABEL, "Game label: ")
    modulo = int(required(MODULO, "Modulo: "))
    server_seed = bytes.fromhex(server_seed_hex)
    if not server_seed:
        raise ValueError("Server seed is missing")
    if nonce < 0:
        raise ValueError("Nonce must be zero or greater")
    if modulo <= 0:
        raise ValueError("Modulo must be greater than zero")
    
    computed_hash = hashlib.sha256(server_seed).hexdigest()
    if server_seed_hash:
        commitment_matches = hmac.compare_digest(
            computed_hash.lower(), server_seed_hash.lower()
        )
        print("Commitment:", "MATCH" if commitment_matches else "MISMATCH")
    else:
        print("Commitment: NOT CHECKED (server seed hash was not supplied)")
    
    space = 2 ** 64
    limit = (space // modulo) * modulo
    counter = 0
    while True:
        message = f"{client_seed}:{nonce}:{label}:{counter}".encode("utf-8")
        digest = hmac.new(server_seed, message, hashlib.sha256).digest()
        window = int.from_bytes(digest[:8], "big")
        if window < limit:
            pointer = window % modulo
            break
        counter += 1
    
    outcome = pointer + 1
    print("Computed server seed hash:", computed_hash)
    print("Pointer (zero-indexed):", pointer)
    print("Outcome (one-indexed):", outcome)
    
    if RECORDED_OUTCOME:
        recorded_outcome = int(RECORDED_OUTCOME)
        print(
            "Recorded outcome:",
            "MATCH" if recorded_outcome == outcome else "MISMATCH",
            f"({recorded_outcome})",
        )
    else:
        print("Recorded outcome: NOT CHECKED")
    

    Keep it, share it or delete it

    The file is standalone. It creates no account, installs no package and leaves no background process running.

    You can use this file for another operator only when it discloses the exact same calculation: HMAC-SHA256 over clientSeed:nonce:label:counter, the first eight digest bytes as a big-endian integer, rejection sampling, modulo and a one-based outcome. Matching field names alone is not enough.

    Understand the evidence

    The short answers behind the fields, the calculation and its limits.