@hizi.io/engine-sdk 0.1.9

package/lib/api.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+exports.loadConfig = loadConfig;
+exports.placeBet = placeBet;
+exports.collect = collect;
+exports.pfVerify = pfVerify;
+exports.refresh = refresh;
+exports.reportAnimationEnd = reportAnimationEnd;
+exports.updateBalance = updateBalance;
+exports.getFreePlaysRemaining = getFreePlaysRemaining;
+exports.getFreePlayStake = getFreePlayStake;
+const constants_js_1 = require("./constants.js");
+const network_js_1 = require("./network.js");
+/** Parse an error response from login/refresh endpoints. */
+function parseErrorResponse(data, statusText) {
+    return {
+        success: false,
+        error: {
+            code: String(data?.errorId ?? data?.code ?? constants_js_1.API_RETURNCODES.UNEXPECTED),
+            message: (data?.errorText ?? data?.message ?? statusText),
+            ...(data?.passThroughData !== undefined && data?.passThroughData !== 'undefined' ? { passThroughData: data.passThroughData } : {}),
+        },
+    };
+}
+/** Parse a connect reply (used by both login and refresh). */
+function parseConnectReply(data) {
+    return {
+        token: data.token,
+        backendURL: (data.backendUrl ?? data.backendURL),
+        refreshURL: (data.refreshUrl ?? data.refreshURL),
+        logoutURL: (data.logoutUrl ?? data.logoutURL),
+        webSocketURL: (data.webSocketUrl ?? data.webSocketURL),
+        balance: data.balance,
+        gameSettings: data.gameSettings,
+        tokenData: data.tokenData,
+        freePlaysAvailable: data.freePlaysAvailable,
+    };
+}
+/**
+ * Exchange a launch token for a session token.
+ *
+ * The `loginURL` and `launchToken` are provided as URL query parameters
+ * when the game is launched by the operator.
+ *
+ * @param options - Login credentials from the launch URL.
+ * @param options.loginURL - The operator-provided login endpoint URL.
+ * @param options.launchToken - Short-lived token from the launch URL query string.
+ * @returns A session token, backend URL, and platform settings on success.
+ *
+ * @example
+ * ```ts
+ * const response = await login({ loginURL, launchToken });
+ * if (response.success) {
+ *   const { token, backendURL } = response.result;
+ * }
+ * ```
+ */
+async function login(options) {
+    try {
+        const url = new URL(options.loginURL);
+        url.searchParams.set('token', options.launchToken);
+        const response = await fetch(url.href, {
+            method: 'GET',
+            headers: { Accept: 'application/json' },
+            signal: AbortSignal.timeout(constants_js_1.defaultNetworkTimeout),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            return parseErrorResponse(data, response.statusText);
+        }
+        return { success: true, result: parseConnectReply(data) };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: {
+                code: String(constants_js_1.API_RETURNCODES.NETWORKERROR),
+                message: error instanceof Error ? error.message : 'Network error',
+            },
+        };
+    }
+}
+/**
+ * Load the game configuration including available stakes, RTP, and buy features.
+ *
+ * Call this once after {@link login} to retrieve the game's configuration before
+ * placing any bets. If a previous round was interrupted, the response includes
+ * `gameResult` and `amountToCollect` for resumption.
+ *
+ * @param options - Session credentials from the login response.
+ * @param options.backendURL - Backend URL from the login response.
+ * @param options.token - Session token.
+ * @returns Game configuration, balance, and any in-progress round data.
+ *
+ * @example
+ * ```ts
+ * const response = await loadConfig({ backendURL, token });
+ * if (response.success) {
+ *   const { stakes, rtp, buyFeatures } = response.result.config;
+ * }
+ * ```
+ */
+async function loadConfig(options) {
+    return (0, network_js_1.request)(options.backendURL, {
+        op: 'loadConfig',
+        token: options.token,
+    });
+}
+/**
+ * Place a bet and receive a game result, or continue an in-progress round.
+ *
+ * - **New spin** — pass the desired `stake` amount.
+ * - **Continue round** — omit `stake` when `engineData.inProgress` is `true`.
+ * - **Buy feature** — pass `featureToBuy` to enter a bonus directly (engine computes the price).
+ * - **Player choice** — pass `playerChoiceIndex` when `engineData.playerChoice` is set.
+ *
+ * @param options - Bet parameters.
+ * @param options.backendURL - Backend URL from the login response.
+ * @param options.token - Session token.
+ * @param options.stake - Stake amount in minor currency units. Required for the first call of a game round.
+ * @param options.featureToBuy - Buy-feature ID (e.g. `'freespin'`).
+ * @param options.playerChoiceIndex - Index of the selected option when `engineData.playerChoice` is set.
+ * @param options.useTicket - Set `true` to consume a free play ticket.
+ * @param options.useTicketFeatureType - Feature type of the free play ticket.
+ * @param options.additionalData - Additional game-specific parameters.
+ * @returns The game result including scenario data, engine state, and cumulative win.
+ *
+ * @example
+ * ```ts
+ * // New spin
+ * const response = await placeBet({ backendURL, token, stake });
+ *
+ * // Buy feature
+ * const response = await placeBet({ backendURL, token, stake, featureToBuy: 'freespin' });
+ *
+ * // Continue round
+ * const response = await placeBet({ backendURL, token });
+ * ```
+ */
+async function placeBet(options) {
+    const { backendURL, token, stake, useTicket, useTicketFeatureType, featureToBuy, playerChoiceIndex, additionalData } = options;
+    const body = {
+        ...additionalData,
+        op: 'placeBet',
+        token,
+    };
+    if (stake !== undefined)
+        body.stake = stake;
+    if (useTicket !== undefined)
+        body.useTicket = useTicket;
+    if (useTicketFeatureType !== undefined)
+        body.useTicketFeatureType = useTicketFeatureType;
+    if (featureToBuy !== undefined)
+        body.featureToBuy = featureToBuy;
+    if (playerChoiceIndex !== undefined)
+        body.playerChoiceIndex = playerChoiceIndex;
+    return (0, network_js_1.request)(backendURL, body);
+}
+/**
+ * Collect winnings after a completed round.
+ *
+ * Only available for games with wager features (`config.wagerFeatures` is present).
+ * Games without wager features auto-end the round and credit winnings automatically.
+ *
+ * @param options - Session credentials and optional partial amount.
+ * @param options.backendURL - Backend URL from the login response.
+ * @param options.token - Session token.
+ * @param options.amount - Amount to collect. Omit to collect the full available amount.
+ * @returns The credited amount and updated balance.
+ * @throws When called on a game without wager features, or when no winnings are available.
+ *
+ * @example
+ * ```ts
+ * if (gameResult.engineData.canCollect) {
+ *   const response = await collect({ backendURL, token });
+ * }
+ * ```
+ */
+async function collect(options) {
+    const body = {
+        ...options.additionalData,
+        op: 'collect',
+        token: options.token,
+    };
+    if (options.amount !== undefined)
+        body.collectAmount = options.amount;
+    return (0, network_js_1.request)(options.backendURL, body);
+}
+/**
+ * Re-run a past round against its revealed PF seeds and get back the
+ * engine's offline replay — the per-call RNG audit (`rngData`) and the
+ * per-step game outcomes (`steps`) — so the caller can diff them against
+ * what they recorded live.
+ *
+ * Only meaningful for rounds played with `config.rng === 'pf'`. The
+ * endpoint never touches the wallet, progression counters, or operator
+ * caps; it's pure compute.
+ *
+ * Two checks make up a passing verification:
+ *
+ * 1. **Audit replay** — `reply.rngData` matches the live `pf.rngData`
+ *    element-wise. A swapped server seed would yield different draws, so
+ *    this transitively proves the revealed seed is the one committed to.
+ * 2. **Result replay** — `reply.steps[i].scenario` / `totalWin` match the
+ *    live round at each step. The terminal step is `steps[steps.length - 1]`.
+ *
+ * @param options - Verify parameters; see {@link IPfVerifyOptions}.
+ * @param options.backendURL - Backend URL from the login response.
+ * @param options.token - Session token (used to resolve the game config).
+ * @param options.serverSeed - Revealed server seed from the round's `pf` block.
+ * @param options.clientSeed - Client seed bound to the round.
+ * @param options.startNonce - Defaults to `0`. Set when the round opened mid-PF-session.
+ * @param options.stake - Stake the round opened with (required by games that need it to settle).
+ * @param options.featureToBuy - Buy-feature id the round opened on, if any.
+ * @param options.initialData - Mirror the round's opening payload (blackjack side bets, …).
+ * @param options.bets - Roulette / crash opening bets.
+ * @param options.playerNumbers - Keno picks, if the player chose their own.
+ * @param options.actions - Continuation actions in order; shape per game (see {@link IPfVerifyAction}).
+ *
+ * @example
+ * ```ts
+ * // Verify a one-shot roulette round.
+ * const reply = await pfVerify({
+ *   backendURL, token,
+ *   serverSeed: pf.revealedServerSeed,
+ *   clientSeed: pf.clientSeed,
+ *   stake: 200,
+ *   bets: [{ type: 'straight', selection: 17, stake: 100 }, { type: 'red', stake: 100 }],
+ * });
+ * if (reply.success) {
+ *   const rngOk = deepEqual(reply.result.rngData, pf.rngData);
+ *   const pocketOk = (reply.result.steps[0].scenario as { pocket: number }).pocket === liveScenario.pocket;
+ * }
+ * ```
+ */
+async function pfVerify(options) {
+    const { backendURL, token, serverSeed, clientSeed, startNonce, stake, featureToBuy, initialData, bets, playerNumbers, actions } = options;
+    const body = { op: 'pfVerify', token, serverSeed, clientSeed };
+    // Engine defaults startNonce to 0 when omitted; only spend bytes when non-zero.
+    if (startNonce !== undefined && startNonce > 0)
+        body.startNonce = startNonce;
+    if (stake !== undefined)
+        body.stake = stake;
+    if (featureToBuy !== undefined)
+        body.featureToBuy = featureToBuy;
+    if (initialData !== undefined)
+        body.initialData = initialData;
+    if (bets !== undefined)
+        body.bets = bets;
+    if (playerNumbers !== undefined)
+        body.playerNumbers = playerNumbers;
+    if (actions !== undefined)
+        body.actions = actions;
+    return (0, network_js_1.request)(backendURL, body);
+}
+/**
+ * Refresh the session token when it expires.
+ *
+ * Call this when API requests start returning `SESSIONINVALID` or `NOTLOGGEDON`
+ * errors. The new session token and URLs are returned in the response.
+ *
+ * @param refreshURL - The refresh endpoint URL from the {@link login} response (`result.refreshURL`).
+ * @returns A new session token and updated platform info.
+ *
+ * @example
+ * ```ts
+ * const response = await refresh(refreshURL);
+ * if (response.success) {
+ *   token = response.result.token;
+ * }
+ * ```
+ */
+async function refresh(refreshURL) {
+    try {
+        const response = await fetch(refreshURL, {
+            method: 'GET',
+            headers: { 'Content-Type': 'application/json' },
+            signal: AbortSignal.timeout(constants_js_1.defaultNetworkTimeout),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            return parseErrorResponse(data, response.statusText);
+        }
+        return { success: true, result: parseConnectReply(data) };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: {
+                code: String(constants_js_1.API_RETURNCODES.NETWORKERROR),
+                message: error instanceof Error ? error.message : 'Network error',
+            },
+        };
+    }
+}
+/**
+ * Report that the game animation has finished playing.
+ *
+ * Only needed when `gameSettings.reportAnimationEnd` is `true` (set by the operator).
+ * Call this after your spin/win animation completes.
+ *
+ * @param options - Session credentials.
+ * @param options.backendURL - Backend URL from the login response.
+ * @param options.token - Session token.
+ */
+async function reportAnimationEnd(options) {
+    return (0, network_js_1.request)(options.backendURL, {
+        op: 'reportAnimationEnd',
+        token: options.token,
+    });
+}
+/**
+ * Request an updated balance from the server.
+ *
+ * Use this to refresh the displayed balance outside of the normal
+ * `placeBet`/`collect` flow (e.g. after an external deposit).
+ *
+ * @param options - Session credentials.
+ * @param options.backendURL - Backend URL from the login response.
+ * @param options.token - Session token.
+ * @returns The player's current balance.
+ */
+async function updateBalance(options) {
+    return (0, network_js_1.request)(options.backendURL, {
+        op: 'updateBalance',
+        token: options.token,
+    });
+}
+// ---- Helper Functions ----
+/**
+ * Get the total number of free plays remaining.
+ *
+ * @param freePlaysAvailable - The `freePlaysAvailable` array from a `loadConfig` or `placeBet` response.
+ * @returns Total free play count across all entries, or `0` if none available.
+ */
+function getFreePlaysRemaining(freePlaysAvailable) {
+    if (!freePlaysAvailable)
+        return 0;
+    return freePlaysAvailable.reduce((total, fp) => total + fp.count, 0);
+}
+/**
+ * Get the stake amount for available free plays.
+ *
+ * @param freePlaysAvailable - The `freePlaysAvailable` array from a `loadConfig` or `placeBet` response.
+ * @returns The first free play's stake amount, or `undefined` if none available.
+ */
+function getFreePlayStake(freePlaysAvailable) {
+    if (!freePlaysAvailable || freePlaysAvailable.length === 0)
+        return undefined;
+    return freePlaysAvailable[0].stake;
+}

