RGS Jackpot Pools

Reads the progressive jackpot pools of the published game and declares a claim on one when your maths says it hit. A maths node: it runs in the editor preview and compiles to the RGS, where the platform injects the live pools.

On the RGS the node receives the game's live pools (ctx.jackpots): every active pool attached to the game plus every shared pool, as { id, name, pool_type, current_value, claimable } with current_value in minor units and claimable true only for scatter-triggered pools. Mock Pools, Fetch Pools, Game Slug and RGS URL are editor-only and never reach the server. When the game has no active pools, and on Simulate, the node sees an empty list: poolCount is 0 and nothing is claimed.

In the editor, set Mock Pools to the same shape, or set Game Slug to the published game's slug and fire Fetch Pools to GET {rgsUrl}/rgs-fn/{gameSlug}/__jackpots (404 for an unknown slug, 503 while the pool table is unavailable, cached for 10 seconds). The fetched pools are stored and evaluated at once; every later Do uses them instead of Mock Pools. A failed fetch logs the error, writes it to inspect data, empties every output and still fires Done.

Do outputs pools (normalised), poolNames, poolCount, poolValues ({ name: current_value }; wire it to the jackpot ticker) and totalPoolValue. Pool Name selects one pool, by name (case-insensitive) or by id, for poolValue, poolFound and claimable. With Should Claim true (wire Jackpot Tiers hasTier or a scatter-count comparison) the selected pool is claimed when it is claimable, or always when Claim Only If Claimable is false: claims becomes [name] and claimed true.

The node moves no money. Wire claims to a Component Outputs port named jackpotClaims: the platform reads it from the round's data, adds the pool's value to the round win and resets the pool to its seed. The server refuses a claim on a pool that is not scatter-triggered, not active for this game, or named in the request payload; guests are not eligible. Claim Only If Claimable off changes the outputs, never what is paid.

Inputs

Parameters

Data	Description
Pool Name (string)	Name (case-insensitive) or id of the pool used for poolValue, poolFound, claimable and claims. Default empty: none selected.
Should Claim (boolean)	Claim the selected pool this round; wire Jackpot Tiers hasTier or a scatter test. Default false.
Claim Only If Claimable (boolean)	Only claim a scatter-triggered pool. Default true; off changes the node's outputs only, the server still refuses other pools.
Mock Pools (editor only) (array)	Editor only: pools for the preview as [{ id, name, pool_type, current_value, claimable }]. Default []; ignored once pools were fetched.
Game Slug (editor only) (string)	Editor only: slug of the published game whose pools Fetch Pools reads. Default empty, so a fetch fails.
RGS URL (editor only) (string)	Editor only: base URL of the RGS functions for Fetch Pools. Default: the production RGS functions URL.

Actions

Signal	Description
Fetch Pools (editor only)	Editor only: GETs the game's pools from the public __jackpots route, stores them and evaluates at once.
Do	Runs the node.

Outputs

Events

Signal	Description
Done	Fires when the node has finished, on success and failure alike.

Results

Data	Description
Pools (array)	Every pool the node sees, normalised to { id, name, pool_type, current_value, claimable }.
Pool Names (array)	The pool names, in pool order.
Pool Count (number)	How many pools the node sees; 0 on Simulate or when the game has none.
Pool Values (object)	{ name: current_value } in minor units; wire it to the jackpot ticker.
Pool Value (number)	Current value of the selected pool in minor units; 0 when none is selected or found.
Pool Found (boolean)	True when Pool Name matched a pool.
Claimable (boolean)	True when the selected pool is scatter-triggered, so the game's maths may claim it.
Claims (array)	[name] of the pool claimed this round, else []; wire it to a Component Outputs port named jackpotClaims.
Claimed (boolean)	True when claims is not empty (a boolean, not a signal).
Total Pool Value (number)	Sum of every pool's current_value, in minor units.

Usage

1. Add RGS Jackpot Pools to the maths component and set Pool Name to the pool your scatter feature pays.
2. Wire the hit test, for example Jackpot Tiers hasTier, into Should Claim and fire Do after the spin.
3. Wire claims to a Component Outputs port named jackpotClaims.
4. Wire poolValues to the jackpot ticker in the UI.
5. For the preview, set Game Slug and fire Fetch Pools, or fill Mock Pools.

caution

Only an identified player can win a pool: a guest session's claim is ignored on the server, and Simulate shows no pools at all. Test claims with a launched session on the published game.