The commitment behind every Tower Rush round
Provably fair is a narrow but genuinely useful promise: the result of a round is settled before you act on it, and you can demonstrate afterwards that it was not altered while you played. The mechanism is a commitment, and Tower Rush Original carries it inside the client itself: the Galaxsys build derives the outcome from a secret string, publishes a fingerprint of that string before the round begins, and then discloses the string itself afterwards so you can confirm the fingerprint belonged to it.
Three inputs go into the calculation. The server seed is the operator's secret, produced per round or per series of rounds. The client seed is yours, editable from the fairness panel at any time. The salt is a further fixed string mixed in so that common seed pairs cannot be worked out in advance and stored in a lookup table. Hashed together the three produce the round; hashed alone, the server seed produces the fingerprint you were handed first.
The order of events is what makes the guarantee hold:
- Before the round, the client displays a hash of the server seed, a value that cannot be turned back into the seed.
- You set or accept a client seed, which the server cannot anticipate once you have replaced it with something of your own.
- The round plays out: the crane swings, you build, you drop, and you decide when to collect.
- After the round closes, the server discloses the plain server seed together with the salt it used.
- You hash the disclosed seed, compare it with the fingerprint you were given first, then rehash the full combination and compare that with the result you watched.
If both comparisons match, the server had settled on that outcome before it could know your client seed and left it untouched afterwards. If either comparison fails, the round was not the one you were promised, and that is a concrete and reportable fact rather than a suspicion you have to argue about.
The four values and who controls each one
Checking a round becomes much simpler once you know which value comes from where. Two of the four belong to the operator's server, one belongs to you, and one exists purely to make precomputation pointless. All of them are reachable from the fairness panel of the authentic client, though deliberately not all at the same moment.
Timing is the detail most people skip over. The fingerprint has to be available before the round, and the plain server seed only once the round has finished. A panel that reveals everything at once, or that reveals nothing until you write to support and wait, is not operating a commitment scheme at all. It is simply showing you numbers.
| Value | What it is | Who controls it | When you can see it |
|---|---|---|---|
| Server seed | The secret string from which the round outcome is derived | The operator's server | Only once the round has closed |
| Server seed hash | A one-way fingerprint of that seed, which cannot be reversed | Produced by the server and shown to you | Before you commit to the round |
| Client seed | A string you supply, folded into the same calculation | You, editable from the fairness panel | At any moment, before and after alike |
| Salt | An extra fixed string that defeats precomputed lookup tables | Published by the provider or the operator | Disclosed alongside the server seed |
| Round hash and result | The output those inputs produce for that one round | Fixed by the inputs and by nothing afterwards | While the round plays, and later in your history |
Change your client seed at least once before you rely on any of this. It is the single action that shows the commitment is live rather than ornamental: a server that had already settled an outcome against a seed you have just replaced cannot produce a matching fingerprint, so a client that quietly ignores your edit has answered the question for you.
Verifying one specific round, step by step
The procedure below applies to a single round from your history. You need the values the fairness panel gives you and any SHA-256 calculator, whether that is the provider's own verifier, a reputable open-source page or a one-line command on your own machine. Running it once against a round you actually remember is worth more than reading about it ten times over.
Step one: capture the fingerprint before you play
Open the fairness panel and copy the server seed hash shown for the coming round. Paste it somewhere outside the game, whether a note file or a message to yourself, as long as you control it. This is the only value you must record in advance, because everything else can be gathered afterwards. Without it, a later comparison establishes nothing, since you would be trusting the site to tell you what it had promised.
Step two: put in a client seed of your own
In the same panel, replace the default client seed with a string you invent and save it. Note it exactly as entered, capital letters included. This step converts a stored record into an actual proof: the outcome now depends on a value the server played no part in choosing, so it cannot have been picked to suit the house once the numbers were known.
Step three: disclose, rehash and compare
Play the round, then reopen the panel and read the disclosed server seed and salt. Hash that seed with SHA-256 and compare the output character by character against the fingerprint you saved in step one; the two must be identical. Then hash the full combination of server seed, client seed and salt in the order the verifier specifies, and confirm that it reproduces the round you watched. Two matches, and the round is verified.
- Store the pre-round fingerprint outside the client, since the whole check hangs on that one anchor.
- Record your client seed exactly as typed, because a single altered character produces an entirely different hash.
- Compare hashes across their full length rather than by the first few characters, and rotate your seeds from time to time.