package/lib/constants.d.ts

@@ -0,0 +1,44 @@
+/** Error codes returned by the Hizi RGS platform. */
+export declare enum API_RETURNCODES {
+    SUCCESS = 0,
+    PLAYERNOTFOUND = 1,
+    PLAYERBLOCKED = 2,
+    BALANCETOOLOW = 10,
+    BETLIMITREACHED = 11,
+    GAMEROUNDALREADYSTARTED = 12,
+    GAMEROUNDNOTACTIVE = 13,
+    GAMEROUNDNOTFOUND = 14,
+    GAMEROUNDNOTSTARTED = 15,
+    TRANSACTIONCOUNTWRONG = 16,
+    GAMEROUNDPLAYERMISMATCH = 17,
+    CURRENCYINVALID = 18,
+    INVALIDPARAMETER = 19,
+    TRANSACTIONAFTEREND = 20,
+    GAMEROUNDISLOCKED = 21,
+    GAMEROUNDISCLOSING = 22,
+    SPINNOTAVAILABLE = 23,
+    COOLOFFPERIODACTIVE = 25,
+    NOTLOGGEDON = 29,
+    RESPONSIBLEGAMINGLIMITREACHED = 30,
+    RESPONSIBLESGAMINGSESSIONEXPIRED = 31,
+    PLAYERNOAUTHENTICATED = 32,
+    GENERICBETERROR = 34,
+    GENERICWINERROR = 35,
+    OPERATIONBEINGPROCESSED = 36,
+    REALITYCHECK = 38,
+    SIGNATUREWRONG = 1001,
+    PARAMETERMISSING = 1004,
+    GAMECODENOTFOUND = 1006,
+    SESSIONINVALID = 1008,
+    RNGFAILURE = 1009,
+    NETWORKERROR = 1010,
+    RATELIMITEXCEEDED = 1300,
+    UNEXPECTED = -1
+}
+/**
+ * Error codes that can be retried (e.g. balance too low, rate limit, network error).
+ * Use this to decide whether to show a retry option or a fatal error screen.
+ */
+export declare const recoverableErrorCodes: string[];
+/** Default timeout for HTTP and WebSocket requests, in milliseconds. */
+export declare const defaultNetworkTimeout = 30000;

