@suigar/sdk 2.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,966 @@
+import { normalizeSuiAddress, normalizeStructTag, SUI_TYPE_ARG } from '@mysten/sui/utils';
+import { bcs, BcsStruct, TypeTagSerializer } from '@mysten/sui/bcs';
+import { Transaction, isArgument } from '@mysten/sui/transactions';
+
+// 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 = normalizeStructTag(
+    options.coinTypes?.sui ?? SUI_TYPE_ARG
+  );
+  const usdcCoinType = normalizeStructTag(
+    options.coinTypes?.usdc ?? DEFAULT_USDC_COIN_TYPE
+  );
+  const usdcFlowxCoinType = normalizeStructTag(
+    options.coinTypes?.usdcFlowx ?? DEFAULT_USDC_FLOWX_COIN_TYPE
+  );
+  const explicitPriceInfoObjectIds = Object.fromEntries(
+    Object.entries(options.pyth?.priceInfoObjectIds ?? {}).map(
+      ([coinType, objectId]) => [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 = 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 = 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 = normalizeSuiAddress("0x1");
+var SUI_FRAMEWORK_ADDRESS = normalizeSuiAddress("0x2");
+function getPureBcsSchema(typeTag) {
+  const parsedTag = typeof typeTag === "string" ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+  if ("u8" in parsedTag) {
+    return bcs.U8;
+  } else if ("u16" in parsedTag) {
+    return bcs.U16;
+  } else if ("u32" in parsedTag) {
+    return bcs.U32;
+  } else if ("u64" in parsedTag) {
+    return bcs.U64;
+  } else if ("u128" in parsedTag) {
+    return bcs.U128;
+  } else if ("u256" in parsedTag) {
+    return bcs.U256;
+  } else if ("address" in parsedTag) {
+    return bcs.Address;
+  } else if ("bool" in parsedTag) {
+    return bcs.Bool;
+  } else if ("vector" in parsedTag) {
+    const type = getPureBcsSchema(parsedTag.vector);
+    return type ? bcs.vector(type) : null;
+  } else if ("struct" in parsedTag) {
+    const structTag = parsedTag.struct;
+    const pkg = normalizeSuiAddress(structTag.address);
+    if (pkg === MOVE_STDLIB_ADDRESS) {
+      if ((structTag.module === "ascii" || structTag.module === "string") && structTag.name === "String") {
+        return bcs.String;
+      }
+      if (structTag.module === "option" && structTag.name === "Option") {
+        const type = getPureBcsSchema(structTag.typeParams[0]);
+        return type ? bcs.option(type) : null;
+      }
+    }
+    if (pkg === SUI_FRAMEWORK_ADDRESS && structTag.module === "object" && (structTag.name === "ID" || structTag.name === "UID")) {
+      return 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" || 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 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 Transaction();
+  tx.setSenderIfNotSet(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 = normalizeSuiAddress(sender ?? owner);
+    const normalizedCoinType = 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(
+      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,
+      pythPriceInfoObjectId,
+      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,
+      pythPriceInfoObjectId,
+      betCoin
+    }) => play({
+      package: config.gamesPackageId.coinflip,
+      typeArguments: [coinType],
+      arguments: [
+        config.sweetHousePackageId,
+        stake,
+        betCoin,
+        betCount,
+        options.side === "tails",
+        metadata.keys,
+        metadata.values,
+        pythPriceInfoObjectId
+      ]
+    })(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,
+      pythPriceInfoObjectId,
+      betCoin
+    }) => play2({
+      package: config.gamesPackageId.limbo,
+      typeArguments: [coinType],
+      arguments: [
+        config.sweetHousePackageId,
+        stake,
+        betCoin,
+        betCount,
+        BigInt(numerator),
+        BigInt(scale),
+        metadata.keys,
+        metadata.values,
+        pythPriceInfoObjectId
+      ]
+    })(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,
+      pythPriceInfoObjectId,
+      betCoin
+    }) => play3({
+      package: config.gamesPackageId.plinko,
+      typeArguments: [coinType],
+      arguments: [
+        config.sweetHousePackageId,
+        stake,
+        betCoin,
+        betCount,
+        configId,
+        metadata.keys,
+        metadata.values,
+        pythPriceInfoObjectId
+      ]
+    })(tx)
+  });
+}
+var $moduleName = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
+var TypeName = new MoveStruct({ name: `${$moduleName}::TypeName`, fields: {
+  name: 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.Address,
+    creator: bcs.Address,
+    creator_is_tails: bcs.bool(),
+    is_private: bcs.bool(),
+    joiner_is_tails: bcs.bool(),
+    stake_per_player: bcs.u64(),
+    house_edge_bps: bcs.u64(),
+    coin_type: TypeName
+  } });
+}
+function GameResolvedEvent(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName2}::GameResolvedEvent<${typeParameters[0].name}>`, fields: {
+    game_id: bcs.Address,
+    creator: bcs.Address,
+    joiner: bcs.Address,
+    winner: bcs.Address,
+    creator_is_tails: bcs.bool(),
+    is_private: bcs.bool(),
+    joiner_is_tails: bcs.bool(),
+    stake_per_player: bcs.u64(),
+    total_pot: bcs.u64(),
+    house_edge_amount: bcs.u64(),
+    payout_amount: bcs.u64(),
+    coin_type: TypeName
+  } });
+}
+function GameCancelledEvent(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName2}::GameCancelledEvent<${typeParameters[0].name}>`, fields: {
+    game_id: bcs.Address,
+    creator: bcs.Address,
+    creator_is_tails: bcs.bool(),
+    is_private: bcs.bool(),
+    stake_per_player: 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 = 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.gamesPackageId["pvp-coinflip"],
+          typeArguments: [normalizedCoinType],
+          arguments: [
+            createOptions.config.sweetHousePackageId,
+            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.gamesPackageId["pvp-coinflip"],
+          typeArguments: [normalizedCoinType],
+          arguments: [
+            joinOptions.gameId,
+            joinOptions.config.sweetHousePackageId,
+            betCoin,
+            encodedMetadata.keys,
+            encodedMetadata.values,
+            joinOptions.extraObjectId
+          ]
+        })
+      );
+      return tx;
+    }
+    case "cancel": {
+      const cancelOptions = options;
+      tx.add(
+        cancelGame({
+          package: cancelOptions.config.gamesPackageId["pvp-coinflip"],
+          typeArguments: [normalizedCoinType],
+          arguments: [
+            cancelOptions.gameId,
+            cancelOptions.config.sweetHousePackageId
+          ]
+        })
+      );
+      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,
+      pythPriceInfoObjectId,
+      betCoin
+    }) => play4({
+      package: config.gamesPackageId.range,
+      typeArguments: [coinType],
+      arguments: [
+        config.sweetHousePackageId,
+        stake,
+        betCoin,
+        betCount,
+        BigInt(leftPoint),
+        BigInt(rightPoint),
+        Boolean(options.outOfRange),
+        metadata.keys,
+        metadata.values,
+        pythPriceInfoObjectId
+      ]
+    })(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,
+      pythPriceInfoObjectId,
+      betCoin
+    }) => play5({
+      package: config.gamesPackageId.wheel,
+      typeArguments: [coinType],
+      arguments: [
+        config.sweetHousePackageId,
+        stake,
+        betCoin,
+        betCount,
+        configId,
+        metadata.keys,
+        metadata.values,
+        pythPriceInfoObjectId
+      ]
+    })(tx)
+  });
+}
+var $moduleName3 = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
+var TypeName2 = new MoveStruct({ name: `${$moduleName3}::TypeName`, fields: {
+  name: bcs.string()
+} });
+var $moduleName4 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
+var I64 = new MoveStruct({ name: `${$moduleName4}::I64`, fields: {
+  bits: bcs.u64()
+} });
+
+// src/contracts/core/float.ts
+var $moduleName5 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
+var Float = new MoveStruct({ name: `${$moduleName5}::Float`, fields: {
+  is_negative: bcs.bool(),
+  exp: I64,
+  mant: 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.vector(Entry(typeParameters[0], typeParameters[1]))
+  } });
+}
+
+// src/contracts/core/core.ts
+var $moduleName7 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::core";
+function BetResultEvent(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName7}::BetResultEvent<${typeParameters[0].name}>`, fields: {
+    player: bcs.Address,
+    coin_type: TypeName2,
+    stake_amount: bcs.u64(),
+    unsafe_oracle_usd_coin_price: Float,
+    adjusted_oracle_usd_coin_price: Float,
+    outcome_amount: bcs.u64(),
+    game_details: VecMap(bcs.string(), bcs.vector(bcs.u8())),
+    metadata: VecMap(bcs.string(), bcs.vector(bcs.u8()))
+  } });
+}
+
+// src/client.ts
+function suigar({
+  name = "suigar",
+  ...options
+} = {}) {
+  return {
+    name,
+    register: (client) => {
+      return new SuigarClient({ client, options });
+    }
+  };
+}
+var SuigarClient = class {
+  #client;
+  #config;
+  constructor({
+    client,
+    options
+  }) {
+    this.#client = client;
+    this.#config = resolveSuigarConfig(options);
+  }
+  /**
+   * Builds a transaction with the configured Sui client and returns the BCS bytes as a base64 string.
+   *
+   * @param transaction Transaction block to serialize.
+   * @returns Base64-encoded transaction bytes ready to send over the wire.
+   */
+  async serializeTransactionToBase64(transaction) {
+    const bytes = await transaction.build({ client: this.#client });
+    return Buffer.from(bytes).toString("base64");
+  }
+  /**
+   * 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
+      });
+    }
+  };
+};
+
+export { SuigarClient, suigar };