@energy8platform/game-engine 0.34.0 → 0.34.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@energy8platform/game-engine",
-  "version": "0.34.0",
+  "version": "0.34.2",
   "description": "Universal casino game engine built on PixiJS v8 and @energy8platform/game-sdk",
   "type": "module",
   "main": "./dist/index.cjs.js",

package/src/host/createSlotGame.ts

@@ -186,11 +186,23 @@ export async function createSlotGame<T extends SlotSpinResultBase = SlotSpinResu
         jurisdiction?: import('./shellConfig').JurisdictionRestrictions;
         betLevels?: number[];
         defaultBet?: number;
-        stake?: { defaultBetLevel?: number };
+        stake?: { defaultBetLevel?: number; minBet?: number; maxBet?: number };
+        /** Set by the Stake bridge when `/wallet/authenticate` returned a still-open round. */
+        activeRound?: { bet?: number; roundId?: string; mode?: string };
       };
+      /** Present only on a resume — the bridge synthesises it from the open round. */
+      session?: { betAmount?: number };
       lang?: string;
     } | null;
     const config = initData?.config;
+    // A reload mid-round is just another entry: authenticate answers with BOTH the currency's
+    // default bet and the round still open from the previous page-load. That round was played at
+    // its own stake, so the default is the wrong bet to come back on — the bar would show it while
+    // the resume drain (and the ×bet win data the scene renders) ran against something else.
+    // `config.activeRound.bet` is the bridge stating it outright; `session.betAmount` is the older
+    // carrier for the same value (INIT only ever has a session on a resume). Both are ignored when
+    // absent or 0 so an ordinary launch still starts on the default.
+    const resumedBet = config?.activeRound?.bet || initData?.session?.betAmount || undefined;
     const { resolveCurrency } = await import('./shellConfig');
     // SINGLE source of truth for the symbol: the Stake bridge already puts a full CurrencyMetaData
     // (symbol + placement) on initData.config.currency. In the non-stake/devBridge path that meta
@@ -217,8 +229,21 @@ export async function createSlotGame<T extends SlotSpinResultBase = SlotSpinResu
       // Currency-specific ladder + per-currency default from /wallet/authenticate (Stake);
       // absent on dev/devBridge → buildShellConfig falls back to the spec.
       betLevels: config?.betLevels,
-      defaultBet: config?.stake?.defaultBetLevel ?? config?.defaultBet,
+      defaultBet: resumedBet ?? config?.stake?.defaultBetLevel ?? config?.defaultBet,
+      // Hard stake window; the bridge rejects anything outside it before /bet/play.
+      minBet: config?.stake?.minBet,
+      maxBet: config?.stake?.maxBet,
     };
+    // On a real Stake launch the ladder is CURRENCY-SPECIFIC and mandatory. Falling back to the
+    // spec's (EUR-shaped) ladder here would put the game on bets the wallet can't honour — every
+    // spin rejected on a high-denomination currency (ARS minBet 50), or silently mispriced. Fail
+    // where the cause is visible instead of at the first spin.
+    if (isStakeNow && !runtime.betLevels?.length) {
+      fatal('Could not load the bet levels for your currency. Please relaunch the game.');
+      throw new Error(
+        'createSlotGame: Stake launch returned no config.betLevels — refusing to fall back to the spec ladder',
+      );
+    }
     if (opts.dev) {
       // Dev-only diagnostic. Logged as PLAIN STRINGS (not collapsed objects) so the values are
       // readable in the console without expanding. If the shown symbol is a bare code ("EUR")
@@ -238,6 +263,12 @@ export async function createSlotGame<T extends SlotSpinResultBase = SlotSpinResu
       app: game.app,
       parent: game.uiLayer,
     };
+    // Adopt the bet the shell is about to display. `currentBet` was seeded from the SPEC above,
+    // which is only ever right by accident: the authoritative default is the per-currency one from
+    // /wallet/authenticate. The shell re-syncs us on `betChange`, but that fires ONLY when the
+    // player moves the bet — so without this the FIRST spin (and any bonus buy before it) plays at
+    // the spec's bet while the bar shows the RGS one.
+    currentBet = pixiShellCfg.currentBet ?? currentBet;
     // The game may swap in its own shell (a custom renderer over the same core) via shellFactory;
     // default is the built-in Pixi shell. The host drives whichever it gets through the Shell contract.
     shell = (opts.shellFactory ?? createPixiShell)(pixiShellCfg);