package/lib/constants.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultNetworkTimeout = exports.recoverableErrorCodes = exports.API_RETURNCODES = void 0;
+/** Error codes returned by the Hizi RGS platform. */
+var API_RETURNCODES;
+(function (API_RETURNCODES) {
+    API_RETURNCODES[API_RETURNCODES["SUCCESS"] = 0] = "SUCCESS";
+    API_RETURNCODES[API_RETURNCODES["PLAYERNOTFOUND"] = 1] = "PLAYERNOTFOUND";
+    API_RETURNCODES[API_RETURNCODES["PLAYERBLOCKED"] = 2] = "PLAYERBLOCKED";
+    API_RETURNCODES[API_RETURNCODES["BALANCETOOLOW"] = 10] = "BALANCETOOLOW";
+    API_RETURNCODES[API_RETURNCODES["BETLIMITREACHED"] = 11] = "BETLIMITREACHED";
+    API_RETURNCODES[API_RETURNCODES["GAMEROUNDALREADYSTARTED"] = 12] = "GAMEROUNDALREADYSTARTED";
+    API_RETURNCODES[API_RETURNCODES["GAMEROUNDNOTACTIVE"] = 13] = "GAMEROUNDNOTACTIVE";
+    API_RETURNCODES[API_RETURNCODES["GAMEROUNDNOTFOUND"] = 14] = "GAMEROUNDNOTFOUND";
+    API_RETURNCODES[API_RETURNCODES["GAMEROUNDNOTSTARTED"] = 15] = "GAMEROUNDNOTSTARTED";
+    API_RETURNCODES[API_RETURNCODES["TRANSACTIONCOUNTWRONG"] = 16] = "TRANSACTIONCOUNTWRONG";
+    API_RETURNCODES[API_RETURNCODES["GAMEROUNDPLAYERMISMATCH"] = 17] = "GAMEROUNDPLAYERMISMATCH";
+    API_RETURNCODES[API_RETURNCODES["CURRENCYINVALID"] = 18] = "CURRENCYINVALID";
+    API_RETURNCODES[API_RETURNCODES["INVALIDPARAMETER"] = 19] = "INVALIDPARAMETER";
+    API_RETURNCODES[API_RETURNCODES["TRANSACTIONAFTEREND"] = 20] = "TRANSACTIONAFTEREND";
+    API_RETURNCODES[API_RETURNCODES["GAMEROUNDISLOCKED"] = 21] = "GAMEROUNDISLOCKED";
+    API_RETURNCODES[API_RETURNCODES["GAMEROUNDISCLOSING"] = 22] = "GAMEROUNDISCLOSING";
+    API_RETURNCODES[API_RETURNCODES["SPINNOTAVAILABLE"] = 23] = "SPINNOTAVAILABLE";
+    API_RETURNCODES[API_RETURNCODES["COOLOFFPERIODACTIVE"] = 25] = "COOLOFFPERIODACTIVE";
+    API_RETURNCODES[API_RETURNCODES["NOTLOGGEDON"] = 29] = "NOTLOGGEDON";
+    API_RETURNCODES[API_RETURNCODES["RESPONSIBLEGAMINGLIMITREACHED"] = 30] = "RESPONSIBLEGAMINGLIMITREACHED";
+    API_RETURNCODES[API_RETURNCODES["RESPONSIBLESGAMINGSESSIONEXPIRED"] = 31] = "RESPONSIBLESGAMINGSESSIONEXPIRED";
+    API_RETURNCODES[API_RETURNCODES["PLAYERNOAUTHENTICATED"] = 32] = "PLAYERNOAUTHENTICATED";
+    API_RETURNCODES[API_RETURNCODES["GENERICBETERROR"] = 34] = "GENERICBETERROR";
+    API_RETURNCODES[API_RETURNCODES["GENERICWINERROR"] = 35] = "GENERICWINERROR";
+    API_RETURNCODES[API_RETURNCODES["OPERATIONBEINGPROCESSED"] = 36] = "OPERATIONBEINGPROCESSED";
+    API_RETURNCODES[API_RETURNCODES["REALITYCHECK"] = 38] = "REALITYCHECK";
+    API_RETURNCODES[API_RETURNCODES["SIGNATUREWRONG"] = 1001] = "SIGNATUREWRONG";
+    API_RETURNCODES[API_RETURNCODES["PARAMETERMISSING"] = 1004] = "PARAMETERMISSING";
+    API_RETURNCODES[API_RETURNCODES["GAMECODENOTFOUND"] = 1006] = "GAMECODENOTFOUND";
+    API_RETURNCODES[API_RETURNCODES["SESSIONINVALID"] = 1008] = "SESSIONINVALID";
+    API_RETURNCODES[API_RETURNCODES["RNGFAILURE"] = 1009] = "RNGFAILURE";
+    API_RETURNCODES[API_RETURNCODES["NETWORKERROR"] = 1010] = "NETWORKERROR";
+    API_RETURNCODES[API_RETURNCODES["RATELIMITEXCEEDED"] = 1300] = "RATELIMITEXCEEDED";
+    API_RETURNCODES[API_RETURNCODES["UNEXPECTED"] = -1] = "UNEXPECTED";
+})(API_RETURNCODES || (exports.API_RETURNCODES = API_RETURNCODES = {}));
+/**
+ * Error codes that can be retried (e.g. balance too low, rate limit, network error).
+ * Use this to decide whether to show a retry option or a fatal error screen.
+ */
+exports.recoverableErrorCodes = [
+    API_RETURNCODES.BALANCETOOLOW,
+    API_RETURNCODES.BETLIMITREACHED,
+    API_RETURNCODES.NETWORKERROR,
+    API_RETURNCODES.RATELIMITEXCEEDED,
+    API_RETURNCODES.GENERICBETERROR,
+    API_RETURNCODES.RNGFAILURE,
+    API_RETURNCODES.OPERATIONBEINGPROCESSED,
+].map(String);
+/** Default timeout for HTTP and WebSocket requests, in milliseconds. */
+exports.defaultNetworkTimeout = 30000;

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { login, loadConfig, placeBet, collect, pfVerify, refresh, reportAnimationEnd, updateBalance, getFreePlaysRemaining, getFreePlayStake } from './api.js';
+export { enableWebSockets } from './websocket.js';
+export type { WebSocketHandler } from './websocket.js';
+export type { TNetworkResponse, TNetworkSuccess, TNetworkError, IErrorResponse, IBalanceEntry, IBalanceReply, IGameSettings, ITokenData, IGameState, IGameRoundInfo, IFreePlayInfo, IScenarioInfo, ISpinInfo, TPlayerChoiceFeatureAward, TPlayerChoiceCashAward, TPlayerChoiceAward, IGameResult, IBuyFeatureOption, ILoadConfigConfig, IProgressionCounterConfig, IProgressionEvent, TRandomChoiceAward, TRandomChoiceFeatureAward, TRandomChoiceCashAward, TProgressionAwarded, IConnectReply, ILoadConfigReply, IPlaceBetReply, ICollectReply, ISessionOptions, ILoginOptions, IPlaceBetOptions, ICollectOptions, IPfVerifyOptions, IPfVerifyAction, IPfVerifyReply, IRngDataEntry, TRouletteBetType, TRouletteBetSelection, TRouletteEvenMoneyBetType, IRouletteBet, IRouletteBetSettlement, IRouletteScenario, TBlackjackRank, TBlackjackSuit, IBlackjackCard, TBlackjackAction, TBlackjackActionKind, IBlackjackSideBets, IBlackjackInitialBet, IBlackjackChoice, IBlackjackHand, IBlackjackDealer, IBlackjackPerfectPairsBet, IBlackjackTwentyOnePlusThreeBet, IBlackjackInsuranceBet, IBlackjackScenario, ICrashBetRequest, ICrashBet, ICrashScenario, ICrashLoadConfig, TCrashEventName, ICrashRoundStartedPayload, ICrashRoundTickPayload, ICrashBetCashedOutPayload, ICrashRoundEndedPayload, ICrashBalanceUpdatedPayload, TCrashEvent, TMinesTile, IMinesScenario, IKenoScenario, } from './types/index.js';
+export { rouletteAdditionalData, blackjackInitialData, blackjackActionData, CRASH_EVENTS, crashPlaceBetData, crashCollectData, minesPickData, kenoPickData, } from './types/index.js';
+export { isCashChoice, isFeatureChoice } from './types/index.js';
+export { API_RETURNCODES, recoverableErrorCodes, defaultNetworkTimeout } from './constants.js';

