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

package/dist/index.cjs

@@ -3,153 +3,9 @@
 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/utils/config.ts
-
-// src/configs/package-id.ts
-var DEFAULT_SWEETHOUSE_PACKAGE_ID = "0xb7f64e5a273aba1ede00caa0a6f8027cc7490c279d17eab12e7100ed20660603";
-var DEFAULT_GAMES_PACKAGE_ID = {
-  coinflip: "0xb35c5f286c443752afc8ccb40125a578a4f32df35617170ccfa17fe180ab80ea",
-  limbo: "0x96c7841b9b32c59a219760fd656f1c3aceb53cc74a68ec9844a3a696374309f4",
-  plinko: "0xd3dd2200883af10811724f0bed97591ad155a02efd6332d471ff8b346030dfb7",
-  pvp_coinflip: "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202",
-  range: "0x096a4cf18b3661e76b2c62b90785418345d52f45b272448794f123a4cb6b6416",
-  wheel: "0x0997852ded7e13301c42317004bc49704a893aa82997c5706cebee59053a31b7"
-};
-
-// src/configs/usdc-coin-type.ts
-var DEFAULT_USDC_COIN_TYPE = "0xdba34672e30cb065b1f93e3a0e89fd79d1f22e12e55e88edbbcbac48609f4af0::usdc::USDC";
-var DEFAULT_USDC_FLOWX_COIN_TYPE = "0xbde4ba4c7f1193c4f1f5b9e8a9c1cdec42c6f3f3a73cf40e1f4cb12cc7e6a4c0::usdc::USDC";
-
-// src/utils/config.ts
-var trim = (value) => value?.trim() ?? "";
-function resolveSuigarConfig(options) {
-  const suiCoinType = utils.normalizeStructTag(
-    options.coinTypes?.sui ?? utils.SUI_TYPE_ARG
-  );
-  const usdcCoinType = utils.normalizeStructTag(
-    options.coinTypes?.usdc ?? DEFAULT_USDC_COIN_TYPE
-  );
-  const usdcFlowxCoinType = utils.normalizeStructTag(
-    options.coinTypes?.usdcFlowx ?? DEFAULT_USDC_FLOWX_COIN_TYPE
-  );
-  const explicitPriceInfoObjectIds = Object.fromEntries(
-    Object.entries(options.pyth?.priceInfoObjectIds ?? {}).map(
-      ([coinType, objectId]) => [utils.normalizeStructTag(coinType), objectId]
-    )
-  );
-  return {
-    sweetHousePackageId: trim(options.sweetHousePackageId) || trim(DEFAULT_SWEETHOUSE_PACKAGE_ID),
-    coinTypes: {
-      sui: suiCoinType,
-      usdc: usdcCoinType,
-      usdcFlowx: usdcFlowxCoinType
-    },
-    gamesPackageId: {
-      coinflip: trim(options.gamesPackageId?.coinflip) || DEFAULT_GAMES_PACKAGE_ID.coinflip,
-      limbo: trim(options.gamesPackageId?.limbo) || DEFAULT_GAMES_PACKAGE_ID.limbo,
-      plinko: trim(options.gamesPackageId?.plinko) || DEFAULT_GAMES_PACKAGE_ID.plinko,
-      "pvp-coinflip": trim(options.gamesPackageId?.["pvp-coinflip"]) || DEFAULT_GAMES_PACKAGE_ID.pvp_coinflip,
-      range: trim(options.gamesPackageId?.range) || DEFAULT_GAMES_PACKAGE_ID.range,
-      wheel: trim(options.gamesPackageId?.wheel) || DEFAULT_GAMES_PACKAGE_ID.wheel
-    },
-    pyth: {
-      packageId: trim(options.pyth?.packageId) || void 0,
-      suiPriceInfoObjectId: trim(options.pyth?.suiPriceInfoObjectId),
-      usdcPriceInfoObjectId: trim(options.pyth?.usdcPriceInfoObjectId),
-      priceInfoObjectIds: explicitPriceInfoObjectIds
-    }
-  };
-}
-function resolvePythPriceInfoObjectId(config, coinType) {
-  const normalizedCoinType = utils.normalizeStructTag(coinType);
-  const explicitObjectId = config.pyth.priceInfoObjectIds[normalizedCoinType];
-  if (explicitObjectId) {
-    return explicitObjectId;
-  }
-  if (normalizedCoinType === config.coinTypes.sui && config.pyth.suiPriceInfoObjectId) {
-    return config.pyth.suiPriceInfoObjectId;
-  }
-  if ((normalizedCoinType === config.coinTypes.usdc || normalizedCoinType === config.coinTypes.usdcFlowx) && config.pyth.usdcPriceInfoObjectId) {
-    return config.pyth.usdcPriceInfoObjectId;
-  }
-  throw new Error(
-    `Missing Pyth price object configuration for coin type ${coinType}`
-  );
-}
-function assertConfiguredBetGame(config, game) {
-  if (!config.gamesPackageId[game]) {
-    throw new Error(
-      `Missing required config for ${game}: gamesPackageId.${game}`
-    );
-  }
-}
-var ADDRESS_METADATA_KEYS = /* @__PURE__ */ new Set(["referrer", "partner"]);
-var textEncoder = new TextEncoder();
-var parseHexAddress = (value) => {
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  try {
-    const normalized = utils.normalizeSuiAddress(trimmed).slice(2);
-    const bytes = new Uint8Array(normalized.length / 2);
-    for (let index = 0; index < normalized.length; index += 2) {
-      bytes[index / 2] = Number.parseInt(
-        normalized.slice(index, index + 2),
-        16
-      );
-    }
-    return bytes;
-  } catch {
-    return null;
-  }
-};
-function encodeBetMetadata(metadata) {
-  const keys = [];
-  const values = [];
-  for (const [key, value] of Object.entries(metadata ?? {})) {
-    if (value === void 0 || value === null) {
-      continue;
-    }
-    let encodedValue;
-    if (value instanceof Uint8Array) {
-      encodedValue = Array.from(value);
-    } else if (Array.isArray(value)) {
-      encodedValue = value;
-    } else if (typeof value === "string" && ADDRESS_METADATA_KEYS.has(key)) {
-      encodedValue = Array.from(
-        parseHexAddress(value) ?? textEncoder.encode(value)
-      );
-    } else {
-      encodedValue = Array.from(textEncoder.encode(String(value)));
-    }
-    keys.push(key);
-    values.push(encodedValue);
-  }
-  return { keys, values };
-}
-
-// src/utils/shared.ts
-var DEFAULT_GAS_BUDGET_MIST = 5e7;
-var RANGE_FIXED_POINT_SCALE = 1e6;
-var LIMBO_MULTIPLIER_SCALE = 100;
-function toBigIntAmount(value, fieldName) {
-  if (typeof value === "bigint") {
-    if (value < 0n) {
-      throw new Error(`${fieldName} must be non-negative`);
-    }
-    return value;
-  }
-  if (!Number.isFinite(value) || value < 0) {
-    throw new Error(`${fieldName} must be a finite non-negative number`);
-  }
-  return BigInt(Math.trunc(value));
-}
-function toU8Number(value, fieldName) {
-  if (!Number.isInteger(value) || value < 0 || value > 255) {
-    throw new Error(`${fieldName} must be an integer between 0 and 255`);
-  }
-  return value;
-}
+// src/client.ts
 var MOVE_STDLIB_ADDRESS = utils.normalizeSuiAddress("0x1");
 var SUI_FRAMEWORK_ADDRESS = utils.normalizeSuiAddress("0x2");
 function getPureBcsSchema(typeTag) {
@@ -181,7 +37,8 @@ function getPureBcsSchema(typeTag) {
         return bcs.bcs.String;
       }
       if (structTag.module === "option" && structTag.name === "Option") {
-        const type = getPureBcsSchema(structTag.typeParams[0]);
+        const inner = structTag.typeParams[0];
+        const type = inner ? getPureBcsSchema(inner) : null;
         return type ? bcs.bcs.option(type) : null;
       }
     }