package/src/host/shellConfig.ts

@@ -73,6 +73,40 @@ export interface ShellRuntime {
   /** Per-currency default bet from `/wallet/authenticate` (the bridge surfaces it as
    *  `config.stake.defaultBetLevel`). Stake requires the selector to start here on every entry. */
   defaultBet?: number;
+  /** Hard per-currency stake bounds from `/wallet/authenticate` (`config.stake.minBet/maxBet`,
+   *  major units). The bridge REJECTS any bet outside them before `/bet/play`, so the resolved
+   *  default is clamped into this window — see `resolveDefaultBet`. */
+  minBet?: number;
+  maxBet?: number;
+}
+
+/**
+ * Resolve the bet the game must START on — the single source of truth for BOTH the shell's
+ * selector and the host's `currentBet` (they must never disagree; if they do, the player is
+ * charged a bet they never chose).
+ *
+ * The `preferred` bet is the RGS default when there is one, else the spec's. Neither is trusted
+ * blindly: the result is always an actual rung of `betLevels`, inside `[minBet, maxBet]`.
+ *
+ * Why snapping matters beyond the bounds check: the shell's `stepBet()` locates the current bet
+ * with `availableBets.indexOf(state.bet)`. An off-ladder default makes that return -1, so the very
+ * first +/- press jumps the bet to `availableBets[0]` instead of stepping.
+ */
+export function resolveDefaultBet(
+  betLevels: number[],
+  preferred: number | undefined,
+  bounds?: { minBet?: number; maxBet?: number },
+): number {
+  if (!betLevels.length) return preferred ?? 0; // no ladder to snap to — nothing better to offer
+  // Drop rungs the RGS would reject outright. If the bounds exclude the WHOLE ladder the data is
+  // self-contradictory; keep the ladder rather than hand back a bet that isn't even selectable.
+  const inBounds = betLevels.filter(
+    (l) => (bounds?.minBet == null || l >= bounds.minBet) && (bounds?.maxBet == null || l <= bounds.maxBet),
+  );
+  const pool = inBounds.length ? inBounds : betLevels;
+  if (preferred == null) return pool[0];
+  // Nearest rung; ties go to the cheaper one (`<` keeps the earlier, ascending-ladder entry).
+  return pool.reduce((best, l) => (Math.abs(l - preferred) < Math.abs(best - preferred) ? l : best), pool[0]);
 }
 
 /** The subset of Stake's jurisdiction flags the shell can enforce via `ShellFeatures`. */
@@ -389,8 +423,19 @@ export function buildShellConfig(
 ): Omit<PixiShellConfig, 'app' | 'parent' | 'gameInfo'> & { gameInfo: GameInfoContent } {
   // Prefer the currency-specific ladder from /wallet/authenticate; fall back to the spec (dev/devBridge).
   const betLevels = runtime.betLevels?.length ? runtime.betLevels : model.spec.betLevels;
-  // Stake requires the default to come from authenticate on every entry; spec default is the dev fallback.
-  const defaultBet = runtime.defaultBet ?? model.spec.defaultBet ?? betLevels[0];
+  // Stake requires the default to come from authenticate on every entry; spec default is the dev
+  // fallback. Snapped onto the ladder + clamped to the RGS bounds so the selector and the host's
+  // `currentBet` both start on a bet the server will actually accept.
+  // EXCEPT in replay: there the bridge reports the replayed round's OWN stake, a historical amount
+  // that need not be a rung of today's ladder. Snapping it would misreport what was actually bet.
+  const preferredBet = runtime.defaultBet ?? model.spec.defaultBet;
+  const defaultBet =
+    runtime.mode === 'replay'
+      ? (preferredBet ?? betLevels[0])
+      : resolveDefaultBet(betLevels, preferredBet, {
+          minBet: runtime.minBet,
+          maxBet: runtime.maxBet,
+        });
   // runtime.currency is the resolved CurrencyConfig (derived from initData.config.currency by the
   // host); opts.currency still wins. Fall back to the spec code, then a neutral euro.
   const currency =