Rules, payouts and RTP for every Market Game.

Games

RTP

This guide describes the games at their standard RTP: 95 % for the Tap games and Tap Up/Down, 97 % for Market Race.

Section 1Tap Markets™ and the Tap games

1.1 Description

Tap the box, beat the clock. A fast prediction game on a live price chart. A grid of cells is laid over the chart ahead of the current price. Each cell is a short time window and a price band and shows a multiplier. The player taps a cell to stake on it and wins if the price touches the cell in time.

Tap BTC (Bitcoin), Tap GOLD (gold), Tap OIL (crude oil) and Tap Sports Clubs (one index per club) are Tap Markets™ on their own synthetic index, each with its own UI. The rules (1.2) and the pricing (1.3) are the same in every Tap game, at the same RTP. Each category can carry more indices of the same kind (for example other coins in Tap Crypto, or silver in Tap Metals). How each index is made is described in section 4.

1.2 Rules

1. The player selects an index, a cell size (2 or 4 seconds; 3 seconds where offered) and a stake.
2. The player taps a cell. Only cells whose window starts at least a few seconds ahead can be tapped.
3. The server accepts the tap, reserves the stake and locks the multiplier it confirms for the cell.
4. Win: the index's mid price, (bid + ask) ÷ 2, touches the cell's price band at any moment during the cell's time window. Band edges count, and a price move that crosses the band between two ticks counts. The win is settled immediately at the touch.
5. Loss: the window ends without a touch.
6. Void: if the price feed is interrupted during the cell's window, or the index is closed while the tap is open, the stake is returned.
7. A win pays stake × multiplier (stake included). A loss pays nothing. A tap cannot be cancelled once accepted.

Limits: stake per currency (default 0.10–50 EUR or equivalent), up to 30 open taps per player, up to 3 taps per cell per player, a total stake limit per cell, and a maximum multiplier per board.

1.3 Payout and RTP

Each cell's multiplier is set from the probability P that the price touches it, given the index's current volatility, the cell's distance from the price and how soon it starts:

multiplier = RTP ÷ P          95 % RTP, P = 0.38 → 2.50x

The touch probabilities are measured on each index's own price model at the board's exact cell size and kept in line with live volatility. Every cell is therefore priced at the target RTP: 95 % at the standard setting, on both the 2 s and the 4 s board, in every Tap game.

Each board has a maximum multiplier (up to 100x). A cell whose fair multiplier would be above the maximum pays the maximum; those cells, far from the price, return less than the target.

Section 2Tap Up/Down

2.1 Description

Higher or lower: one decision. The player calls whether a synthetic index will be higher (Up) or lower (Down) at the end of a 5–20 second round. Each side shows its own payout, which moves with the market and with the money on the game (the Turbo payout model).

2.2 Rules

1. The player selects an index, a stake and a round length: 5, 10, 15 or 20 seconds.
2. The player calls Up or Down. The payout shown on that side when the call is accepted is locked for the call.
3. Entry price: the mid price, (bid + ask) ÷ 2, when the server accepts the call.
4. Settlement price: the mid price at expiry (entry time + round length).
5. Win: Up and settlement > entry, or Down and settlement < entry. Pays stake × (1 + payout).
6. Loss: Up and settlement < entry, or Down and settlement > entry. Pays nothing.
7. Tie: settlement = entry. The stake is returned.
8. Void: if the entry or settlement price cannot be established (price feed interruption), the stake is returned.
9. A call always runs to expiry; there is no early close.

Stake limits are set per currency (default 0.10–50 EUR or equivalent).

2.3 Payouts

Up and Down are equally likely over a few seconds, so a payout of r returns ½ × (1 + r). The base payout is therefore set from the RTP:

base payout = 2 × RTP − 1          95 % RTP → 90 %

The operator chooses one of two modes per index.

Fixed payouts. Both sides pay the base payout at all times (90 % at 95 % RTP).

Dynamic payouts (default). Both sides are recalculated every 2 seconds in four layers:

1. See-saw. The Up payout takes a random step of up to ±2 points, kept within the base ±5 points; the Down payout mirrors it (Down = 2 × base − Up). At 95 % RTP the two sides move between 85 % and 95 % and always average 90 %.
2. Pool exposure. The side with more money on it pays up to 10 points less and the other side up to 10 points more, in proportion to the imbalance of open stakes: imbalance = (Up − Down) ÷ (Up + Down).
3. Stretch. z is how far the price sits from its average over the last minute, in standard deviations. From |z| = 1 the side that continues the move is raised, reaching 106 % at |z| ≥ 2.5, and the side that bets on the snap-back is cut by up to 12 points. The indices' price models pull stretched prices back, so after a large move the continuation is the less likely outcome; the higher payout reflects its lower probability.
4. Flares. About once a minute (a 1-in-30 chance every 2 seconds) one side, chosen at random, is lifted to 96–106 % for 6–10 seconds.

Payouts are kept between 70 % and 106 % and shown to the whole percent.

2.4 RTP