@@ -195,7 +52,7 @@ function normalizeMoveArguments(args, argTypes, parameterNames) {
   Array.isArray(args) ? args.length : Object.keys(args).length;
   const normalizedArgs = [];
   let index = 0;
-  for (const [i, argType] of argTypes.entries()) {
+  for (const argType of argTypes) {
     if (argType === "0x2::clock::Clock") {
       normalizedArgs.push((tx) => tx.object.clock());
       continue;
@@ -230,8 +87,7 @@ function normalizeMoveArguments(args, argTypes, parameterNames) {
       normalizedArgs.push(arg);
       continue;
     }
-    const type = argTypes[i];
-    const bcsType = type === null ? null : getPureBcsSchema(type);
+    const bcsType = argType === null ? null : getPureBcsSchema(argType);
     if (bcsType) {
       const bytes = bcsType.serialize(arg);
       normalizedArgs.push((tx) => tx.pure(bytes));
@@ -241,7 +97,7 @@ function normalizeMoveArguments(args, argTypes, parameterNames) {
       normalizedArgs.push((tx) => tx.object(arg));
       continue;
     }
-    throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
+    throw new Error(`Invalid argument ${stringify(arg)} for type ${argType}`);
   }
   return normalizedArgs;
 }
@@ -254,6 +110,9 @@ var MoveStruct = class extends bcs.BcsStruct {
       ...options,
       objectIds: [objectId]
     });
+    if (!res) {
+      throw new Error(`No object found for id ${objectId}`);
+    }
     return res;
   }
   async getMany({
@@ -287,8 +146,429 @@ function stringify(val) {
   }
   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/coinflip/coinflip.ts
+// 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 Error(
+      `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 = [
@@ -311,39 +591,105 @@ function play(options) {
     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 Error(`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 Error(`Unable to parse coin type from ${type}`);
+  }
+  return utils.normalizeStructTag(coinType);
+}
+
+// src/transactions/shared.ts
 function createBaseGameTransaction({
   config,
   game,
-  owner,
-  sender,
+  playerAddress,
   gasBudget
 }) {
   assertConfiguredBetGame(config, game);
   const tx = new transactions.Transaction();
-  tx.setSenderIfNotSet(utils.normalizeSuiAddress(sender ?? owner));
+  tx.setSenderIfNotSet(utils.normalizeSuiAddress(playerAddress));
   tx.setGasBudgetIfNotSet(gasBudget ?? DEFAULT_GAS_BUDGET_MIST);
   return tx;
 }
 function buildSharedStandardGameBetCall({
   config,
-  owner,
-  sender,
+  playerAddress,
   coinType,
   stake,
   cashStake,
   betCount,
   metadata,
+  partner,
   allowGasCoinShortcut = true,
   buildRewardCoin
 }) {
   return (tx) => {
-    const normalizedOwner = utils.normalizeSuiAddress(sender ?? owner);
+    const normalizedPlayerAddress = utils.normalizeSuiAddress(playerAddress);
     const normalizedCoinType = utils.normalizeStructTag(coinType);
-    const resolvedStake = toBigIntAmount(stake, "stake");
-    const resolvedCashStake = toBigIntAmount(cashStake ?? stake, "cashStake");
-    const resolvedBetCount = toBigIntAmount(betCount ?? 1, "betCount");
-    const encodedMetadata = encodeBetMetadata(metadata);
-    const pythPriceInfoObjectId = resolvePythPriceInfoObjectId(
+    const resolvedStake = toBigInt(stake);
+    const resolvedCashStake = toBigInt(cashStake ?? stake);
+    const resolvedBetCount = toBigInt(betCount ?? 1);
+    const encodedMetadata = encodeBetMetadata(metadata, partner);
+    const priceInfoObjectId = resolvePriceInfoObjectId(
       config,
       normalizedCoinType
     );
@@ -355,16 +701,16 @@ function buildSharedStandardGameBetCall({
     const rewardCoin = buildRewardCoin({
       tx,
       config,
-      owner: normalizedOwner,
+      playerAddress: normalizedPlayerAddress,
       coinType: normalizedCoinType,
       stake: resolvedStake,
       cashStake: resolvedCashStake,
       betCount: resolvedBetCount,
       metadata: encodedMetadata,
-      pythPriceInfoObjectId,
+      priceInfoObjectId,
       betCoin
     });
-    tx.transferObjects([rewardCoin], tx.pure.address(normalizedOwner));
+    tx.transferObjects([rewardCoin], tx.pure.address(normalizedPlayerAddress));
     return rewardCoin;
   };
 }
@@ -386,26 +732,65 @@ function buildCoinflipTransaction(options) {
       stake,
       betCount,
       metadata,
-      pythPriceInfoObjectId,
+      priceInfoObjectId,
       betCoin
     }) => play({
-      package: config.gamesPackageId.coinflip,
+      package: config.packageIds.coinflip,
       typeArguments: [coinType],
       arguments: [
-        config.sweetHousePackageId,
+        config.packageIds.sweetHouse,
         stake,
         betCoin,
         betCount,
         options.side === "tails",
         metadata.keys,
         metadata.values,
-        pythPriceInfoObjectId
+        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 = [
@@ -432,7 +817,7 @@ function play2(options) {
 
 // src/transactions/limbo.ts
 function buildLimboTransaction(options) {
-  const scale = options.scale ?? LIMBO_MULTIPLIER_SCALE;
+  const scale = options.scale ?? DEFAULT_LIMBO_MULTIPLIER_SCALE;
   const numerator = Math.round(options.targetMultiplier * scale);
   return buildSharedStandardGameBetTransaction({
     ...options,
@@ -444,13 +829,13 @@ function buildLimboTransaction(options) {
       stake,
       betCount,
       metadata,
-      pythPriceInfoObjectId,
+      priceInfoObjectId,
       betCoin
     }) => play2({
-      package: config.gamesPackageId.limbo,
+      package: config.packageIds.limbo,
       typeArguments: [coinType],
       arguments: [
-        config.sweetHousePackageId,
+        config.packageIds.sweetHouse,
         stake,
         betCoin,
         betCount,
@@ -458,13 +843,76 @@ function buildLimboTransaction(options) {
         BigInt(scale),
         metadata.keys,
         metadata.values,
-        pythPriceInfoObjectId
+        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 = [
@@ -490,7 +938,7 @@ function play3(options) {
 
 // src/transactions/plinko.ts
 function buildPlinkoTransaction(options) {
-  const configId = toU8Number(options.configId, "configId");
+  const configId = toU8(options.configId);
   return buildSharedStandardGameBetTransaction({
     ...options,
     game: "plinko",
@@ -501,134 +949,35 @@ function buildPlinkoTransaction(options) {
       stake,
       betCount,
       metadata,
-      pythPriceInfoObjectId,
+      priceInfoObjectId,
       betCoin
     }) => play3({
-      package: config.gamesPackageId.plinko,
+      package: config.packageIds.plinko,
       typeArguments: [coinType],
       arguments: [
-        config.sweetHousePackageId,
+        config.packageIds.sweetHouse,
         stake,
         betCoin,
         betCount,
         configId,
         metadata.keys,
         metadata.values,
-        pythPriceInfoObjectId
+        priceInfoObjectId
       ]
     })(tx)
   });
 }
-var $moduleName = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
-var TypeName = new MoveStruct({ name: `${$moduleName}::TypeName`, fields: {
-  name: bcs.bcs.string()
-} });
-
-// src/contracts/pvp-coinflip/pvp_coinflip.ts
-var $moduleName2 = "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip";
-function GameCreatedEvent(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName2}::GameCreatedEvent<${typeParameters[0].name}>`, 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: TypeName
-  } });
-}
-function GameResolvedEvent(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName2}::GameResolvedEvent<${typeParameters[0].name}>`, 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: TypeName
-  } });
-}
-function GameCancelledEvent(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName2}::GameCancelledEvent<${typeParameters[0].name}>`, 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: TypeName
-  } });
-}
-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/transactions/pvp-coinflip.ts
 function buildPvPCoinflipTransaction(action, options) {
   const tx = createBaseGameTransaction({
     ...options,
     game: "pvp-coinflip"
   });
   const normalizedCoinType = utils.normalizeStructTag(options.coinType);
-  const encodedMetadata = encodeBetMetadata(options.metadata);
+  const encodedMetadata = encodeBetMetadata(options.metadata, options.partner);
   switch (action) {
     case "create": {
       const createOptions = options;
-      const stake = toBigIntAmount(createOptions.stake, "stake");
+      const stake = toBigInt(createOptions.stake);
       const betCoin = tx.coin({
         type: normalizedCoinType,
         balance: stake,
@@ -636,10 +985,10 @@ function buildPvPCoinflipTransaction(action, options) {
       });
       tx.add(
         createGame({
-          package: createOptions.config.gamesPackageId["pvp-coinflip"],
+          package: createOptions.config.packageIds.pvpCoinflip,
           typeArguments: [normalizedCoinType],
           arguments: [
-            createOptions.config.sweetHousePackageId,
+            createOptions.config.packageIds.sweetHouse,
             betCoin,
             createOptions.side === "tails",
             Boolean(createOptions.isPrivate),
@@ -652,23 +1001,21 @@ function buildPvPCoinflipTransaction(action, options) {
     }
     case "join": {
       const joinOptions = options;
-      const stake = toBigIntAmount(joinOptions.stake, "stake");
-      const betCoin = tx.coin({
-        type: normalizedCoinType,
-        balance: stake,
-        useGasCoin: joinOptions.allowGasCoinShortcut
-      });
+      const priceInfoObjectId = resolvePriceInfoObjectId(
+        joinOptions.config,
+        normalizedCoinType
+      );
       tx.add(
         joinGame({
-          package: joinOptions.config.gamesPackageId["pvp-coinflip"],
+          package: joinOptions.config.packageIds.pvpCoinflip,
           typeArguments: [normalizedCoinType],
           arguments: [
             joinOptions.gameId,
-            joinOptions.config.sweetHousePackageId,
-            betCoin,
+            joinOptions.config.packageIds.sweetHouse,
+            tx.add(joinOptions.betCoin),
             encodedMetadata.keys,
             encodedMetadata.values,
-            joinOptions.extraObjectId
+            priceInfoObjectId
           ]
         })
       );
@@ -678,11 +1025,11 @@ function buildPvPCoinflipTransaction(action, options) {
       const cancelOptions = options;
       tx.add(
         cancelGame({
-          package: cancelOptions.config.gamesPackageId["pvp-coinflip"],
+          package: cancelOptions.config.packageIds.pvpCoinflip,
           typeArguments: [normalizedCoinType],
           arguments: [
             cancelOptions.gameId,
-            cancelOptions.config.sweetHousePackageId
+            cancelOptions.config.packageIds.sweetHouse
           ]
         })
       );
@@ -692,8 +1039,46 @@ function buildPvPCoinflipTransaction(action, options) {
       throw new Error(`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 = [
@@ -721,7 +1106,7 @@ function play4(options) {
 
 // src/transactions/range.ts
 function buildRangeTransaction(options) {
-  const scale = options.scale ?? RANGE_FIXED_POINT_SCALE;
+  const scale = options.scale ?? DEFAULT_RANGE_SCALE;
   const leftPoint = Math.round(options.leftPoint * scale);
   const rightPoint = Math.round(options.rightPoint * scale);
   return buildSharedStandardGameBetTransaction({
@@ -734,13 +1119,13 @@ function buildRangeTransaction(options) {
       stake,
       betCount,
       metadata,
-      pythPriceInfoObjectId,
+      priceInfoObjectId,
       betCoin
     }) => play4({
-      package: config.gamesPackageId.range,
+      package: config.packageIds.range,
       typeArguments: [coinType],
       arguments: [
-        config.sweetHousePackageId,
+        config.packageIds.sweetHouse,
         stake,
         betCoin,
         betCount,
@@ -749,13 +1134,76 @@ function buildRangeTransaction(options) {
         Boolean(options.outOfRange),
         metadata.keys,
         metadata.values,
-        pythPriceInfoObjectId
+        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 = [
@@ -781,7 +1229,7 @@ function play5(options) {
 
 // src/transactions/wheel.ts
 function buildWheelTransaction(options) {
-  const configId = toU8Number(options.configId, "configId");
+  const configId = toU8(options.configId);
   return buildSharedStandardGameBetTransaction({
     ...options,
     game: "wheel",
@@ -792,87 +1240,183 @@ function buildWheelTransaction(options) {
       stake,
       betCount,
       metadata,
-      pythPriceInfoObjectId,
+      priceInfoObjectId,
       betCoin
     }) => play5({
-      package: config.gamesPackageId.wheel,
+      package: config.packageIds.wheel,
       typeArguments: [coinType],
       arguments: [
-        config.sweetHousePackageId,
+        config.packageIds.sweetHouse,
         stake,
         betCoin,
         betCount,
         configId,
         metadata.keys,
         metadata.values,
-        pythPriceInfoObjectId
+        priceInfoObjectId
       ]
     })(tx)
   });
 }
-var $moduleName3 = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
-var TypeName2 = new MoveStruct({ name: `${$moduleName3}::TypeName`, fields: {
-  name: bcs.bcs.string()
-} });
-var $moduleName4 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
-var I64 = new MoveStruct({ name: `${$moduleName4}::I64`, fields: {
-  bits: bcs.bcs.u64()
-} });
-
-// src/contracts/core/float.ts
-var $moduleName5 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
-var Float = new MoveStruct({ name: `${$moduleName5}::Float`, fields: {
-  is_negative: bcs.bcs.bool(),
-  exp: I64,
-  mant: bcs.bcs.u64()
-} });
-var $moduleName6 = "0x2::vec_map";
-function Entry(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName6}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
-    key: typeParameters[0],
-    value: typeParameters[1]
-  } });
-}
-function VecMap(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName6}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
-    contents: bcs.bcs.vector(Entry(typeParameters[0], typeParameters[1]))
-  } });
+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/contracts/core/core.ts
-var $moduleName7 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::core";
-function BetResultEvent(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName7}::BetResultEvent<${typeParameters[0].name}>`, fields: {
-    player: bcs.bcs.Address,
-    coin_type: TypeName2,
-    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()))
-  } });
-}
+// 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",
-  ...options
+  partner,
+  cacheTtl
 } = {}) {
   return {
     name,
     register: (client) => {
-      return new SuigarClient({ client, options });
+      return new SuigarClient({
+        client,
+        name: String(name),
+        partner,
+        cacheTtl
+      });
     }
   };
 }
 var SuigarClient = class {
   #client;
   #config;
+  #partner;
+  #cache;
   constructor({
     client,
-    options
+    name,
+    partner,
+    cacheTtl
   }) {
     this.#client = client;
-    this.#config = resolveSuigarConfig(options);
+    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 Error(`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.
@@ -890,9 +1434,144 @@ var SuigarClient = class {
     return utils.toBase64(bytes);
   }
   /**
-   * BCS struct constructors for decoding Suigar events emitted on-chain.
+   * 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 onchain 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 onchain 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]
+    );
+  }
+  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
+    );
+  }
+  /**
+   * 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.
      */
@@ -900,15 +1579,15 @@ var SuigarClient = class {
     /**
      * Event emitted when a PvP Coinflip game is created, containing the game configuration and initial state.
      */
-    PvPCoinflipGameCreated: GameCreatedEvent,
+    PvPCoinflipGameCreatedEvent: GameCreatedEvent,
     /**
      * Event emitted when a PvP Coinflip game is resolved, containing the final outcome.
      */
-    PvPCoinflipGameResolved: GameResolvedEvent,
+    PvPCoinflipGameResolvedEvent: GameResolvedEvent,
     /**
      * Event emitted when a PvP Coinflip game is cancelled.
      */
-    PvPCoinflipGameCancelled: GameCancelledEvent
+    PvPCoinflipGameCancelledEvent: GameCancelledEvent
   };
   /**
    * Transaction builders for Suigar games.
@@ -926,27 +1605,32 @@ var SuigarClient = class {
         case "coinflip":
           return buildCoinflipTransaction({
             ...options,
-            config: this.#config
+            config: this.#config,
+            partner: this.#partner
           });
         case "limbo":
           return buildLimboTransaction({
             ...options,
-            config: this.#config
+            config: this.#config,
+            partner: this.#partner
           });
         case "plinko":
           return buildPlinkoTransaction({
             ...options,
-            config: this.#config
+            config: this.#config,
+            partner: this.#partner
           });
         case "range":
           return buildRangeTransaction({
             ...options,
-            config: this.#config
+            config: this.#config,
+            partner: this.#partner
           });
         case "wheel":
           return buildWheelTransaction({
             ...options,
-            config: this.#config
+            config: this.#config,
+            partner: this.#partner
           });
         default:
           throw new Error(`Unsupported game: ${gameId}`);
@@ -960,12 +1644,47 @@ var SuigarClient = class {
      * @returns Prepared PvP coinflip transaction.
      */
     createPvPCoinflipTransaction: (action, options) => {
-      return buildPvPCoinflipTransaction(action, {
-        ...options,
-        config: this.#config
-      });
+      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 Error(`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
+      });
+    };
+  }
 };
 
+exports.SuigarClient = SuigarClient;
 exports.suigar = suigar;