@suigar/sdk 2.0.0-beta.13 → 2.0.0-beta.15

package/dist/index.cjs

@@ -1,1692 +0,0 @@
-'use strict';
-
-var utils = require('@mysten/sui/utils');
-var bcs = require('@mysten/sui/bcs');
-var transactions = require('@mysten/sui/transactions');
-var client = require('@mysten/sui/client');
-
-// src/client.ts
-var MOVE_STDLIB_ADDRESS = utils.normalizeSuiAddress("0x1");
-var SUI_FRAMEWORK_ADDRESS = utils.normalizeSuiAddress("0x2");
-function getPureBcsSchema(typeTag) {
-  const parsedTag = typeof typeTag === "string" ? bcs.TypeTagSerializer.parseFromStr(typeTag) : typeTag;
-  if ("u8" in parsedTag) {
-    return bcs.bcs.U8;
-  } else if ("u16" in parsedTag) {
-    return bcs.bcs.U16;
-  } else if ("u32" in parsedTag) {
-    return bcs.bcs.U32;
-  } else if ("u64" in parsedTag) {
-    return bcs.bcs.U64;
-  } else if ("u128" in parsedTag) {
-    return bcs.bcs.U128;
-  } else if ("u256" in parsedTag) {
-    return bcs.bcs.U256;
-  } else if ("address" in parsedTag) {
-    return bcs.bcs.Address;
-  } else if ("bool" in parsedTag) {
-    return bcs.bcs.Bool;
-  } else if ("vector" in parsedTag) {
-    const type = getPureBcsSchema(parsedTag.vector);
-    return type ? bcs.bcs.vector(type) : null;
-  } else if ("struct" in parsedTag) {
-    const structTag = parsedTag.struct;
-    const pkg = utils.normalizeSuiAddress(structTag.address);
-    if (pkg === MOVE_STDLIB_ADDRESS) {
-      if ((structTag.module === "ascii" || structTag.module === "string") && structTag.name === "String") {
-        return bcs.bcs.String;
-      }
-      if (structTag.module === "option" && structTag.name === "Option") {
-        const inner = structTag.typeParams[0];
-        const type = inner ? getPureBcsSchema(inner) : null;
-        return type ? bcs.bcs.option(type) : null;
-      }
-    }
-    if (pkg === SUI_FRAMEWORK_ADDRESS && structTag.module === "object" && (structTag.name === "ID" || structTag.name === "UID")) {
-      return bcs.bcs.Address;
-    }
-  }
-  return null;
-}
-function normalizeMoveArguments(args, argTypes, parameterNames) {
-  Array.isArray(args) ? args.length : Object.keys(args).length;
-  const normalizedArgs = [];
-  let index = 0;
-  for (const argType of argTypes) {
-    if (argType === "0x2::clock::Clock") {
-      normalizedArgs.push((tx) => tx.object.clock());
-      continue;
-    }
-    if (argType === "0x2::random::Random") {
-      normalizedArgs.push((tx) => tx.object.random());
-      continue;
-    }
-    if (argType === "0x2::deny_list::DenyList") {
-      normalizedArgs.push((tx) => tx.object.denyList());
-      continue;
-    }
-    if (argType === "0x3::sui_system::SuiSystemState") {
-      normalizedArgs.push((tx) => tx.object.system());
-      continue;
-    }
-    let arg;
-    if (Array.isArray(args)) {
-      if (index >= args.length) {
-        throw new Error(
-          `Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`
-        );
-      }
-      arg = args[index];
-    } else {
-      {
-        throw new Error(`Expected arguments to be passed as an array`);
-      }
-    }
-    index += 1;
-    if (typeof arg === "function" || transactions.isArgument(arg)) {
-      normalizedArgs.push(arg);
-      continue;
-    }
-    const bcsType = argType === null ? null : getPureBcsSchema(argType);
-    if (bcsType) {
-      const bytes = bcsType.serialize(arg);
-      normalizedArgs.push((tx) => tx.pure(bytes));
-      continue;
-    }
-    if (typeof arg === "string") {
-      normalizedArgs.push((tx) => tx.object(arg));
-      continue;
-    }
-    throw new Error(`Invalid argument ${stringify(arg)} for type ${argType}`);
-  }
-  return normalizedArgs;
-}
-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)
-      };
-    });
-  }
-};
-function stringify(val) {
-  if (typeof val === "object") {
-    return JSON.stringify(val, (val2) => val2);
-  }
-  if (typeof val === "bigint") {
-    return val.toString();
-  }
-  return val;
-}
-var $moduleName = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
-var TypeName = new MoveStruct({
-  name: `${$moduleName}::TypeName`,
-  fields: {
-    name: bcs.bcs.string()
-  }
-});
-var $moduleName2 = "0x2::vec_map";
-function Entry(...typeParameters) {
-  return new MoveStruct({
-    name: `${$moduleName2}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`,
-    fields: {
-      key: typeParameters[0],
-      value: typeParameters[1]
-    }
-  });
-}
-function VecMap(...typeParameters) {
-  return new MoveStruct({
-    name: `${$moduleName2}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`,
-    fields: {
-      contents: bcs.bcs.vector(Entry(typeParameters[0], typeParameters[1]))
-    }
-  });
-}
-var $moduleName3 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
-var I64 = new MoveStruct({
-  name: `${$moduleName3}::I64`,
-  fields: {
-    bits: bcs.bcs.u64()
-  }
-});
-
-// src/contracts/core/float.ts
-var $moduleName4 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
-var Float = new MoveStruct({
-  name: `${$moduleName4}::Float`,
-  fields: {
-    is_negative: bcs.bcs.bool(),
-    exp: I64,
-    mant: bcs.bcs.u64()
-  }
-});
-
-// src/contracts/core/core.ts
-var $moduleName5 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::core";
-var BetResultEvent = new MoveStruct({
-  name: `${$moduleName5}::BetResultEvent<phantom T0>`,
-  fields: {
-    player: bcs.bcs.Address,
-    coin_type: TypeName,
-    stake_amount: bcs.bcs.u64(),
-    unsafe_oracle_usd_coin_price: Float,
-    adjusted_oracle_usd_coin_price: Float,
-    outcome_amount: bcs.bcs.u64(),
-    game_details: VecMap(bcs.bcs.string(), bcs.bcs.vector(bcs.bcs.u8())),
-    metadata: VecMap(bcs.bcs.string(), bcs.bcs.vector(bcs.bcs.u8()))
-  }
-});
-var $moduleName6 = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
-var TypeName2 = new MoveStruct({
-  name: `${$moduleName6}::TypeName`,
-  fields: {
-    name: bcs.bcs.string()
-  }
-});
-var $moduleName7 = "0x2::balance";
-var Balance = new MoveStruct({
-  name: `${$moduleName7}::Balance<phantom T0>`,
-  fields: {
-    value: bcs.bcs.u64()
-  }
-});
-var $moduleName8 = "0x2::vec_map";
-function Entry2(...typeParameters) {
-  return new MoveStruct({
-    name: `${$moduleName8}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`,
-    fields: {
-      key: typeParameters[0],
-      value: typeParameters[1]
-    }
-  });
-}
-function VecMap2(...typeParameters) {
-  return new MoveStruct({
-    name: `${$moduleName8}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`,
-    fields: {
-      contents: bcs.bcs.vector(Entry2(typeParameters[0], typeParameters[1]))
-    }
-  });
-}
-
-// src/contracts/pvp-coinflip/pvp_coinflip.ts
-var $moduleName9 = "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip";
-var PvpCoinflipSettingsKey = new MoveStruct({
-  name: `${$moduleName9}::PvpCoinflipSettingsKey`,
-  fields: {
-    dummy_field: bcs.bcs.bool()
-  }
-});
-var Game = new MoveStruct({
-  name: `${$moduleName9}::Game<phantom T0>`,
-  fields: {
-    id: bcs.bcs.Address,
-    creator: bcs.bcs.Address,
-    creator_is_tails: bcs.bcs.bool(),
-    is_private: bcs.bcs.bool(),
-    creator_metadata: VecMap2(bcs.bcs.string(), bcs.bcs.vector(bcs.bcs.u8())),
-    joiner: bcs.bcs.Address,
-    winner: bcs.bcs.Address,
-    stake_per_player: bcs.bcs.u64(),
-    house_edge_bps: bcs.bcs.u64(),
-    stake_pot: Balance
-  }
-});
-var GameCreatedEvent = new MoveStruct({
-  name: `${$moduleName9}::GameCreatedEvent<phantom T0>`,
-  fields: {
-    game_id: bcs.bcs.Address,
-    creator: bcs.bcs.Address,
-    creator_is_tails: bcs.bcs.bool(),
-    is_private: bcs.bcs.bool(),
-    joiner_is_tails: bcs.bcs.bool(),
-    stake_per_player: bcs.bcs.u64(),
-    house_edge_bps: bcs.bcs.u64(),
-    coin_type: TypeName2
-  }
-});
-var GameResolvedEvent = new MoveStruct({
-  name: `${$moduleName9}::GameResolvedEvent<phantom T0>`,
-  fields: {
-    game_id: bcs.bcs.Address,
-    creator: bcs.bcs.Address,
-    joiner: bcs.bcs.Address,
-    winner: bcs.bcs.Address,
-    creator_is_tails: bcs.bcs.bool(),
-    is_private: bcs.bcs.bool(),
-    joiner_is_tails: bcs.bcs.bool(),
-    stake_per_player: bcs.bcs.u64(),
-    total_pot: bcs.bcs.u64(),
-    house_edge_amount: bcs.bcs.u64(),
-    payout_amount: bcs.bcs.u64(),
-    coin_type: TypeName2
-  }
-});
-var GameCancelledEvent = new MoveStruct({
-  name: `${$moduleName9}::GameCancelledEvent<phantom T0>`,
-  fields: {
-    game_id: bcs.bcs.Address,
-    creator: bcs.bcs.Address,
-    creator_is_tails: bcs.bcs.bool(),
-    is_private: bcs.bcs.bool(),
-    stake_per_player: bcs.bcs.u64(),
-    coin_type: TypeName2
-  }
-});
-var Parameters = new MoveStruct({
-  name: `${$moduleName9}::Parameters<phantom T0>`,
-  fields: {
-    id: bcs.bcs.Address,
-    house_edge_bps: bcs.bcs.u64(),
-    min_stake: bcs.bcs.u64()
-  }
-});
-function createGame(options) {
-  const packageAddress = options.package ?? "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202";
-  const argumentsTypes = [
-    null,
-    null,
-    "bool",
-    "bool",
-    "vector<0x1::string::String>",
-    "vector<vector<u8>>"
-  ];
-  return (tx) => tx.moveCall({
-    package: packageAddress,
-    module: "pvp_coinflip",
-    function: "create_game",
-    arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
-    typeArguments: options.typeArguments
-  });
-}
-function joinGame(options) {
-  const packageAddress = options.package ?? "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202";
-  const argumentsTypes = [
-    "0x2::object::ID",
-    null,
-    null,
-    "vector<0x1::string::String>",
-    "vector<vector<u8>>",
-    null,
-    "0x2::clock::Clock",
-    "0x2::random::Random"
-  ];
-  return (tx) => tx.moveCall({
-    package: packageAddress,
-    module: "pvp_coinflip",
-    function: "join_game",
-    arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
-    typeArguments: options.typeArguments
-  });
-}
-function cancelGame(options) {
-  const packageAddress = options.package ?? "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202";
-  const argumentsTypes = ["0x2::object::ID", null];
-  return (tx) => tx.moveCall({
-    package: packageAddress,
-    module: "pvp_coinflip",
-    function: "cancel_game",
-    arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
-    typeArguments: options.typeArguments
-  });
-}
-
-// src/configs/package.mainnet.ts
-var MAINNET_PACKAGE_IDS = {
-  sweetHouse: "0xa1549d73230118716bc08865b8d62454f360ddaf40eee2158e458e52125d4ef1",
-  core: "0xcbb0929f21450013ebe5e86e7139f2409da2e3ed212c51126a7e6448b795a43f",
-  coinflip: "0xca96885371150f55653f7fab9e9b146f5a19698b1002bdff42159ea9d2ba7d7e",
-  limbo: "0x89db6a55ad4e650cad641b6f9fd90b391b22b1d9adbb2cabbfeb94a9eeda7026",
-  plinko: "0x74a73daff11c11ed05299c93ed770c62ec4dc6756fa99e271e251c2399f49fef",
-  pvpCoinflip: "0x29162faf01a8135630e0a32bbe4ce47f69607b24dbb1edea3800861f91d0030a",
-  range: "0xd19e32b0f2a5e541fbd345b4602f8a93a2eee25c16029595b6fef0b1e0461a54",
-  wheel: "0x6791eac73fe7bf463b7f3b1ea391df265fbc1b96201270664a5a11e2441e9955"
-};
-var MAINNET_COIN_TYPES = {
-  sui: "0x2::sui::SUI",
-  usdc: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC"
-};
-var MAINNET_PRICE_INFO_OBJECT_IDS = {
-  sui: "0x801dbc2f0053d34734814b2d6df491ce7807a725fe9a01ad74a07e9c51396c37",
-  usdc: "0x5dec622733a204ca27f5a90d8c2fad453cc6665186fd5dff13a83d0b6c9027ab"
-};
-
-// src/configs/package.testnet.ts
-var TESTNET_PACKAGE_IDS = {
-  sweetHouse: "0xb7f64e5a273aba1ede00caa0a6f8027cc7490c279d17eab12e7100ed20660603",
-  core: "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc",
-  coinflip: "0xb35c5f286c443752afc8ccb40125a578a4f32df35617170ccfa17fe180ab80ea",
-  limbo: "0x96c7841b9b32c59a219760fd656f1c3aceb53cc74a68ec9844a3a696374309f4",
-  plinko: "0xd3dd2200883af10811724f0bed97591ad155a02efd6332d471ff8b346030dfb7",
-  pvpCoinflip: "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202",
-  range: "0x096a4cf18b3661e76b2c62b90785418345d52f45b272448794f123a4cb6b6416",
-  wheel: "0x0997852ded7e13301c42317004bc49704a893aa82997c5706cebee59053a31b7"
-};
-var TESTNET_COIN_TYPES = {
-  sui: "0x47c67b9594069c32caa7a6e875ddf31d7fa52602dd22ccb9ebd8d3482aed76dc::test_sui::TEST_SUI",
-  usdc: "0x47c67b9594069c32caa7a6e875ddf31d7fa52602dd22ccb9ebd8d3482aed76dc::test_usdc::TEST_USDC"
-};
-var TESTNET_PRICE_INFO_OBJECT_IDS = {
-  sui: "0x1ebb295c789cc42b3b2a1606482cd1c7124076a0f5676718501fda8c7fd075a0",
-  usdc: "0x9c4dd4008297ffa5e480684b8100ec21cc934405ed9a25d4e4d7b6259aad9c81"
-};
-
-// src/configs/package.ts
-var PACKAGE_IDS = {
-  mainnet: { ...MAINNET_PACKAGE_IDS },
-  testnet: { ...TESTNET_PACKAGE_IDS }
-};
-var COIN_TYPES = {
-  mainnet: { ...MAINNET_COIN_TYPES },
-  testnet: { ...TESTNET_COIN_TYPES }
-};
-var PRICE_INFO_OBJECT_IDS = {
-  mainnet: { ...MAINNET_PRICE_INFO_OBJECT_IDS },
-  testnet: { ...TESTNET_PRICE_INFO_OBJECT_IDS }
-};
-
-// src/configs/registry.mainnet.ts
-var PVP_COINFLIP_REGISTRY_ID = "0x3d73568546c539c1da3eb2b8fe917faef3c0acdbec78a67fe6d52800a0729349";
-
-// src/configs/registry.testnet.ts
-var PVP_COINFLIP_REGISTRY_ID2 = "0x99f20d8e4be012ea14a681144ae72ac349d0a1a1585205880183eb167f075bad";
-
-// src/configs/registry.ts
-var REGISTRY_IDS = {
-  mainnet: {
-    pvpCoinflip: PVP_COINFLIP_REGISTRY_ID
-  },
-  testnet: {
-    pvpCoinflip: PVP_COINFLIP_REGISTRY_ID2
-  }
-};
-
-// src/helpers/config.ts
-var DEFAULT_CACHE_TTL_MS = 30 * 60 * 1e3;
-function resolveSuigarConfig(network) {
-  const packageIds = PACKAGE_IDS[network];
-  const registryIds = REGISTRY_IDS[network];
-  const coinTypes = COIN_TYPES[network];
-  const priceInfoObjectIds = PRICE_INFO_OBJECT_IDS[network];
-  return {
-    packageIds: { ...packageIds },
-    registryIds: { ...registryIds },
-    coinTypes: {
-      sui: utils.normalizeStructTag(coinTypes.sui),
-      usdc: utils.normalizeStructTag(coinTypes.usdc)
-    },
-    priceInfoObjectIds: {
-      sui: priceInfoObjectIds.sui,
-      usdc: priceInfoObjectIds.usdc
-    }
-  };
-}
-function assertConfiguredBetGame(config, game) {
-  if (!resolveGamePackageId(config, game)) {
-    throw new Error(`Missing required config for ${game}: packageIds.${game}`);
-  }
-}
-function resolveGamePackageId(config, game) {
-  switch (game) {
-    case "coinflip":
-      return config.packageIds.coinflip;
-    case "limbo":
-      return config.packageIds.limbo;
-    case "plinko":
-      return config.packageIds.plinko;
-    case "pvp-coinflip":
-      return config.packageIds.pvpCoinflip;
-    case "range":
-      return config.packageIds.range;
-    case "wheel":
-      return config.packageIds.wheel;
-  }
-}
-function resolvePriceInfoObjectId(config, coinType) {
-  const normalizedCoinType = utils.normalizeStructTag(coinType);
-  const supportedCoin = resolveSupportedCoin(config, normalizedCoinType);
-  const objectId = config.priceInfoObjectIds[supportedCoin];
-  if (!objectId) {
-    throw new Error(
-      `Missing price info object configuration for coin type ${coinType}`
-    );
-  }
-  return objectId;
-}
-function resolveSupportedCoin(config, coinType) {
-  const [supportedCoin] = Object.entries(config.coinTypes).find(([_, value]) => value === coinType) ?? [];
-  if (!supportedCoin) {
-    throw new RangeError(
-      `Unsupported coin type ${coinType}. Supported coin types: ${Object.values(
-        config.coinTypes
-      ).join(", ")}`
-    );
-  }
-  return supportedCoin;
-}
-function replaceStructTagAddress(structName, address) {
-  return utils.normalizeStructTag({
-    ...utils.parseStructTag(structName),
-    address
-  });
-}
-function resolveGameSettingsKeyType(structName, packageId) {
-  return replaceStructTagAddress(structName, packageId);
-}
-function resolveCoinTypeNameForTypeNameKey(structName) {
-  const { address } = utils.parseStructTag(structName);
-  return replaceStructTagAddress(
-    structName,
-    utils.normalizeSuiAddress(address).replace(/^0x/, "")
-  );
-}
-var PARTNER_METADATA_KEY = "partner";
-var RESERVED_METADATA_KEYS = /* @__PURE__ */ new Set([PARTNER_METADATA_KEY, "referrer"]);
-var textEncoder = new TextEncoder();
-function encodeString(value) {
-  try {
-    return utils.fromHex(value);
-  } catch {
-    return textEncoder.encode(value);
-  }
-}
-function encodeMetadataValue(value) {
-  if (value instanceof Uint8Array) {
-    return Array.from(value);
-  }
-  if (Array.isArray(value)) {
-    return value;
-  }
-  return Array.from(encodeString(String(value)));
-}
-function encodeBetMetadata(metadata, partner) {
-  const keys = [];
-  const values = [];
-  for (const [key, value] of Object.entries(metadata ?? {})) {
-    if (RESERVED_METADATA_KEYS.has(key)) {
-      console.warn(
-        `Metadata key "${key}" is reserved and will be ignored when parsing metadata.`
-      );
-      continue;
-    }
-    if (value == null) {
-      continue;
-    }
-    keys.push(key);
-    values.push(encodeMetadataValue(value));
-  }
-  if (partner?.trim()) {
-    keys.unshift(PARTNER_METADATA_KEY);
-    values.unshift(encodeMetadataValue(partner));
-  }
-  return {
-    keys,
-    values
-  };
-}
-var $moduleName10 = "0xb35c5f286c443752afc8ccb40125a578a4f32df35617170ccfa17fe180ab80ea::coinflip";
-var CoinFlipSettingsKey = new MoveStruct({
-  name: `${$moduleName10}::CoinFlipSettingsKey`,
-  fields: {
-    dummy_field: bcs.bcs.bool()
-  }
-});
-var Parameters2 = new MoveStruct({
-  name: `${$moduleName10}::Parameters<phantom T0>`,
-  fields: {
-    id: bcs.bcs.Address,
-    house_edge: bcs.bcs.u64(),
-    min_stake: bcs.bcs.u64(),
-    max_stake: bcs.bcs.u64()
-  }
-});
-function play(options) {
-  const packageAddress = options.package ?? "0xb35c5f286c443752afc8ccb40125a578a4f32df35617170ccfa17fe180ab80ea";
-  const argumentsTypes = [
-    null,
-    "u64",
-    null,
-    "u64",
-    "bool",
-    "vector<0x1::string::String>",
-    "vector<vector<u8>>",
-    null,
-    "0x2::clock::Clock",
-    "0x2::random::Random"
-  ];
-  return (tx) => tx.moveCall({
-    package: packageAddress,
-    module: "coinflip",
-    function: "play",
-    arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
-    typeArguments: options.typeArguments
-  });
-}
-var DEFAULT_GAS_BUDGET_MIST = utils.parseToMist("0.05");
-var DEFAULT_RANGE_SCALE = 1e6;
-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 RangeError(
-      `Value must be a ${typeName} integer (0-${max}): ${value}`
-    );
-  }
-  return num;
-}
-function toU8(value) {
-  return toBoundedInt(value, 255, "u8");
-}
-
-// src/types/network.type.ts
-var SUPPORTED_SUI_NETWORKS = [
-  "mainnet",
-  "testnet"
-];
-
-// src/utils/parser.ts
-new TextDecoder();
-({
-  u8: bcs.bcs.U8,
-  u64: bcs.bcs.U64,
-  bool: bcs.bcs.Bool,
-  string: bcs.bcs.String
-});
-function parseCoinType(type) {
-  const coinType = utils.parseStructTag(type).typeParams[0];
-  if (!coinType) {
-    throw new TypeError(`Unable to parse coin type from ${type}`);
-  }
-  return utils.normalizeStructTag(coinType);
-}
-
-// src/transactions/shared.ts
-function createBaseGameTransaction({
-  config,
-  game,
-  playerAddress,
-  gasBudget
-}) {
-  assertConfiguredBetGame(config, game);
-  const tx = new transactions.Transaction();
-  tx.setSenderIfNotSet(utils.normalizeSuiAddress(playerAddress));
-  tx.setGasBudgetIfNotSet(gasBudget ?? DEFAULT_GAS_BUDGET_MIST);
-  return tx;
-}
-function buildSharedStandardGameBetCall({
-  config,
-  playerAddress,
-  coinType,
-  stake,
-  cashStake,
-  betCount,
-  metadata,
-  partner,
-  allowGasCoinShortcut = true,
-  buildRewardCoin
-}) {
-  return (tx) => {
-    const normalizedPlayerAddress = utils.normalizeSuiAddress(playerAddress);
-    const normalizedCoinType = utils.normalizeStructTag(coinType);
-    const resolvedStake = toBigInt(stake);
-    const resolvedCashStake = toBigInt(cashStake ?? stake);
-    const resolvedBetCount = toBigInt(betCount ?? 1);
-    const encodedMetadata = encodeBetMetadata(metadata, partner);
-    const priceInfoObjectId = resolvePriceInfoObjectId(
-      config,
-      normalizedCoinType
-    );
-    const betCoin = tx.coin({
-      type: normalizedCoinType,
-      balance: resolvedCashStake,
-      useGasCoin: allowGasCoinShortcut
-    });
-    const rewardCoin = buildRewardCoin({
-      tx,
-      config,
-      playerAddress: normalizedPlayerAddress,
-      coinType: normalizedCoinType,
-      stake: resolvedStake,
-      cashStake: resolvedCashStake,
-      betCount: resolvedBetCount,
-      metadata: encodedMetadata,
-      priceInfoObjectId,
-      betCoin
-    });
-    tx.transferObjects([rewardCoin], tx.pure.address(normalizedPlayerAddress));
-    return rewardCoin;
-  };
-}
-function buildSharedStandardGameBetTransaction(options) {
-  const tx = createBaseGameTransaction(options);
-  tx.add(buildSharedStandardGameBetCall(options));
-  return tx;
-}
-
-// src/transactions/coinflip.ts
-function buildCoinflipTransaction(options) {
-  return buildSharedStandardGameBetTransaction({
-    ...options,
-    game: "coinflip",
-    buildRewardCoin: ({
-      tx,
-      config,
-      coinType,
-      stake,
-      betCount,
-      metadata,
-      priceInfoObjectId,
-      betCoin
-    }) => play({
-      package: config.packageIds.coinflip,
-      typeArguments: [coinType],
-      arguments: [
-        config.packageIds.sweetHouse,
-        stake,
-        betCoin,
-        betCount,
-        options.side === "tails",
-        metadata.keys,
-        metadata.values,
-        priceInfoObjectId
-      ]
-    })(tx)
-  });
-}
-var $moduleName11 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
-var I642 = new MoveStruct({
-  name: `${$moduleName11}::I64`,
-  fields: {
-    bits: bcs.bcs.u64()
-  }
-});
-
-// src/contracts/limbo/deps/0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc/float.ts
-var $moduleName12 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
-var Float2 = new MoveStruct({
-  name: `${$moduleName12}::Float`,
-  fields: {
-    is_negative: bcs.bcs.bool(),
-    exp: I642,
-    mant: bcs.bcs.u64()
-  }
-});
-
-// src/contracts/limbo/limbo.ts
-var $moduleName13 = "0x96c7841b9b32c59a219760fd656f1c3aceb53cc74a68ec9844a3a696374309f4::limbo";
-var LimboSettingsKey = new MoveStruct({
-  name: `${$moduleName13}::LimboSettingsKey`,
-  fields: {
-    dummy_field: bcs.bcs.bool()
-  }
-});
-var Parameters3 = new MoveStruct({
-  name: `${$moduleName13}::Parameters<phantom T0>`,
-  fields: {
-    id: bcs.bcs.Address,
-    min_stake: bcs.bcs.u64(),
-    max_stake: bcs.bcs.u64(),
-    max_payout: bcs.bcs.u64(),
-    min_target_multiplier: Float2,
-    max_target_multiplier: Float2,
-    max_number_of_games: bcs.bcs.u64(),
-    min_rtp: Float2,
-    max_rtp: Float2
-  }
-});
-function play2(options) {
-  const packageAddress = options.package ?? "0x96c7841b9b32c59a219760fd656f1c3aceb53cc74a68ec9844a3a696374309f4";
-  const argumentsTypes = [
-    null,
-    "u64",
-    null,
-    "u64",
-    "u64",
-    "u64",
-    "vector<0x1::string::String>",
-    "vector<vector<u8>>",
-    null,
-    "0x2::clock::Clock",
-    "0x2::random::Random"
-  ];
-  return (tx) => tx.moveCall({
-    package: packageAddress,
-    module: "limbo",
-    function: "play",
-    arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
-    typeArguments: options.typeArguments
-  });
-}
-
-// src/transactions/limbo.ts
-function buildLimboTransaction(options) {
-  const scale = options.scale ?? DEFAULT_LIMBO_MULTIPLIER_SCALE;
-  const numerator = Math.round(options.targetMultiplier * scale);
-  return buildSharedStandardGameBetTransaction({
-    ...options,
-    game: "limbo",
-    buildRewardCoin: ({
-      tx,
-      config,
-      coinType,
-      stake,
-      betCount,
-      metadata,
-      priceInfoObjectId,
-      betCoin
-    }) => play2({
-      package: config.packageIds.limbo,
-      typeArguments: [coinType],
-      arguments: [
-        config.packageIds.sweetHouse,
-        stake,
-        betCoin,
-        betCount,
-        BigInt(numerator),
-        BigInt(scale),
-        metadata.keys,
-        metadata.values,
-        priceInfoObjectId
-      ]
-    })(tx)
-  });
-}
-var $moduleName14 = "0x2::vec_map";
-function Entry3(...typeParameters) {
-  return new MoveStruct({
-    name: `${$moduleName14}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`,
-    fields: {
-      key: typeParameters[0],
-      value: typeParameters[1]
-    }
-  });
-}
-function VecMap3(...typeParameters) {
-  return new MoveStruct({
-    name: `${$moduleName14}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`,
-    fields: {
-      contents: bcs.bcs.vector(Entry3(typeParameters[0], typeParameters[1]))
-    }
-  });
-}
-var $moduleName15 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
-var I643 = new MoveStruct({
-  name: `${$moduleName15}::I64`,
-  fields: {
-    bits: bcs.bcs.u64()
-  }
-});
-
-// src/contracts/plinko/deps/0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc/float.ts
-var $moduleName16 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
-var Float3 = new MoveStruct({
-  name: `${$moduleName16}::Float`,
-  fields: {
-    is_negative: bcs.bcs.bool(),
-    exp: I643,
-    mant: bcs.bcs.u64()
-  }
-});
-
-// src/contracts/plinko/plinko.ts
-var $moduleName17 = "0xd3dd2200883af10811724f0bed97591ad155a02efd6332d471ff8b346030dfb7::plinko";
-var PlinkoSettingsKey = new MoveStruct({
-  name: `${$moduleName17}::PlinkoSettingsKey`,
-  fields: {
-    dummy_field: bcs.bcs.bool()
-  }
-});
-var PlinkoConfig = new MoveStruct({
-  name: `${$moduleName17}::PlinkoConfig`,
-  fields: {
-    num_rows: bcs.bcs.u8(),
-    multipliers: bcs.bcs.vector(Float3),
-    min_stake: bcs.bcs.u64(),
-    max_stake: bcs.bcs.u64(),
-    is_playable: bcs.bcs.bool()
-  }
-});
-var Parameters4 = new MoveStruct({
-  name: `${$moduleName17}::Parameters<phantom T0>`,
-  fields: {
-    id: bcs.bcs.Address,
-    min_stake: bcs.bcs.u64(),
-    max_stake: bcs.bcs.u64(),
-    max_number_of_balls: bcs.bcs.u64(),
-    configs: VecMap3(bcs.bcs.u8(), PlinkoConfig)
-  }
-});
-function play3(options) {
-  const packageAddress = options.package ?? "0xd3dd2200883af10811724f0bed97591ad155a02efd6332d471ff8b346030dfb7";
-  const argumentsTypes = [
-    null,
-    "u64",
-    null,
-    "u64",
-    "u8",
-    "vector<0x1::string::String>",
-    "vector<vector<u8>>",
-    null,
-    "0x2::clock::Clock",
-    "0x2::random::Random"
-  ];
-  return (tx) => tx.moveCall({
-    package: packageAddress,
-    module: "plinko",
-    function: "play",
-    arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
-    typeArguments: options.typeArguments
-  });
-}
-
-// src/transactions/plinko.ts
-function buildPlinkoTransaction(options) {
-  const configId = toU8(options.configId);
-  return buildSharedStandardGameBetTransaction({
-    ...options,
-    game: "plinko",
-    buildRewardCoin: ({
-      tx,
-      config,
-      coinType,
-      stake,
-      betCount,
-      metadata,
-      priceInfoObjectId,
-      betCoin
-    }) => play3({
-      package: config.packageIds.plinko,
-      typeArguments: [coinType],
-      arguments: [
-        config.packageIds.sweetHouse,
-        stake,
-        betCoin,
-        betCount,
-        configId,
-        metadata.keys,
-        metadata.values,
-        priceInfoObjectId
-      ]
-    })(tx)
-  });
-}
-function buildPvPCoinflipTransaction(action, options) {
-  const tx = createBaseGameTransaction({
-    ...options,
-    game: "pvp-coinflip"
-  });
-  const normalizedCoinType = utils.normalizeStructTag(options.coinType);
-  const encodedMetadata = encodeBetMetadata(options.metadata, options.partner);
-  switch (action) {
-    case "create": {
-      const createOptions = options;
-      const stake = toBigInt(createOptions.stake);
-      const betCoin = tx.coin({
-        type: normalizedCoinType,
-        balance: stake,
-        useGasCoin: createOptions.allowGasCoinShortcut
-      });
-      tx.add(
-        createGame({
-          package: createOptions.config.packageIds.pvpCoinflip,
-          typeArguments: [normalizedCoinType],
-          arguments: [
-            createOptions.config.packageIds.sweetHouse,
-            betCoin,
-            createOptions.side === "tails",
-            Boolean(createOptions.isPrivate),
-            encodedMetadata.keys,
-            encodedMetadata.values
-          ]
-        })
-      );
-      return tx;
-    }
-    case "join": {
-      const joinOptions = options;
-      const priceInfoObjectId = resolvePriceInfoObjectId(
-        joinOptions.config,
-        normalizedCoinType
-      );
-      tx.add(
-        joinGame({
-          package: joinOptions.config.packageIds.pvpCoinflip,
-          typeArguments: [normalizedCoinType],
-          arguments: [
-            joinOptions.gameId,
-            joinOptions.config.packageIds.sweetHouse,
-            tx.add(joinOptions.betCoin),
-            encodedMetadata.keys,
-            encodedMetadata.values,
-            priceInfoObjectId
-          ]
-        })
-      );
-      return tx;
-    }
-    case "cancel": {
-      const cancelOptions = options;
-      tx.add(
-        cancelGame({
-          package: cancelOptions.config.packageIds.pvpCoinflip,
-          typeArguments: [normalizedCoinType],
-          arguments: [
-            cancelOptions.gameId,
-            cancelOptions.config.packageIds.sweetHouse
-          ]
-        })
-      );
-      return tx;
-    }
-    default:
-      throw new RangeError(`Unsupported PvP coinflip action: ${action}`);
-  }
-}
-var $moduleName18 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
-var I644 = new MoveStruct({
-  name: `${$moduleName18}::I64`,
-  fields: {
-    bits: bcs.bcs.u64()
-  }
-});
-
-// src/contracts/range/deps/0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc/float.ts
-var $moduleName19 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
-var Float4 = new MoveStruct({
-  name: `${$moduleName19}::Float`,
-  fields: {
-    is_negative: bcs.bcs.bool(),
-    exp: I644,
-    mant: bcs.bcs.u64()
-  }
-});
-
-// src/contracts/range/range.ts
-var $moduleName20 = "0x096a4cf18b3661e76b2c62b90785418345d52f45b272448794f123a4cb6b6416::range";
-var RangeSettingsKey = new MoveStruct({
-  name: `${$moduleName20}::RangeSettingsKey`,
-  fields: {
-    dummy_field: bcs.bcs.bool()
-  }
-});
-var Parameters5 = new MoveStruct({
-  name: `${$moduleName20}::Parameters<phantom T0>`,
-  fields: {
-    id: bcs.bcs.Address,
-    min_stake: bcs.bcs.u64(),
-    max_stake: bcs.bcs.u64(),
-    min_zone_size: bcs.bcs.u64(),
-    max_zone_size: bcs.bcs.u64(),
-    max_number_of_games: bcs.bcs.u64(),
-    min_rtp: Float4,
-    max_rtp: Float4
-  }
-});
-function play4(options) {
-  const packageAddress = options.package ?? "0x096a4cf18b3661e76b2c62b90785418345d52f45b272448794f123a4cb6b6416";
-  const argumentsTypes = [
-    null,
-    "u64",
-    null,
-    "u64",
-    "u64",
-    "u64",
-    "bool",
-    "vector<0x1::string::String>",
-    "vector<vector<u8>>",
-    null,
-    "0x2::clock::Clock",
-    "0x2::random::Random"
-  ];
-  return (tx) => tx.moveCall({
-    package: packageAddress,
-    module: "range",
-    function: "play",
-    arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
-    typeArguments: options.typeArguments
-  });
-}
-
-// src/transactions/range.ts
-function buildRangeTransaction(options) {
-  const scale = options.scale ?? DEFAULT_RANGE_SCALE;
-  const leftPoint = Math.round(options.leftPoint * scale);
-  const rightPoint = Math.round(options.rightPoint * scale);
-  return buildSharedStandardGameBetTransaction({
-    ...options,
-    game: "range",
-    buildRewardCoin: ({
-      tx,
-      config,
-      coinType,
-      stake,
-      betCount,
-      metadata,
-      priceInfoObjectId,
-      betCoin
-    }) => play4({
-      package: config.packageIds.range,
-      typeArguments: [coinType],
-      arguments: [
-        config.packageIds.sweetHouse,
-        stake,
-        betCoin,
-        betCount,
-        BigInt(leftPoint),
-        BigInt(rightPoint),
-        Boolean(options.outOfRange),
-        metadata.keys,
-        metadata.values,
-        priceInfoObjectId
-      ]
-    })(tx)
-  });
-}
-var $moduleName21 = "0x2::vec_map";
-function Entry4(...typeParameters) {
-  return new MoveStruct({
-    name: `${$moduleName21}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`,
-    fields: {
-      key: typeParameters[0],
-      value: typeParameters[1]
-    }
-  });
-}
-function VecMap4(...typeParameters) {
-  return new MoveStruct({
-    name: `${$moduleName21}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`,
-    fields: {
-      contents: bcs.bcs.vector(Entry4(typeParameters[0], typeParameters[1]))
-    }
-  });
-}
-var $moduleName22 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
-var I645 = new MoveStruct({
-  name: `${$moduleName22}::I64`,
-  fields: {
-    bits: bcs.bcs.u64()
-  }
-});
-
-// src/contracts/wheel/deps/0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc/float.ts
-var $moduleName23 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
-var Float5 = new MoveStruct({
-  name: `${$moduleName23}::Float`,
-  fields: {
-    is_negative: bcs.bcs.bool(),
-    exp: I645,
-    mant: bcs.bcs.u64()
-  }
-});
-
-// src/contracts/wheel/wheel.ts
-var $moduleName24 = "0x0997852ded7e13301c42317004bc49704a893aa82997c5706cebee59053a31b7::wheel";
-var WheelSettingsKey = new MoveStruct({
-  name: `${$moduleName24}::WheelSettingsKey`,
-  fields: {
-    dummy_field: bcs.bcs.bool()
-  }
-});
-var WheelConfig = new MoveStruct({
-  name: `${$moduleName24}::WheelConfig`,
-  fields: {
-    num_cases: bcs.bcs.u8(),
-    multipliers: bcs.bcs.vector(Float5),
-    min_stake: bcs.bcs.u64(),
-    max_stake: bcs.bcs.u64(),
-    is_playable: bcs.bcs.bool()
-  }
-});
-var Parameters6 = new MoveStruct({
-  name: `${$moduleName24}::Parameters<phantom T0>`,
-  fields: {
-    id: bcs.bcs.Address,
-    min_stake: bcs.bcs.u64(),
-    max_stake: bcs.bcs.u64(),
-    max_number_of_spins: bcs.bcs.u64(),
-    configs: VecMap4(bcs.bcs.u8(), WheelConfig)
-  }
-});
-function play5(options) {
-  const packageAddress = options.package ?? "0x0997852ded7e13301c42317004bc49704a893aa82997c5706cebee59053a31b7";
-  const argumentsTypes = [
-    null,
-    "u64",
-    null,
-    "u64",
-    "u8",
-    "vector<0x1::string::String>",
-    "vector<vector<u8>>",
-    null,
-    "0x2::clock::Clock",
-    "0x2::random::Random"
-  ];
-  return (tx) => tx.moveCall({
-    package: packageAddress,
-    module: "wheel",
-    function: "play",
-    arguments: normalizeMoveArguments(options.arguments, argumentsTypes),
-    typeArguments: options.typeArguments
-  });
-}
-
-// src/transactions/wheel.ts
-function buildWheelTransaction(options) {
-  const configId = toU8(options.configId);
-  return buildSharedStandardGameBetTransaction({
-    ...options,
-    game: "wheel",
-    buildRewardCoin: ({
-      tx,
-      config,
-      coinType,
-      stake,
-      betCount,
-      metadata,
-      priceInfoObjectId,
-      betCoin
-    }) => play5({
-      package: config.packageIds.wheel,
-      typeArguments: [coinType],
-      arguments: [
-        config.packageIds.sweetHouse,
-        stake,
-        betCoin,
-        betCount,
-        configId,
-        metadata.keys,
-        metadata.values,
-        priceInfoObjectId
-      ]
-    })(tx)
-  });
-}
-var TtlClientCache = class extends client.ClientCache {
-  #ttlMs;
-  constructor({ ttlMs, ...options }) {
-    super({
-      ...options,
-      prefix: options.prefix ?? ["ttl"]
-    });
-    this.#ttlMs = ttlMs;
-  }
-  read(key, load, options) {
-    if (options?.ignoreCache) {
-      super.clear(key);
-    }
-    if (this.#ttlMs <= 0) {
-      return load();
-    }
-    const cached = super.read(
-      key,
-      () => this.#loadEntry(key, load)
-    );
-    if (cached && cached.expiresAt > Date.now()) {
-      return cached.value;
-    }
-    super.clear(key);
-    return super.read(
-      key,
-      () => this.#loadEntry(key, load)
-    ).value;
-  }
-  readSync(key, load, options) {
-    if (options?.ignoreCache) {
-      super.clear(key);
-    }
-    if (this.#ttlMs <= 0) {
-      return load();
-    }
-    const cached = super.readSync(
-      key,
-      () => this.#loadSyncEntry(load)
-    );
-    if (cached.expiresAt > Date.now()) {
-      return cached.value;
-    }
-    super.clear(key);
-    return super.readSync(key, () => this.#loadSyncEntry(load)).value;
-  }
-  #loadEntry(key, load) {
-    const value = load();
-    const entry = {
-      value,
-      expiresAt: Date.now() + this.#ttlMs
-    };
-    if (isPromiseLike(value)) {
-      entry.value = Promise.resolve(value).then((resolved) => {
-        super.clear(key);
-        super.read(key, () => ({
-          value: resolved,
-          expiresAt: Date.now() + this.#ttlMs
-        }));
-        return resolved;
-      }).catch((error) => {
-        super.clear(key);
-        throw error;
-      });
-    }
-    return entry;
-  }
-  #loadSyncEntry(load) {
-    return {
-      value: load(),
-      expiresAt: Date.now() + this.#ttlMs
-    };
-  }
-};
-function isPromiseLike(value) {
-  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value;
-}
-
-// src/types/game-settings.type.ts
-var GAME_SETTINGS = {
-  coinflip: {
-    settingsKey: CoinFlipSettingsKey,
-    parameters: Parameters2
-  },
-  limbo: {
-    settingsKey: LimboSettingsKey,
-    parameters: Parameters3
-  },
-  plinko: {
-    settingsKey: PlinkoSettingsKey,
-    parameters: Parameters4
-  },
-  "pvp-coinflip": {
-    settingsKey: PvpCoinflipSettingsKey,
-    parameters: Parameters
-  },
-  range: {
-    settingsKey: RangeSettingsKey,
-    parameters: Parameters5
-  },
-  wheel: {
-    settingsKey: WheelSettingsKey,
-    parameters: Parameters6
-  }
-};
-
-// 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 ?? DEFAULT_CACHE_TTL_MS
-      });
-    });
-    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) {
-    const bytes = await transaction.build({ ...options, client: this.#client });
-    return utils.toBase64(bytes);
-  }
-  /**
-   * 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 = utils.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),
-          coinType: 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 = {
-    // Objects
-    /**
-     * Object representing the state of a PvP coinflip game, as stored on-chain.
-     */
-    PvPCoinflipGame: Game,
-    // Events
-    /**
-     * 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
-    );
-  }
-};
-
-exports.SuigarClient = SuigarClient;
-exports.suigar = suigar;