@octane-rgs/sdk

Type-safe SDK for integrating games with Octane RGS.

Install

npm install @octane-rgs/sdk

Quick Start

import { OctaneRgsClient } from "@octane-rgs/sdk";

const rgs = new OctaneRgsClient({
  baseUrl: "https://your-rgs.example.com",
  apiKey: "your-api-key",
});

// Launch a player session
const { sessionToken, tableSessionId } = await rgs.launch({
  externalPlayerId: "player-123",
  tableSessionId: "550e8400-e29b-41d4-a716-446655440000",
  tableGameCode: "baccarat",
  currency: "USD",
});

// Create a round
const { roundId } = await rgs.createRound({
  tableSessionId,
  bettingOpenAt: new Date().toISOString(),
  bettingClosedAt: new Date(Date.now() + 30_000).toISOString(),
});

// Place a bet
const { remainingBalance } = await rgs.placeBet({
  sessionToken,
  roundId,
  bets: [{ betOption: "player", amount: 1000 }],
  requestId: crypto.randomUUID(),
});

// Settle the round
const result = await rgs.settle({
  roundId,
  gameType: "baccarat",
  multipliers: [
    { betOption: "player", multiplier: 2 },
    { betOption: "banker", multiplier: 0 },
  ],
});

API Reference

Sessions

| Method | Description | |--------|-------------| | launch(params) | Create a player session and authorize with the operator | | getBalance(sessionToken) | Get player's current balance | | getPlayerSession(sessionToken) | Get session details | | markStarted(sessionToken) | Mark a session as started |

Table Sessions

| Method | Description | |--------|-------------| | upsertTable(params) | Create or update a table session | | endTable(tableSessionId, endedAt) | End a table session | | getTableSession(tableSessionId) | Get table session details | | lobbies(publicOnly?) | List active table sessions | | updateRoomStates(params) | Batch update room states | | cleanup(params) | Clean up stale sessions |

Rounds

| Method | Description | |--------|-------------| | createRound(params) | Create a new betting round | | listRounds(tableSessionId, order?) | List rounds for a table | | findRound(params) | Find a specific round | | updateRoundOutcome(roundId, data) | Store game outcome data | | roundHistory(tableSessionId, limit?) | Get round history with outcomes |

Betting

| Method | Description | |--------|-------------| | placeBet(params) | Place a bet on a round | | doubleBet(params) | Double existing bets | | undoBet(params) | Undo the last bet action | | settle(params) | Settle a round with multipliers | | voidRound(roundId) | Void a round and refund bets |

Queries

| Method | Description | |--------|-------------| | roundWinners(roundId) | Get winners for a round | | lastPayout(sessionToken) | Get player's last payout amount | | betStatistics(roundId, sides) | Get bet distribution stats | | playerHistory(sessionToken) | Get player's bet/payout history |

RNG (Provably Fair)

| Method | Description | |--------|-------------| | getRng(params) | Generate provably fair random numbers | | revealSeed(params) | Reveal server seed for verification |

Operator Adapter

When registering your operator with Octane RGS, implement the OperatorAdapterConfig interface:

import type { OperatorAdapterConfig } from "@octane-rgs/sdk";

const myAdapter: OperatorAdapterConfig = {
  async authorizePlayer(authPayload) { /* verify player with your system */ },
  async placeBet(request) { /* debit player wallet */ },
  async cancelBet(request) { /* refund player wallet */ },
  async cancelUndo(request) { /* re-debit after failed undo reversal */ },
  async getBalance(request) { /* query player balance */ },
  async settleRound(settlement) { /* credit player winnings */ },
  async voidRound(roundId, voidBets) { /* refund voided bets */ },
};

Error Handling

All methods throw RgsError on failure:

import { RgsError } from "@octane-rgs/sdk";

try {
  await rgs.placeBet({ ... });
} catch (err) {
  if (err instanceof RgsError) {
    console.log(err.message); // "Betting for this round is closed"
    console.log(err.status);  // 400
  }
}