package/lib/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultNetworkTimeout = exports.recoverableErrorCodes = exports.API_RETURNCODES = exports.isFeatureChoice = exports.isCashChoice = exports.kenoPickData = exports.minesPickData = exports.crashCollectData = exports.crashPlaceBetData = exports.CRASH_EVENTS = exports.blackjackActionData = exports.blackjackInitialData = exports.rouletteAdditionalData = exports.enableWebSockets = exports.getFreePlayStake = exports.getFreePlaysRemaining = exports.updateBalance = exports.reportAnimationEnd = exports.refresh = exports.pfVerify = exports.collect = exports.placeBet = exports.loadConfig = exports.login = void 0;
+// API functions
+var api_js_1 = require("./api.js");
+Object.defineProperty(exports, "login", { enumerable: true, get: function () { return api_js_1.login; } });
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return api_js_1.loadConfig; } });
+Object.defineProperty(exports, "placeBet", { enumerable: true, get: function () { return api_js_1.placeBet; } });
+Object.defineProperty(exports, "collect", { enumerable: true, get: function () { return api_js_1.collect; } });
+Object.defineProperty(exports, "pfVerify", { enumerable: true, get: function () { return api_js_1.pfVerify; } });
+Object.defineProperty(exports, "refresh", { enumerable: true, get: function () { return api_js_1.refresh; } });
+Object.defineProperty(exports, "reportAnimationEnd", { enumerable: true, get: function () { return api_js_1.reportAnimationEnd; } });
+Object.defineProperty(exports, "updateBalance", { enumerable: true, get: function () { return api_js_1.updateBalance; } });
+Object.defineProperty(exports, "getFreePlaysRemaining", { enumerable: true, get: function () { return api_js_1.getFreePlaysRemaining; } });
+Object.defineProperty(exports, "getFreePlayStake", { enumerable: true, get: function () { return api_js_1.getFreePlayStake; } });
+// WebSocket
+var websocket_js_1 = require("./websocket.js");
+Object.defineProperty(exports, "enableWebSockets", { enumerable: true, get: function () { return websocket_js_1.enableWebSockets; } });
+// Game-specific helpers
+var index_js_1 = require("./types/index.js");
+Object.defineProperty(exports, "rouletteAdditionalData", { enumerable: true, get: function () { return index_js_1.rouletteAdditionalData; } });
+Object.defineProperty(exports, "blackjackInitialData", { enumerable: true, get: function () { return index_js_1.blackjackInitialData; } });
+Object.defineProperty(exports, "blackjackActionData", { enumerable: true, get: function () { return index_js_1.blackjackActionData; } });
+Object.defineProperty(exports, "CRASH_EVENTS", { enumerable: true, get: function () { return index_js_1.CRASH_EVENTS; } });
+Object.defineProperty(exports, "crashPlaceBetData", { enumerable: true, get: function () { return index_js_1.crashPlaceBetData; } });
+Object.defineProperty(exports, "crashCollectData", { enumerable: true, get: function () { return index_js_1.crashCollectData; } });
+Object.defineProperty(exports, "minesPickData", { enumerable: true, get: function () { return index_js_1.minesPickData; } });
+Object.defineProperty(exports, "kenoPickData", { enumerable: true, get: function () { return index_js_1.kenoPickData; } });
+// Type guards
+var index_js_2 = require("./types/index.js");
+Object.defineProperty(exports, "isCashChoice", { enumerable: true, get: function () { return index_js_2.isCashChoice; } });
+Object.defineProperty(exports, "isFeatureChoice", { enumerable: true, get: function () { return index_js_2.isFeatureChoice; } });
+// Constants
+var constants_js_1 = require("./constants.js");
+Object.defineProperty(exports, "API_RETURNCODES", { enumerable: true, get: function () { return constants_js_1.API_RETURNCODES; } });
+Object.defineProperty(exports, "recoverableErrorCodes", { enumerable: true, get: function () { return constants_js_1.recoverableErrorCodes; } });
+Object.defineProperty(exports, "defaultNetworkTimeout", { enumerable: true, get: function () { return constants_js_1.defaultNetworkTimeout; } });

