@suigar/sdk 2.0.0-beta.14 → 2.0.0-beta.16

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @suigar/sdk
 
+## 2.0.0-beta.16
+
+### Patch Changes
+
+- 4463bbf: Update `@mysten/*` dependencies to latest patch versions
+
+## 2.0.0-beta.15
+
+### Patch Changes
+
+- 67a8b5b: Add `parseGameEvent` to `@suigar/sdk/utils` for extracting a normalized Suigar game id plus raw Move event name for supported Suigar events in `GAME_EVENTS`, including standard `BetResultEvent` and PvP coinflip events.
+
+  Change `parseGameDetails` to accept `gameId` first so TypeScript can narrow the returned detail keys and value types per game.
+
 ## 2.0.0-beta.14
 
 ### Patch Changes

package/README.md

@@ -10,7 +10,7 @@ npm install --save @suigar/sdk @mysten/sui @mysten/bcs
 
 Runtime requirements:
 
-- Node.js `>=22`
+- Node.js `^22.18.0 || >=24`
 - ESM project configuration (`"type": "module"`)
 - `@mysten/sui` v2
 - `@mysten/bcs` v2
@@ -71,7 +71,7 @@ Numeric helper behavior:
   JavaScript `number`
 - `parseCoinType(type)` extracts the normalized first generic coin type from a
   Move object type string and throws `TypeError` when no coin type can be parsed
-- `parseGameDetails(gameDetails)` decodes standard `BetResultEvent.game_details`
+- `parseGameDetails(gameId, gameDetails)` decodes standard `BetResultEvent.game_details`
   byte arrays into the expected string, number, and boolean values while
   preserving the original on-chain keys
 
@@ -267,6 +267,9 @@ By default, per-object fetch or parse failures are skipped so one broken or
 already-deleted registry entry does not reject the full lookup. Pass
 `throwOnError: true` if you want the call to reject instead.
 
+Each returned entry includes the parsed game fields plus a derived
+`coin_type` string from the underlying Move object type.
+
 Any supported `listDynamicFields()` options such as `limit`, `cursor`, or
 `signal` can be passed through `options`.
 
@@ -275,7 +278,7 @@ const games = await client.suigar.getPvPCoinflipGames({ limit: 20 });
 
 for (const game of games) {
 	console.log(game.id);
-	console.log(game.coinType);
+	console.log(game.coin_type);
 }
 ```
 
@@ -460,7 +463,7 @@ These are generated Move event decoders. Use them to parse Suigar event payloads
 - `fromMoveFloat(float)` converts a generated Move `Float` struct to a JavaScript number
 - `parseCoinType(type)` extracts the normalized coin type from generic Move object type strings such as PvP coinflip `Game<T>`
   and throws `TypeError` when the type string does not include a first generic coin type
-- `parseGameDetails(game_details)` decodes `BetResultEvent.game_details` entries into the expected string, number, and boolean values
+- `parseGameDetails(gameId, game_details)` decodes `BetResultEvent.game_details` entries into the expected string, number, and boolean values
 
 ### Parse PvP Coinflip Game Object Data
 
@@ -525,17 +528,28 @@ Parsed fields include:
 - `game_details`
 - `metadata`
 
-`game_details` and `metadata` decode as `VecMap<string, vector<u8>>`-shaped data, so values come back as byte arrays. Use `parseGameDetails` from `@suigar/sdk/utils` to decode `game_details` with the SDK's known game-detail schemas.
+`game_details` and `metadata` decode as `VecMap<string, vector<u8>>`-shaped data, so values come back as byte arrays. Use `parseGameEvent(event)` from `@suigar/sdk/utils` to retrieve the normalized `gameId` and `eventName`, then pass that `gameId` to `parseGameDetails(gameId, decoded.game_details)` for game-specific key and value typing.
 
 ```ts
-import { parseGameDetails } from '@suigar/sdk/utils';
+import { parseGameDetails, parseGameEvent } from '@suigar/sdk/utils';
 
+const { gameId, eventName } = parseGameEvent(event)!;
 const decoded = client.suigar.bcs.BetResultEvent.parse(event.bcs);
-const gameDetails = parseGameDetails(decoded.game_details);
+const gameDetails = parseGameDetails(gameId, decoded.game_details);
 ```
 
 `parseGameDetails` preserves the on-chain keys and only changes the value representation. For example, coinflip details keep keys such as `player_bet` and `coin_outcome`; range details keep keys such as `roll_value`, `win`, and `payout_multiplier`.
 
+`parseGameDetails(gameId, decoded.game_details)` narrows based on the parsed event game id. For example, when `gameId === 'coinflip'` it narrows to:
+
+- `{ player_bet: string; coin_outcome: string }`
+
+`parseGameEvent(event)` returns the normalized game id and raw Move event name for every supported Suigar event in `GAME_EVENTS`:
+
+- `{ gameId: 'coinflip' | 'limbo' | 'plinko' | 'range' | 'wheel', eventName: 'BetResultEvent' }` for standard bet result events
+- `{ gameId: 'pvp-coinflip', eventName: 'GameCreatedEvent' | 'GameResolvedEvent' | 'GameCancelledEvent' }` for PvP coinflip events
+- `null` for unsupported event names or non-Suigar event payloads
+
 When the extension is configured with `partner`, decoded event `metadata` will
 contain that partner wallet address under the `partner` entry.
 
@@ -545,7 +559,7 @@ contain that partner wallet address under the `partner` entry.
 > - unwrap the core API union with `result.$kind`, `result.Transaction`, and `result.FailedTransaction`
 > - parse emitted events from the unwrapped transaction result
 > - use `event.bcs` for consistent decoding across transports
-> - use `parseGameDetails(decoded.game_details)` instead of hand-decoding standard game detail byte arrays
+> - use `const { gameId } = parseGameEvent(event)!` and then `parseGameDetails(gameId, decoded.game_details)` instead of hand-decoding standard game detail byte arrays
 
 > **Tip:**
 >

package/dist/client.d.mts

@@ -0,0 +1,258 @@
+import { Game, StandardGame } from "./types/game.type.mjs";
+import { SuigarConfig, SuigarExtensionOptions } from "./types/suigar-config.type.mjs";
+import { BuildPvPCoinflipTransactionOptions, PvPCoinflipAction, WithThrowOnError } from "./types/transaction-options.type.mjs";
+import { MoveStruct } from "./contracts/utils/index.mjs";
+import { Game as Game$1 } from "./contracts/pvp-coinflip/pvp_coinflip.mjs";
+import { BuildGameOptions } from "./types/build-game-transaction-options.type.mjs";
+import { GameParameters, GetGameParametersOptions } from "./types/game-settings.type.mjs";
+import { BuildTransactionOptions, Transaction } from "@mysten/sui/transactions";
+import { ClientWithCoreApi, SuiClientTypes } from "@mysten/sui/client";
+import * as _$_mysten_bcs0 from "@mysten/bcs";
+import { InferBcsType } from "@mysten/bcs";
+
+//#region src/client.d.ts
+declare function suigar<const Name = 'suigar'>({
+  name,
+  partner,
+  cacheTtl
+}?: SuigarExtensionOptions<Name>): {
+  name: Name;
+  register: (client: ClientWithCoreApi) => SuigarClient;
+};
+declare class SuigarClient {
+  #private;
+  constructor({
+    client,
+    name,
+    partner,
+    cacheTtl
+  }: {
+    client: ClientWithCoreApi;
+    name: string;
+    partner?: string;
+    cacheTtl?: number;
+  });
+  /**
+   * Returns the resolved SDK configuration for the connected network.
+   *
+   * This is primarily useful for debugging or inspecting which package ids,
+   * registry ids, supported coin types, and price info object ids the SDK
+   * resolved for the current client network.
+   *
+   * @returns Network-resolved Suigar configuration.
+   */
+  getConfig(): SuigarConfig;
+  /**
+   * Builds a transaction with the configured Sui client and encodes the resulting BCS bytes as base64.
+   *
+   * Use this when an external wallet, API, or transport expects the built transaction payload as a base64 string
+   * instead of raw bytes. The SDK always injects the configured Sui client, so `options` accepts the standard
+   * transaction build options except for `client`.
+   *
+   * @param transaction Transaction to build and serialize.
+   * @param options Optional transaction build options forwarded to `transaction.build()`, excluding `client`.
+   * @returns Base64-encoded transaction bytes ready to send over the wire.
+   */
+  serializeTransactionToBase64(transaction: Transaction, options?: Omit<BuildTransactionOptions, 'client'>): Promise<string>;
+  /**
+   * Reads on-chain game parameters for the requested game.
+   *
+   * The SDK first reads the selected game's settings object from SweetHouse,
+   * then reads that game's coin-specific `Parameters<T>` object. Results are
+   * cached according to the extension `cacheTtl` option. Pass
+   * `ignoreCache: true` to refresh the on-chain read and replace the cached
+   * value.
+   *
+   * @param game Game whose parameters should be loaded.
+   * @param options Optional coin type, cache override, and abort signal.
+   * @returns Parsed game parameters typed for the requested game.
+   */
+  getGameParameters<TGame extends Game>(game: TGame, options?: GetGameParametersOptions): Promise<GameParameters<TGame>>;
+  /**
+   * Lists unresolved PvP coinflip games from the configured registry and resolves
+   * each entry into parsed on-chain game state.
+   *
+   * This fetches dynamic fields from the PvP coinflip registry object, then bulk
+   * loads the referenced game objects through `client.core.getObjects()`. Registry
+   * membership is the unresolved-state signal: when a game is joined and resolved,
+   * the Move flow removes it from the registry and deletes the live `Game` object.
+   * Use this when a product needs the current set of open PvP coinflip matches for
+   * browsing or lobby views.
+   *
+   * @param options Optional dynamic field pagination forwarded to `listDynamicFields()`, excluding `parentId`.
+   * Supported options such as `limit`, `cursor`, and `signal` are forwarded to the
+   * underlying lookup calls. Pass `throwOnError: true` to fail the whole lookup
+   * when any referenced game object cannot be fetched or parsed. By default,
+   * failed per-object lookups are skipped and only successfully parsed unresolved
+   * games are returned.
+   * @returns Parsed unresolved PvP coinflip game objects for the requested
+   * registry page. When `throwOnError` is `false`, entries that fail object fetch
+   * or parse are omitted from the returned array.
+   */
+  getPvPCoinflipGames(options?: WithThrowOnError<Omit<SuiClientTypes.ListDynamicFieldsOptions, 'parentId'>>): Promise<(InferBcsType<typeof Game$1> & {
+    coin_type: string;
+  })[]>;
+  /**
+   * BCS struct constructors for decoding on-chain objects and events related to Suigar games.
+   *
+   * These can be used to parse the `content` field of on-chain objects and events into structured data with the
+   * expected types. For example, use `client.suigar.bcs.PvPCoinflipGame.parse(object.content)` to decode a PvP
+   * coinflip game object.
+   *
+   * Note that these constructors are not meant for encoding transaction arguments, as the SDK's transaction
+   * builders handle argument serialization internally. Use these primarily for decoding and parsing on-chain data.
+   */
+  bcs: {
+    /**
+     * Object representing the state of a PvP coinflip game, as stored on-chain.
+     */
+    PvPCoinflipGame: MoveStruct<{
+      id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      is_private: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      creator_metadata: MoveStruct<{
+        contents: _$_mysten_bcs0.BcsType<{
+          key: string;
+          value: number[];
+        }[], Iterable<{
+          key: string;
+          value: Iterable<number> & {
+            length: number;
+          };
+        }> & {
+          length: number;
+        }, string>;
+      }, "0x2::vec_map::VecMap<string, vector<u8>>">;
+      joiner: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      winner: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      stake_per_player: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      house_edge_bps: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      stake_pot: MoveStruct<{
+        value: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0x2::balance::Balance<phantom T0>">;
+    }, "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip::Game<phantom T0>">;
+    /**
+     * Event emitted at the end of a standard game (e.g., Coinflip, Limbo), containing the result and payout information.
+     */
+    BetResultEvent: MoveStruct<{
+      player: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      coin_type: MoveStruct<{
+        name: _$_mysten_bcs0.BcsType<string, string, "string">;
+      }, "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName">;
+      stake_amount: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      unsafe_oracle_usd_coin_price: MoveStruct<{
+        is_negative: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+          bits: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+      adjusted_oracle_usd_coin_price: MoveStruct<{
+        is_negative: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+          bits: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+      outcome_amount: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      game_details: MoveStruct<{
+        contents: _$_mysten_bcs0.BcsType<{
+          key: string;
+          value: number[];
+        }[], Iterable<{
+          key: string;
+          value: Iterable<number> & {
+            length: number;
+          };
+        }> & {
+          length: number;
+        }, string>;
+      }, "0x2::vec_map::VecMap<string, vector<u8>>">;
+      metadata: MoveStruct<{
+        contents: _$_mysten_bcs0.BcsType<{
+          key: string;
+          value: number[];
+        }[], Iterable<{
+          key: string;
+          value: Iterable<number> & {
+            length: number;
+          };
+        }> & {
+          length: number;
+        }, string>;
+      }, "0x2::vec_map::VecMap<string, vector<u8>>">;
+    }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::core::BetResultEvent<phantom T0>">;
+    /**
+     * Event emitted when a PvP Coinflip game is created, containing the game configuration and initial state.
+     */
+    PvPCoinflipGameCreatedEvent: MoveStruct<{
+      game_id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      is_private: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      joiner_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      stake_per_player: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      house_edge_bps: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      coin_type: MoveStruct<{
+        name: _$_mysten_bcs0.BcsType<string, string, "string">;
+      }, "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName">;
+    }, "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip::GameCreatedEvent<phantom T0>">;
+    /**
+     * Event emitted when a PvP Coinflip game is resolved, containing the final outcome.
+     */
+    PvPCoinflipGameResolvedEvent: MoveStruct<{
+      game_id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      joiner: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      winner: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      is_private: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      joiner_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      stake_per_player: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      total_pot: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      house_edge_amount: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      payout_amount: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      coin_type: MoveStruct<{
+        name: _$_mysten_bcs0.BcsType<string, string, "string">;
+      }, "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName">;
+    }, "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip::GameResolvedEvent<phantom T0>">;
+    /**
+     * Event emitted when a PvP Coinflip game is cancelled.
+     */
+    PvPCoinflipGameCancelledEvent: MoveStruct<{
+      game_id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      is_private: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      stake_per_player: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      coin_type: MoveStruct<{
+        name: _$_mysten_bcs0.BcsType<string, string, "string">;
+      }, "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName">;
+    }, "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip::GameCancelledEvent<phantom T0>">;
+  };
+  /**
+   * Transaction builders for Suigar games.
+   */
+  tx: {
+    /**
+     * Creates a standard game transaction for the provided game id.
+     *
+     * @param gameId Supported standard game identifier.
+     * @param options Transaction builder options for the selected game.
+     * @returns Prepared transaction for the selected game.
+     */
+    createBetTransaction: <GameId extends StandardGame>(gameId: GameId, options: BuildGameOptions<GameId>) => Transaction;
+    /**
+     * Creates a PvP coinflip transaction for the requested action.
+     *
+     * @param action PvP coinflip action to perform.
+     * @param options Transaction builder options for the selected action.
+     * @returns Prepared PvP coinflip transaction.
+     */
+    createPvPCoinflipTransaction: <Action extends PvPCoinflipAction>(action: Action, options: BuildPvPCoinflipTransactionOptions<Action>) => Transaction;
+  };
+}
+//#endregion
+export { SuigarClient, suigar };
+//# sourceMappingURL=client.d.mts.map

package/dist/client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.mts","names":[],"sources":["../src/client.ts"],"mappings":";;;;;;;;;;;;;iBA+DgB,MAAA,uBAAA,CAAA;EACf,IAAA;EACA,OAAA;EACA;AAAA,IACE,sBAAA,CAAuB,IAAA;;qBAGL,iBAAA,KAAoB,YAAA;AAAA;AAAA,cAW5B,YAAA;EAAA;;IAUX,MAAA;IACA,IAAA;IACA,OAAA;IACA;EAAA;IAEA,MAAA,EAAQ,iBAAA;IACR,IAAA;IACA,OAAA;IACA,QAAA;EAAA;EAlCD;;;;;;;;;EA+DA,SAAA,CAAA,GAAa,YAAA;EAhEb;;;;;;;;;;;EA+EM,4BAAA,CACL,WAAA,EAAa,WAAA,EACb,OAAA,GAAU,IAAA,CAAK,uBAAA,cACb,OAAA;;;;;AAjEJ;;;;;;;;;EAmFO,iBAAA,eAAgC,IAAA,CAAA,CACrC,IAAA,EAAM,KAAA,EACN,OAAA,GAAS,wBAAA,GACP,OAAA,CAAQ,cAAA,CAAe,KAAA;EAtBV;;;;;;;;;;;;;;;;;;;;;EAsDV,mBAAA,CACL,OAAA,GAAS,gBAAA,CACR,IAAA,CAAK,cAAA,CAAe,wBAAA,iBAInB,OAAA,EAAS,YAAA,QAAoB,MAAA;IAAqB,SAAA;EAAA;;;;;;;;;;;EA4DrD,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCW;;;;;;;;;;;;;;;IAlNV;;;;;;;;;;;;;;;;;;;IAuEuB;;;;;;;;;;;;;;EAoCvB;;;EA6FD,EAAA;IAxFqD;;;;;;;0CAgGd,YAAA,EAAY,MAAA,EACzC,MAAA,EAAM,OAAA,EACL,gBAAA,CAAiB,MAAA,MACxB,WAAA;;;;;;;;kDA2C2C,iBAAA,EAAiB,MAAA,EACtD,MAAA,EAAM,OAAA,EACL,kCAAA,CAAmC,MAAA,MAC1C,WAAA;EAAA;AAAA"}

package/dist/client.mjs

@@ -0,0 +1,291 @@
+import { TypeName } from "./contracts/core/deps/0x0000000000000000000000000000000000000000000000000000000000000001/type_name.mjs";
+import { BetResultEvent } from "./contracts/core/core.mjs";
+import { Game, GameCancelledEvent, GameCreatedEvent, GameResolvedEvent } from "./contracts/pvp-coinflip/pvp_coinflip.mjs";
+import { resolveGamePackageId, resolveSuigarConfig } from "./helpers/config.mjs";
+import { resolveCoinTypeNameForTypeNameKey, resolveGameSettingsKeyType } from "./helpers/game-settings.mjs";
+import { SUPPORTED_SUI_NETWORKS } from "./types/network.type.mjs";
+import { parseCoinType } from "./utils/parser.mjs";
+import { buildCoinflipTransaction } from "./transactions/coinflip.mjs";
+import { buildLimboTransaction } from "./transactions/limbo.mjs";
+import { buildPlinkoTransaction } from "./transactions/plinko.mjs";
+import { buildPvPCoinflipTransaction } from "./transactions/pvp-coinflip.mjs";
+import { buildRangeTransaction } from "./transactions/range.mjs";
+import { buildWheelTransaction } from "./transactions/wheel.mjs";
+import { TtlClientCache } from "./ttl-cache.mjs";
+import { GAME_SETTINGS } from "./types/game-settings.type.mjs";
+import { normalizeStructTag, toBase64 } from "@mysten/sui/utils";
+//#region src/client.ts
+function suigar({ name = "suigar", partner, cacheTtl } = {}) {
+	return {
+		name,
+		register: (client) => {
+			return new SuigarClient({
+				client,
+				name: String(name),
+				partner,
+				cacheTtl
+			});
+		}
+	};
+}
+var SuigarClient = class {
+	#client;
+	#config;
+	#partner;
+	#cache;
+	constructor({ client, name, partner, cacheTtl }) {
+		this.#client = client;
+		this.#partner = partner;
+		this.#cache = client.cache.scope("@suigar/sdk").readSync([name, "ttl-cache"], () => {
+			return new TtlClientCache({ ttlMs: cacheTtl ?? 18e5 });
+		});
+		const network = this.#client.network;
+		if (!SUPPORTED_SUI_NETWORKS.includes(network)) throw new RangeError(`Unsupported network: ${network}`);
+		this.#config = resolveSuigarConfig(network);
+	}
+	/**
+	* Returns the resolved SDK configuration for the connected network.
+	*
+	* This is primarily useful for debugging or inspecting which package ids,
+	* registry ids, supported coin types, and price info object ids the SDK
+	* resolved for the current client network.
+	*
+	* @returns Network-resolved Suigar configuration.
+	*/
+	getConfig() {
+		return this.#config;
+	}
+	/**
+	* Builds a transaction with the configured Sui client and encodes the resulting BCS bytes as base64.
+	*
+	* Use this when an external wallet, API, or transport expects the built transaction payload as a base64 string
+	* instead of raw bytes. The SDK always injects the configured Sui client, so `options` accepts the standard
+	* transaction build options except for `client`.
+	*
+	* @param transaction Transaction to build and serialize.
+	* @param options Optional transaction build options forwarded to `transaction.build()`, excluding `client`.
+	* @returns Base64-encoded transaction bytes ready to send over the wire.
+	*/
+	async serializeTransactionToBase64(transaction, options) {
+		return toBase64(await transaction.build({
+			...options,
+			client: this.#client
+		}));
+	}
+	/**
+	* Reads on-chain game parameters for the requested game.
+	*
+	* The SDK first reads the selected game's settings object from SweetHouse,
+	* then reads that game's coin-specific `Parameters<T>` object. Results are
+	* cached according to the extension `cacheTtl` option. Pass
+	* `ignoreCache: true` to refresh the on-chain read and replace the cached
+	* value.
+	*
+	* @param game Game whose parameters should be loaded.
+	* @param options Optional coin type, cache override, and abort signal.
+	* @returns Parsed game parameters typed for the requested game.
+	*/
+	async getGameParameters(game, options = {}) {
+		const coinType = normalizeStructTag(options.coinType ?? this.#config.coinTypes.sui);
+		return this.#cache.read([
+			"parameters",
+			this.#client.network,
+			game,
+			coinType
+		], () => this.#fetchGameParameters(game, coinType, options.signal), { ignoreCache: options.ignoreCache });
+	}
+	/**
+	* Lists unresolved PvP coinflip games from the configured registry and resolves
+	* each entry into parsed on-chain game state.
+	*
+	* This fetches dynamic fields from the PvP coinflip registry object, then bulk
+	* loads the referenced game objects through `client.core.getObjects()`. Registry
+	* membership is the unresolved-state signal: when a game is joined and resolved,
+	* the Move flow removes it from the registry and deletes the live `Game` object.
+	* Use this when a product needs the current set of open PvP coinflip matches for
+	* browsing or lobby views.
+	*
+	* @param options Optional dynamic field pagination forwarded to `listDynamicFields()`, excluding `parentId`.
+	* Supported options such as `limit`, `cursor`, and `signal` are forwarded to the
+	* underlying lookup calls. Pass `throwOnError: true` to fail the whole lookup
+	* when any referenced game object cannot be fetched or parsed. By default,
+	* failed per-object lookups are skipped and only successfully parsed unresolved
+	* games are returned.
+	* @returns Parsed unresolved PvP coinflip game objects for the requested
+	* registry page. When `throwOnError` is `false`, entries that fail object fetch
+	* or parse are omitted from the returned array.
+	*/
+	async getPvPCoinflipGames(options = { limit: 50 }) {
+		const { throwOnError = false, ...listOptions } = options;
+		const { dynamicFields } = await this.#client.core.listDynamicFields({
+			...listOptions,
+			parentId: this.#config.registryIds.pvpCoinflip
+		});
+		const { objects } = await this.#client.core.getObjects({
+			objectIds: dynamicFields.map(({ childId }) => childId),
+			signal: listOptions.signal,
+			include: { content: true }
+		});
+		const resolvedGames = objects.map((object) => {
+			try {
+				if (object instanceof Error) throw object;
+				if (!object.content) throw new Error("Unable to resolve PvP coinflip game from retrieved object");
+				return {
+					...Game.parse(object.content),
+					coin_type: parseCoinType(object.type)
+				};
+			} catch (error) {
+				return error instanceof Error ? error : new Error(String(error));
+			}
+		});
+		if (throwOnError) {
+			const firstError = resolvedGames.find((game) => game instanceof Error);
+			if (firstError) throw firstError;
+		}
+		return resolvedGames.flatMap((game) => game instanceof Error ? [] : [game]);
+	}
+	/**
+	* BCS struct constructors for decoding on-chain objects and events related to Suigar games.
+	*
+	* These can be used to parse the `content` field of on-chain objects and events into structured data with the
+	* expected types. For example, use `client.suigar.bcs.PvPCoinflipGame.parse(object.content)` to decode a PvP
+	* coinflip game object.
+	*
+	* Note that these constructors are not meant for encoding transaction arguments, as the SDK's transaction
+	* builders handle argument serialization internally. Use these primarily for decoding and parsing on-chain data.
+	*/
+	bcs = {
+		/**
+		* Object representing the state of a PvP coinflip game, as stored on-chain.
+		*/
+		PvPCoinflipGame: Game,
+		/**
+		* Event emitted at the end of a standard game (e.g., Coinflip, Limbo), containing the result and payout information.
+		*/
+		BetResultEvent,
+		/**
+		* Event emitted when a PvP Coinflip game is created, containing the game configuration and initial state.
+		*/
+		PvPCoinflipGameCreatedEvent: GameCreatedEvent,
+		/**
+		* Event emitted when a PvP Coinflip game is resolved, containing the final outcome.
+		*/
+		PvPCoinflipGameResolvedEvent: GameResolvedEvent,
+		/**
+		* Event emitted when a PvP Coinflip game is cancelled.
+		*/
+		PvPCoinflipGameCancelledEvent: GameCancelledEvent
+	};
+	/**
+	* Transaction builders for Suigar games.
+	*/
+	tx = {
+		/**
+		* Creates a standard game transaction for the provided game id.
+		*
+		* @param gameId Supported standard game identifier.
+		* @param options Transaction builder options for the selected game.
+		* @returns Prepared transaction for the selected game.
+		*/
+		createBetTransaction: (gameId, options) => {
+			switch (gameId) {
+				case "coinflip": return buildCoinflipTransaction({
+					...options,
+					config: this.#config,
+					partner: this.#partner
+				});
+				case "limbo": return buildLimboTransaction({
+					...options,
+					config: this.#config,
+					partner: this.#partner
+				});
+				case "plinko": return buildPlinkoTransaction({
+					...options,
+					config: this.#config,
+					partner: this.#partner
+				});
+				case "range": return buildRangeTransaction({
+					...options,
+					config: this.#config,
+					partner: this.#partner
+				});
+				case "wheel": return buildWheelTransaction({
+					...options,
+					config: this.#config,
+					partner: this.#partner
+				});
+				default: throw new RangeError(`Unsupported game: ${gameId}`);
+			}
+		},
+		/**
+		* Creates a PvP coinflip transaction for the requested action.
+		*
+		* @param action PvP coinflip action to perform.
+		* @param options Transaction builder options for the selected action.
+		* @returns Prepared PvP coinflip transaction.
+		*/
+		createPvPCoinflipTransaction: (action, options) => {
+			switch (action) {
+				case "create": return buildPvPCoinflipTransaction("create", {
+					...options,
+					config: this.#config,
+					partner: this.#partner
+				});
+				case "join": {
+					const joinOptions = options;
+					return buildPvPCoinflipTransaction("join", {
+						...joinOptions,
+						betCoin: this.#createPvPCoinflipBetCoin(joinOptions),
+						config: this.#config,
+						partner: this.#partner
+					});
+				}
+				case "cancel": return buildPvPCoinflipTransaction("cancel", {
+					...options,
+					config: this.#config,
+					partner: this.#partner
+				});
+				default: throw new RangeError(`Unsupported PvP coinflip action: ${action}`);
+			}
+		}
+	};
+	#createPvPCoinflipBetCoin(options) {
+		return async (tx) => {
+			const { json } = await Game.get({
+				client: this.#client,
+				objectId: options.gameId
+			});
+			return tx.coin({
+				type: options.coinType,
+				balance: BigInt(json.stake_per_player),
+				useGasCoin: options.allowGasCoinShortcut
+			});
+		};
+	}
+	async #fetchGameParameters(game, coinType, signal) {
+		const gameDefinition = GAME_SETTINGS[game];
+		const { object: settingsObject } = await this.#client.core.getDynamicObjectField({
+			parentId: this.#config.packageIds.sweetHouse,
+			name: {
+				type: resolveGameSettingsKeyType(gameDefinition.settingsKey.name, resolveGamePackageId(this.#config, game)),
+				bcs: gameDefinition.settingsKey.serialize({ dummy_field: false }).toBytes()
+			},
+			signal
+		});
+		const { object } = await this.#client.core.getDynamicObjectField({
+			parentId: settingsObject.objectId,
+			name: {
+				type: TypeName.name,
+				bcs: TypeName.serialize({ name: resolveCoinTypeNameForTypeNameKey(coinType) }).toBytes()
+			},
+			include: { content: true },
+			signal
+		});
+		if (!object?.content) throw new Error(`Missing parameters object content for ${game} and coin type ${coinType}`);
+		return gameDefinition.parameters.parse(object.content);
+	}
+};
+//#endregion
+export { SuigarClient, suigar };
+
+//# sourceMappingURL=client.mjs.map