• Fixed mode: every call returns the target RTP, 95 %.
• Dynamic mode: the see-saw and the exposure layer move the two sides in opposite directions around the base, so averaged over both sides the RTP is the target, 95 %. The stretch layer prices the continuation side by its lower probability and trims the more likely side, so it keeps the margin. A call on a flared side can return more than the target (up to 103 % at the 106 % ceiling); the operator can switch flares off or lower the ceiling.
• Ties are refunded, which adds a fraction of a percent.

Section 3Market Race

3.1 Description

Four markets race for 30 seconds. Every runner starts from the same line, and its position is its percentage price growth since the start. The player backs one or more runners while the race is on and wins if their runner finishes first.

Market Race is pool betting between players: all stakes on a race form one pool, and the pool, less the house share, is divided between the winning bets.

3.2 Rules

1. Schedule. Races run back to back on the server clock, anchored to UTC: 30 s race, 4 s result, 5 s countdown (a 39 s cycle). All players see the same race.
2. Runners. Four indices per race, set by the operator (standard: Tap BTC, Tap ETH, Tap SOL, Tap BNB).
3. Start price. Each runner's last tick at or before the start time.
4. Position. growth = (price − start price) ÷ start price × 100 %, updated on every tick.
5. Finish price. Each runner's last tick at or before the finish time.
6. Winner. The runner with the highest growth at the finish.
7. Dead heat. If two or more runners share the highest growth, each is a winner and the pool is divided equally between them (3.3).
8. Betting. Open from the start of the race until 2 seconds before the finish. A player may place several bets per race, on one or several runners.
9. Void race. All stakes are returned if a runner has no start price, if the price feed of any runner is interrupted during the race, or if no runner moved.

Start and finish prices are taken from tick timestamps on the server, never from the time a device received them.

3.3 Payout

At the finish the pool, less the house share, is divided between the winning bets in proportion to their stakes:

payout per 1 staked = RTP × T ÷ W      (at least 1.00)
T = total pool, W = pool on the winning runner

A winning bet never pays less than its stake.

• Dead heat between k runners: the bets on each winning runner share 1/k of the pool, so the payout per 1 staked on that runner is RTP × T ÷ (k × W), at least 1.00.
• If nobody backed the winner, all stakes are returned.
• Each runner's card shows the money on it and a forecast of the payout. The payout is fixed by the final pools at the finish, not by the forecast when the bet was placed.

3.4 RTP

97 % at the standard setting. The house keeps up to 3 % of each pool (less when nearly all the money is on the winner, because a winning bet always gets at least its stake back). The house never pays out more than was staked.

Limits: minimum and maximum stake per currency, set by the operator.

Section 4Prices and indices

• Every game runs on synthetic indices produced by our price generator. It publishes one stream per index with bid, ask and a millisecond timestamp on every tick. Results are always decided on the server on these published prices; every player sees the same prices.
• The indices that follow a real market take their reference prices from licensed data providers (dxFeed, Finage; Binance for the club tokens).

Tap Up/Down runs on any of these indices, as the operator chooses.

How the market-linked indices work (Tap BTC as the example). The index follows the real Bitcoin price within its band. Large real moves pass through; the second-by-second path is its own random walk. It trades 24/7, continuing around the last real price when the market is closed or the source pauses.

Section 5RNG

• Algorithm: HMAC-SHA256 deterministic random bit generator (NIST SP 800-90A family). Each draw is the first 8 bytes of HMAC-SHA256(key, label) mapped to a uniform number in (−1, 1). The label is the tick slot and the purpose of the draw.
• Keys: a secret master key per region. For the fully synthetic indices the key of each 30-second round comes from a daily seed chain:

  seed[2879] = HMAC-SHA256(master key, "chain:<index>:<day>")
  seed[k]    = SHA-256(seed[k+1])
  head       = SHA-256(seed[0])        published before the day starts

• No system random source and no clock reads inside the generator: the same key and slot always give the same draw, so every synthetic price step can be replayed.

Section 6Verification and provably fair

Price integrity (every index). Each tick's hash is SHA-256(index | bid | ask | last | time | previous 5 hashes), sent with the tick and kept in a public ledger. Changing, adding or removing a tick breaks every later hash.

Provably fair generation (fully synthetic indices, such as the Tap Markets™ house index).

1. Before each day the head of each index's seed chain is published.
2. During each 30-second round the prices are generated with that round's seed.
3. Five seconds after the round its seed is revealed, with a per-tick generation record and the model parameters.
4. Anyone can check that the seed hashes forward to the committed head and recompute every price step. A public verifier (browser page and verify_fairness.py) does this for any index and day; no access to our systems is needed.

The market-linked indices (Tap BTC, Tap GOLD, Tap OIL, Tap Sports Clubs and the Market Race runners) are covered by price integrity; part of their movement comes from the real market, so they are not replayed from seeds.

What the player sees

Section 7Enable the games on your platform

What you need to list the games once the logic above is clear: the assets for your lobby, the tiles as they look in place, and the integration options.