package/lib/network.d.ts

@@ -0,0 +1,9 @@
+import type { TNetworkResponse } from './types/index.js';
+declare let wsTransport: {
+    send: <T>(body: Record<string, unknown>) => Promise<TNetworkResponse<T>>;
+    isConnected: () => boolean;
+} | null;
+export declare function setWsTransport(transport: typeof wsTransport): void;
+export declare function getWsTransport(): typeof wsTransport;
+export declare function request<T>(url: string, body: Record<string, unknown>): Promise<TNetworkResponse<T>>;
+export {};

package/lib/network.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setWsTransport = setWsTransport;
+exports.getWsTransport = getWsTransport;
+exports.request = request;
+const constants_js_1 = require("./constants.js");
+let wsTransport = null;
+function setWsTransport(transport) {
+    wsTransport = transport;
+}
+function getWsTransport() {
+    return wsTransport;
+}
+async function request(url, body) {
+    if (wsTransport?.isConnected()) {
+        return wsTransport.send(body);
+    }
+    return httpRequest(url, body);
+}
+function decodeBase64Utf8(value) {
+    try {
+        const binary = atob(value);
+        const bytes = Uint8Array.from(binary, c => c.charCodeAt(0));
+        return new TextDecoder('utf-8').decode(bytes);
+    }
+    catch {
+        return value;
+    }
+}
+async function httpRequest(url, body) {
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(constants_js_1.defaultNetworkTimeout),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            const errorMsgBase64 = response.headers.get('x-h-error-msg-base64');
+            const headerMsg = errorMsgBase64 ? decodeBase64Utf8(errorMsgBase64) : response.headers.get('x-h-error-msg');
+            const headerId = response.headers.get('x-h-error-id');
+            const error = {
+                code: String(headerId ?? data?.errorId ?? data?.code ?? constants_js_1.API_RETURNCODES.UNEXPECTED),
+                message: headerMsg ?? data?.errorText ?? data?.message ?? response.statusText,
+            };
+            if (data?.passThroughData !== undefined && data?.passThroughData !== 'undefined') {
+                error.passThroughData = data.passThroughData;
+            }
+            return { success: false, error };
+        }
+        return { success: true, result: data };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: {
+                code: String(constants_js_1.API_RETURNCODES.NETWORKERROR),
+                message: error instanceof Error ? error.message : 'Network error',
+            },
+        };
+    }
+}

package/lib/types/balance.d.ts

@@ -0,0 +1,20 @@
+/** A single balance bucket (e.g. real money, bonus, free-play credit). */
+export interface IBalanceEntry {
+    /** Balance type identifier (e.g. "real", "bonus"). */
+    type: string;
+    /** ISO 4217 currency code. */
+    currency: string;
+    /** Balance amount in minor currency units. */
+    amount: number;
+}
+/** Player balance breakdown, returned in most API responses. */
+export interface IBalanceReply {
+    /** Sum of all balance buckets. */
+    totalBalance: number;
+    /** Balance mode identifier (operator-specific). */
+    mode: string;
+    /** ISO 4217 currency code. */
+    currency: string;
+    /** Individual balance buckets. */
+    balances: IBalanceEntry[];
+}

package/lib/types/balance.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });