@suigar/sdk 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/utils.cjs

@@ -0,0 +1,241 @@
+'use strict';
+
+var utils = require('@mysten/sui/utils');
+var bcs = require('@mysten/sui/bcs');
+require('@mysten/sui/transactions');
+
+// src/utils/constants.ts
+var DEFAULT_GAS_BUDGET_MIST = utils.parseToMist("0.05");
+var DEFAULT_RANGE_SCALE = 1e6;
+var RANGE_POINT_LIMIT = DEFAULT_RANGE_SCALE * 100;
+var DEFAULT_LIMBO_MULTIPLIER_SCALE = 100;
+
+// src/utils/numeric.ts
+function assertFiniteNumber(value, errorMessage) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(`${errorMessage}: ${String(value)}`);
+  }
+}
+function toBigInt(value) {
+  let result;
+  try {
+    if (typeof value === "bigint" || typeof value === "string" || typeof value === "boolean") {
+      result = BigInt(value);
+    } else {
+      assertFiniteNumber(
+        value,
+        "Value must be a bigint, number, integer string, or boolean"
+      );
+      result = BigInt(Math.trunc(value));
+    }
+  } catch {
+    throw new TypeError(
+      `Value must be a bigint, number, integer string, or boolean: ${value}`
+    );
+  }
+  if (result < 0n) {
+    throw new RangeError(`Value must be non-negative: ${value}`);
+  }
+  return result;
+}
+function toBoundedInt(value, max, typeName) {
+  const num = typeof value === "string" && value.trim() === "" ? NaN : Number(value);
+  assertFiniteNumber(num, "Value must be a finite number or integer string");
+  if (typeof value === "boolean" || value == null || !Number.isInteger(num) || num < 0 || num > max) {
+    throw new Error(`Value must be a ${typeName} integer (0-${max}): ${value}`);
+  }
+  return num;
+}
+function toU8(value) {
+  return toBoundedInt(value, 255, "u8");
+}
+function toU16(value) {
+  return toBoundedInt(value, 65535, "u16");
+}
+utils.normalizeSuiAddress("0x1");
+utils.normalizeSuiAddress("0x2");
+var MoveStruct = class extends bcs.BcsStruct {
+  async get({
+    objectId,
+    ...options
+  }) {
+    const [res] = await this.getMany({
+      ...options,
+      objectIds: [objectId]
+    });
+    if (!res) {
+      throw new Error(`No object found for id ${objectId}`);
+    }
+    return res;
+  }
+  async getMany({
+    client,
+    ...options
+  }) {
+    const response = await client.core.getObjects({
+      ...options,
+      include: {
+        ...options.include,
+        content: true
+      }
+    });
+    return response.objects.map((obj) => {
+      if (obj instanceof Error) {
+        throw obj;
+      }
+      return {
+        ...obj,
+        json: this.parse(obj.content)
+      };
+    });
+  }
+};
+var $moduleName = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
+var I64 = new MoveStruct({
+  name: `${$moduleName}::I64`,
+  fields: {
+    bits: bcs.bcs.u64()
+  }
+});
+
+// src/contracts/core/float.ts
+var $moduleName2 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
+var Float = new MoveStruct({
+  name: `${$moduleName2}::Float`,
+  fields: {
+    is_negative: bcs.bcs.bool(),
+    exp: I64,
+    mant: bcs.bcs.u64()
+  }
+});
+
+// src/types/game-details.type.ts
+var COINFLIP_GAME_DETAILS_SCHEMA = {
+  player_bet: "string",
+  coin_outcome: "string"
+};
+var PVP_COINFLIP_GAME_DETAILS_SCHEMA = {
+  pvp_result: "string"
+};
+var LIMBO_GAME_DETAILS_SCHEMA = {
+  payout_amount: "u64",
+  win: "bool",
+  roll_multiplier: "float",
+  payout_multiplier: "float",
+  target_multiplier: "float",
+  actual_rtp: "float"
+};
+var RANGE_GAME_DETAILS_SCHEMA = {
+  roll_value: "u64",
+  win: "bool",
+  payout_amount: "u64",
+  payout_multiplier: "float",
+  left_point: "u64",
+  right_point: "u64",
+  zone_size: "u64",
+  winning_zone_size: "u64",
+  is_out_range: "bool",
+  bet_threshold: "u64",
+  roll_under: "bool",
+  range_mode: "u8",
+  win_probability: "float",
+  win_multiplier: "float",
+  actual_rtp: "float"
+};
+var PLINKO_GAME_DETAILS_SCHEMA = {
+  slot_index: "u8",
+  multiplier: "float",
+  payout_amount: "u64",
+  plinko_config: "u8"
+};
+var WHEEL_GAME_DETAILS_SCHEMA = {
+  case_index: "u8",
+  multiplier: "float",
+  payout_amount: "u64",
+  wheel_config: "u8",
+  spin_value: "u64"
+};
+var GAME_DETAILS_SCHEMA = {
+  ...COINFLIP_GAME_DETAILS_SCHEMA,
+  ...PVP_COINFLIP_GAME_DETAILS_SCHEMA,
+  ...LIMBO_GAME_DETAILS_SCHEMA,
+  ...RANGE_GAME_DETAILS_SCHEMA,
+  ...PLINKO_GAME_DETAILS_SCHEMA,
+  ...WHEEL_GAME_DETAILS_SCHEMA
+};
+
+// src/utils/parser.ts
+var textDecoder = new TextDecoder();
+var GAME_DETAIL_BCS = {
+  u8: bcs.bcs.U8,
+  u64: bcs.bcs.U64,
+  bool: bcs.bcs.Bool,
+  float: Float,
+  string: bcs.bcs.String
+};
+function fromMoveI64(i64) {
+  try {
+    return Number(BigInt.asIntN(64, BigInt(i64.bits ?? 0)));
+  } catch {
+    return 0;
+  }
+}
+function fromMoveFloat(float) {
+  const mantissa = BigInt(float.mant ?? 0);
+  if (mantissa === 0n) {
+    return 0;
+  }
+  const exponent = fromMoveI64(float.exp) - 52;
+  const magnitude = Number(mantissa) * 2 ** exponent;
+  return float.is_negative ? -magnitude : magnitude;
+}
+function parseCoinType(type) {
+  const coinType = utils.parseStructTag(type).typeParams[0];
+  if (!coinType) {
+    throw new Error(`Unable to parse coin type from ${type}`);
+  }
+  return utils.normalizeStructTag(coinType);
+}
+function normalizeGameDetailValue(valueType, parsed) {
+  if (valueType === "float") {
+    return fromMoveFloat(parsed);
+  }
+  if (valueType === "u64") {
+    return Number(parsed);
+  }
+  return parsed;
+}
+function parseStringGameDetail(value) {
+  const bytes = Uint8Array.from(value);
+  try {
+    return bcs.bcs.String.parse(bytes);
+  } catch {
+    return textDecoder.decode(bytes);
+  }
+}
+function parseGameDetail(valueType, value) {
+  if (valueType === "string") {
+    return parseStringGameDetail(value);
+  }
+  const parsed = GAME_DETAIL_BCS[valueType].parse(Uint8Array.from(value));
+  return normalizeGameDetailValue(valueType, parsed);
+}
+function parseGameDetails(gameDetails) {
+  return gameDetails.contents.reduce((details, entry) => {
+    const valueType = GAME_DETAILS_SCHEMA[entry.key] ?? "string";
+    details[entry.key] = parseGameDetail(valueType, entry.value);
+    return details;
+  }, {});
+}
+
+exports.DEFAULT_GAS_BUDGET_MIST = DEFAULT_GAS_BUDGET_MIST;
+exports.DEFAULT_LIMBO_MULTIPLIER_SCALE = DEFAULT_LIMBO_MULTIPLIER_SCALE;
+exports.DEFAULT_RANGE_SCALE = DEFAULT_RANGE_SCALE;
+exports.RANGE_POINT_LIMIT = RANGE_POINT_LIMIT;
+exports.fromMoveFloat = fromMoveFloat;
+exports.fromMoveI64 = fromMoveI64;
+exports.parseCoinType = parseCoinType;
+exports.parseGameDetails = parseGameDetails;
+exports.toBigInt = toBigInt;
+exports.toU16 = toU16;
+exports.toU8 = toU8;

package/dist/utils.d.cts

@@ -0,0 +1,180 @@
+import * as _mysten_bcs from '@mysten/bcs';
+import { M as MoveStruct } from './index-3P_LBbDM.cjs';
+import '@mysten/sui/bcs';
+import '@mysten/sui/client';
+
+declare const BetResultEvent: MoveStruct<{
+    player: _mysten_bcs.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    coin_type: MoveStruct<{
+        name: _mysten_bcs.BcsType<string, string, "string">;
+    }, "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName">;
+    stake_amount: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+    unsafe_oracle_usd_coin_price: MoveStruct<{
+        is_negative: _mysten_bcs.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+            bits: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+    }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+    adjusted_oracle_usd_coin_price: MoveStruct<{
+        is_negative: _mysten_bcs.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+            bits: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+    }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+    outcome_amount: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+    game_details: MoveStruct<{
+        contents: _mysten_bcs.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_bcs.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>">;
+
+type BetResultGameDetails = ReturnType<(typeof BetResultEvent)['parse']>['game_details'];
+type ParsedGameDetailValue = string | number | boolean;
+type ParsedGameDetails = Record<string, ParsedGameDetailValue>;
+
+declare const DEFAULT_GAS_BUDGET_MIST: bigint;
+declare const DEFAULT_RANGE_SCALE = 1000000;
+declare const RANGE_POINT_LIMIT: number;
+declare const DEFAULT_LIMBO_MULTIPLIER_SCALE = 100;
+
+/**
+ * Normalizes a value into a non-negative `bigint`.
+ *
+ * Accepted inputs:
+ * - `bigint`
+ * - finite `number`
+ * - base-10 integer `string`
+ * - `boolean`
+ *
+ * Number inputs are truncated toward zero before conversion, so `5.9` becomes
+ * `5n`. String and boolean inputs are parsed through the native
+ * `BigInt(...)` constructor, so `true` becomes `1n`, `false` becomes `0n`,
+ * and only integer strings are accepted.
+ *
+ * @param value Value to normalize.
+ * @returns A non-negative `bigint`.
+ * @throws When `value` is not a bigint, finite number, integer string, or
+ * boolean.
+ * @throws When the normalized value is negative.
+ */
+declare function toBigInt(value: unknown): bigint;
+/**
+ * Validates that a value can be safely used as a Move `u8` in the `0..255`
+ * range.
+ *
+ * Accepted inputs:
+ * - finite `number`
+ * - base-10 integer `string`
+ *
+ * String inputs are accepted for parsed values such as `'1'`, but only when
+ * they are plain non-negative integer strings. This helper does not accept
+ * booleans and does not truncate fractional values.
+ *
+ * @param value Value to validate.
+ * @returns The validated `u8` value as a JavaScript `number`.
+ * @throws When `value` is not a finite number or integer string.
+ * @throws When `value` is not an integer between `0` and `255`.
+ */
+declare function toU8(value: unknown): number;
+/**
+ * Validates that a value can be safely used as a Move `u16` in the
+ * `0..65535` range.
+ *
+ * Accepted inputs:
+ * - finite `number`
+ * - base-10 integer `string`
+ *
+ * String inputs are accepted for parsed values such as `'1'`, but only when
+ * they are plain non-negative integer strings. This helper does not accept
+ * booleans and does not truncate fractional values.
+ *
+ * @param value Value to validate.
+ * @returns The validated `u16` value as a JavaScript `number`.
+ * @throws When `value` is not a finite number or integer string.
+ * @throws When `value` is not an integer between `0` and `65535`.
+ */
+declare function toU16(value: unknown): number;
+
+declare const Float: MoveStruct<{
+    is_negative: _mysten_bcs.BcsType<boolean, boolean, "bool">;
+    exp: MoveStruct<{
+        bits: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+    }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+    mant: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+}, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+
+type MoveFloat = ReturnType<(typeof Float)['parse']>;
+/**
+ * Converts a generated Move `i64` wrapper into a JavaScript number.
+ *
+ * The generated bindings expose signed 64-bit integers through a `{ bits }`
+ * field that stores the raw two's-complement bit pattern. This helper
+ * reinterprets those bits as a signed `i64` and returns a plain JS number.
+ * Invalid or missing input falls back to `0`.
+ *
+ * @param i64 Generated Move `i64` value, typically used for float exponents.
+ * @returns The signed 64-bit value as a JavaScript number.
+ */
+declare function fromMoveI64(i64: MoveFloat['exp']): number;
+/**
+ * Converts a generated Move `Float` struct into a JavaScript number.
+ *
+ * Suigar float values are represented as a sign flag, an unsigned mantissa,
+ * and a Move `i64` exponent. This helper rebuilds the numeric value using the
+ * same normalization expected by the onchain format and applies the sign at
+ * the end. Missing mantissas are treated as `0`, and a zero mantissa returns `0`.
+ *
+ * @param float Generated Move float value with `mant`, `exp`, and `is_negative`.
+ * @returns The decoded floating-point value as a JavaScript number.
+ */
+declare function fromMoveFloat(float: MoveFloat): number;
+/**
+ * Extracts and normalizes the first generic coin type from a Move object type.
+ *
+ * PvP game object types encode the wager coin as their first type parameter,
+ * for example `Game<0x2::sui::SUI>`. This helper converts that generic type
+ * argument into the SDK's canonical struct tag string.
+ *
+ * @param type Fully qualified Move object type with the coin type as its first generic argument.
+ * @returns Normalized coin type struct tag.
+ */
+declare function parseCoinType(type: string): string;
+/**
+ * Decodes `BetResultEvent.game_details` into plain application values.
+ *
+ * Suigar stores game detail entries as `VecMap<string, vector<u8>>`, so raw BCS
+ * decoding leaves each value as bytes. This helper looks up the known schema for
+ * each key, parses the bytes into the expected runtime type, and preserves the
+ * original onchain keys in the returned object. Unknown keys fall back to
+ * string decoding so newer detail fields remain readable by default.
+ *
+ * @param gameDetails Raw `game_details` map from a decoded bet result event.
+ * @returns A plain object with the same keys and decoded string, number, or boolean values.
+ */
+declare function parseGameDetails(gameDetails: BetResultGameDetails): ParsedGameDetails;
+
+export { DEFAULT_GAS_BUDGET_MIST, DEFAULT_LIMBO_MULTIPLIER_SCALE, DEFAULT_RANGE_SCALE, RANGE_POINT_LIMIT, fromMoveFloat, fromMoveI64, parseCoinType, parseGameDetails, toBigInt, toU16, toU8 };

package/dist/utils.d.ts

@@ -0,0 +1,180 @@
+import * as _mysten_bcs from '@mysten/bcs';
+import { M as MoveStruct } from './index-3P_LBbDM.js';
+import '@mysten/sui/bcs';
+import '@mysten/sui/client';
+
+declare const BetResultEvent: MoveStruct<{
+    player: _mysten_bcs.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    coin_type: MoveStruct<{
+        name: _mysten_bcs.BcsType<string, string, "string">;
+    }, "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName">;
+    stake_amount: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+    unsafe_oracle_usd_coin_price: MoveStruct<{
+        is_negative: _mysten_bcs.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+            bits: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+    }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+    adjusted_oracle_usd_coin_price: MoveStruct<{
+        is_negative: _mysten_bcs.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+            bits: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+    }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+    outcome_amount: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+    game_details: MoveStruct<{
+        contents: _mysten_bcs.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_bcs.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>">;
+
+type BetResultGameDetails = ReturnType<(typeof BetResultEvent)['parse']>['game_details'];
+type ParsedGameDetailValue = string | number | boolean;
+type ParsedGameDetails = Record<string, ParsedGameDetailValue>;
+
+declare const DEFAULT_GAS_BUDGET_MIST: bigint;
+declare const DEFAULT_RANGE_SCALE = 1000000;
+declare const RANGE_POINT_LIMIT: number;
+declare const DEFAULT_LIMBO_MULTIPLIER_SCALE = 100;
+
+/**
+ * Normalizes a value into a non-negative `bigint`.
+ *
+ * Accepted inputs:
+ * - `bigint`
+ * - finite `number`
+ * - base-10 integer `string`
+ * - `boolean`
+ *
+ * Number inputs are truncated toward zero before conversion, so `5.9` becomes
+ * `5n`. String and boolean inputs are parsed through the native
+ * `BigInt(...)` constructor, so `true` becomes `1n`, `false` becomes `0n`,
+ * and only integer strings are accepted.
+ *
+ * @param value Value to normalize.
+ * @returns A non-negative `bigint`.
+ * @throws When `value` is not a bigint, finite number, integer string, or
+ * boolean.
+ * @throws When the normalized value is negative.
+ */
+declare function toBigInt(value: unknown): bigint;
+/**
+ * Validates that a value can be safely used as a Move `u8` in the `0..255`
+ * range.
+ *
+ * Accepted inputs:
+ * - finite `number`
+ * - base-10 integer `string`
+ *
+ * String inputs are accepted for parsed values such as `'1'`, but only when
+ * they are plain non-negative integer strings. This helper does not accept
+ * booleans and does not truncate fractional values.
+ *
+ * @param value Value to validate.
+ * @returns The validated `u8` value as a JavaScript `number`.
+ * @throws When `value` is not a finite number or integer string.
+ * @throws When `value` is not an integer between `0` and `255`.
+ */
+declare function toU8(value: unknown): number;
+/**
+ * Validates that a value can be safely used as a Move `u16` in the
+ * `0..65535` range.
+ *
+ * Accepted inputs:
+ * - finite `number`
+ * - base-10 integer `string`
+ *
+ * String inputs are accepted for parsed values such as `'1'`, but only when
+ * they are plain non-negative integer strings. This helper does not accept
+ * booleans and does not truncate fractional values.
+ *
+ * @param value Value to validate.
+ * @returns The validated `u16` value as a JavaScript `number`.
+ * @throws When `value` is not a finite number or integer string.
+ * @throws When `value` is not an integer between `0` and `65535`.
+ */
+declare function toU16(value: unknown): number;
+
+declare const Float: MoveStruct<{
+    is_negative: _mysten_bcs.BcsType<boolean, boolean, "bool">;
+    exp: MoveStruct<{
+        bits: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+    }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+    mant: _mysten_bcs.BcsType<string, string | number | bigint, "u64">;
+}, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+
+type MoveFloat = ReturnType<(typeof Float)['parse']>;
+/**
+ * Converts a generated Move `i64` wrapper into a JavaScript number.
+ *
+ * The generated bindings expose signed 64-bit integers through a `{ bits }`
+ * field that stores the raw two's-complement bit pattern. This helper
+ * reinterprets those bits as a signed `i64` and returns a plain JS number.
+ * Invalid or missing input falls back to `0`.
+ *
+ * @param i64 Generated Move `i64` value, typically used for float exponents.
+ * @returns The signed 64-bit value as a JavaScript number.
+ */
+declare function fromMoveI64(i64: MoveFloat['exp']): number;
+/**
+ * Converts a generated Move `Float` struct into a JavaScript number.
+ *
+ * Suigar float values are represented as a sign flag, an unsigned mantissa,
+ * and a Move `i64` exponent. This helper rebuilds the numeric value using the
+ * same normalization expected by the onchain format and applies the sign at
+ * the end. Missing mantissas are treated as `0`, and a zero mantissa returns `0`.
+ *
+ * @param float Generated Move float value with `mant`, `exp`, and `is_negative`.
+ * @returns The decoded floating-point value as a JavaScript number.
+ */
+declare function fromMoveFloat(float: MoveFloat): number;
+/**
+ * Extracts and normalizes the first generic coin type from a Move object type.
+ *
+ * PvP game object types encode the wager coin as their first type parameter,
+ * for example `Game<0x2::sui::SUI>`. This helper converts that generic type
+ * argument into the SDK's canonical struct tag string.
+ *
+ * @param type Fully qualified Move object type with the coin type as its first generic argument.
+ * @returns Normalized coin type struct tag.
+ */
+declare function parseCoinType(type: string): string;
+/**
+ * Decodes `BetResultEvent.game_details` into plain application values.
+ *
+ * Suigar stores game detail entries as `VecMap<string, vector<u8>>`, so raw BCS
+ * decoding leaves each value as bytes. This helper looks up the known schema for
+ * each key, parses the bytes into the expected runtime type, and preserves the
+ * original onchain keys in the returned object. Unknown keys fall back to
+ * string decoding so newer detail fields remain readable by default.
+ *
+ * @param gameDetails Raw `game_details` map from a decoded bet result event.
+ * @returns A plain object with the same keys and decoded string, number, or boolean values.
+ */
+declare function parseGameDetails(gameDetails: BetResultGameDetails): ParsedGameDetails;
+
+export { DEFAULT_GAS_BUDGET_MIST, DEFAULT_LIMBO_MULTIPLIER_SCALE, DEFAULT_RANGE_SCALE, RANGE_POINT_LIMIT, fromMoveFloat, fromMoveI64, parseCoinType, parseGameDetails, toBigInt, toU16, toU8 };

package/dist/utils.js

@@ -0,0 +1 @@
+export { DEFAULT_GAS_BUDGET_MIST, DEFAULT_LIMBO_MULTIPLIER_SCALE, DEFAULT_RANGE_SCALE, RANGE_POINT_LIMIT, fromMoveFloat, fromMoveI64, parseCoinType, parseGameDetails, toBigInt, toU16, toU8 } from './chunk-TBJ5TYYE.js';