@suigar/sdk 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/index.cjs

@@ -1,1016 +0,0 @@
-'use strict';
-
-var utils = require('@mysten/sui/utils');
-var bcs = require('@mysten/sui/bcs');
-var transactions = require('@mysten/sui/transactions');
-
-// src/types/network.type.ts
-var SUPPORTED_SUI_NETWORKS = [
-  "mainnet",
-  "testnet"
-];
-
-// 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/utils/config.ts
-function resolveSuigarConfig(network) {
-  const packageIds = PACKAGE_IDS[network];
-  const coinTypes = COIN_TYPES[network];
-  const priceInfoObjectIds = PRICE_INFO_OBJECT_IDS[network];
-  return {
-    packageIds: { ...packageIds },
-    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) {
-    return objectId;
-  }
-  throw new Error(
-    `Missing price info object configuration for coin type ${coinType}`
-  );
-}
-function resolveSupportedCoin(config, coinType) {
-  const entries = Object.entries(config.coinTypes);
-  const supportedCoin = entries.find(
-    ([, configuredCoinType]) => configuredCoinType === coinType
-  )?.[0];
-  if (supportedCoin) {
-    return supportedCoin;
-  }
-  throw new Error(
-    `Unsupported coin type ${coinType}. Supported coin types: ${entries.map(([, configuredCoinType]) => configuredCoinType).join(", ")}`
-  );
-}
-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;
-}
-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 type = getPureBcsSchema(structTag.typeParams[0]);
-        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 [i, argType] of argTypes.entries()) {
-    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 type = argTypes[i];
-    const bcsType = type === null ? null : getPureBcsSchema(type);
-    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 ${type}`);
-  }
-  return normalizedArgs;
-}
-var MoveStruct = class extends bcs.BcsStruct {
-  async get({
-    objectId,
-    ...options
-  }) {
-    const [res] = await this.getMany({
-      ...options,
-      objectIds: [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;
-}
-
-// src/contracts/coinflip/coinflip.ts
-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
-  });
-}
-function createBaseGameTransaction({
-  config,
-  game,
-  owner,
-  sender,
-  gasBudget
-}) {
-  assertConfiguredBetGame(config, game);
-  const tx = new transactions.Transaction();
-  tx.setSenderIfNotSet(utils.normalizeSuiAddress(sender ?? owner));
-  tx.setGasBudgetIfNotSet(gasBudget ?? DEFAULT_GAS_BUDGET_MIST);
-  return tx;
-}
-function buildSharedStandardGameBetCall({
-  config,
-  owner,
-  sender,
-  coinType,
-  stake,
-  cashStake,
-  betCount,
-  metadata,
-  allowGasCoinShortcut = true,
-  buildRewardCoin
-}) {
-  return (tx) => {
-    const normalizedOwner = utils.normalizeSuiAddress(sender ?? owner);
-    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 priceInfoObjectId = resolvePriceInfoObjectId(
-      config,
-      normalizedCoinType
-    );
-    const betCoin = tx.coin({
-      type: normalizedCoinType,
-      balance: resolvedCashStake,
-      useGasCoin: allowGasCoinShortcut
-    });
-    const rewardCoin = buildRewardCoin({
-      tx,
-      config,
-      owner: normalizedOwner,
-      coinType: normalizedCoinType,
-      stake: resolvedStake,
-      cashStake: resolvedCashStake,
-      betCount: resolvedBetCount,
-      metadata: encodedMetadata,
-      priceInfoObjectId,
-      betCoin
-    });
-    tx.transferObjects([rewardCoin], tx.pure.address(normalizedOwner));
-    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)
-  });
-}
-
-// src/contracts/limbo/limbo.ts
-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 ?? 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)
-  });
-}
-
-// src/contracts/plinko/plinko.ts
-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 = toU8Number(options.configId, "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)
-  });
-}
-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";
-var GameCreatedEvent = new MoveStruct({ name: `${$moduleName2}::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: TypeName
-} });
-var GameResolvedEvent = new MoveStruct({ name: `${$moduleName2}::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: TypeName
-} });
-var GameCancelledEvent = new MoveStruct({ name: `${$moduleName2}::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: 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);
-  switch (action) {
-    case "create": {
-      const createOptions = options;
-      const stake = toBigIntAmount(createOptions.stake, "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 stake = toBigIntAmount(joinOptions.stake, "stake");
-      const betCoin = tx.coin({
-        type: normalizedCoinType,
-        balance: stake,
-        useGasCoin: joinOptions.allowGasCoinShortcut
-      });
-      tx.add(
-        joinGame({
-          package: joinOptions.config.packageIds.pvpCoinflip,
-          typeArguments: [normalizedCoinType],
-          arguments: [
-            joinOptions.gameId,
-            joinOptions.config.packageIds.sweetHouse,
-            betCoin,
-            encodedMetadata.keys,
-            encodedMetadata.values,
-            joinOptions.extraObjectId
-          ]
-        })
-      );
-      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 Error(`Unsupported PvP coinflip action: ${action}`);
-  }
-}
-
-// src/contracts/range/range.ts
-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 ?? RANGE_FIXED_POINT_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)
-  });
-}
-
-// src/contracts/wheel/wheel.ts
-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 = toU8Number(options.configId, "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 $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]))
-  } });
-}
-
-// src/contracts/core/core.ts
-var $moduleName7 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::core";
-var BetResultEvent = new MoveStruct({ name: `${$moduleName7}::BetResultEvent<phantom T0>`, 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()))
-} });
-function suigar({
-  name = "suigar"
-} = {}) {
-  return {
-    name,
-    register: (client) => {
-      return new SuigarClient({ client });
-    }
-  };
-}
-var SuigarClient = class {
-  #client;
-  #config;
-  constructor({ client }) {
-    this.#client = client;
-    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,
-   * 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);
-  }
-  /**
-   * BCS struct constructors for decoding Suigar events emitted on-chain.
-   */
-  bcs = {
-    /**
-     * 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.
-     */
-    PvPCoinflipGameCreated: GameCreatedEvent,
-    /**
-     * Event emitted when a PvP Coinflip game is resolved, containing the final outcome.
-     */
-    PvPCoinflipGameResolved: GameResolvedEvent,
-    /**
-     * Event emitted when a PvP Coinflip game is cancelled.
-     */
-    PvPCoinflipGameCancelled: 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
-          });
-        case "limbo":
-          return buildLimboTransaction({
-            ...options,
-            config: this.#config
-          });
-        case "plinko":
-          return buildPlinkoTransaction({
-            ...options,
-            config: this.#config
-          });
-        case "range":
-          return buildRangeTransaction({
-            ...options,
-            config: this.#config
-          });
-        case "wheel":
-          return buildWheelTransaction({
-            ...options,
-            config: this.#config
-          });
-        default:
-          throw new Error(`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) => {
-      return buildPvPCoinflipTransaction(action, {
-        ...options,
-        config: this.#config
-      });
-    }
-  };
-};
-
-exports.suigar = suigar;