@suigar/sdk 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/index.js

@@ -1,289 +1,365 @@
-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';
+import { MoveStruct, Float, parseCoinType, toBigInt, toU8, DEFAULT_GAS_BUDGET_MIST, normalizeMoveArguments, DEFAULT_LIMBO_MULTIPLIER_SCALE, DEFAULT_RANGE_SCALE } from './chunk-PPUDLRHA.js';
+import { toBase64, normalizeStructTag, normalizeSuiAddress, fromHex } from '@mysten/sui/utils';
+import { bcs } from '@mysten/sui/bcs';
+import { Transaction } from '@mysten/sui/transactions';
 
-// src/utils/config.ts
+var $moduleName = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
+var TypeName = new MoveStruct({
+  name: `${$moduleName}::TypeName`,
+  fields: {
+    name: 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.vector(Entry(typeParameters[0], typeParameters[1]))
+    }
+  });
+}
 
-// src/configs/package-id.ts
-var DEFAULT_SWEETHOUSE_PACKAGE_ID = "0xb7f64e5a273aba1ede00caa0a6f8027cc7490c279d17eab12e7100ed20660603";
-var DEFAULT_GAMES_PACKAGE_ID = {
+// src/contracts/core/core.ts
+var $moduleName3 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::core";
+var BetResultEvent = new MoveStruct({
+  name: `${$moduleName3}::BetResultEvent<phantom T0>`,
+  fields: {
+    player: bcs.Address,
+    coin_type: TypeName,
+    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()))
+  }
+});
+var $moduleName4 = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
+var TypeName2 = new MoveStruct({
+  name: `${$moduleName4}::TypeName`,
+  fields: {
+    name: bcs.string()
+  }
+});
+var $moduleName5 = "0x2::balance";
+var Balance = new MoveStruct({
+  name: `${$moduleName5}::Balance<phantom T0>`,
+  fields: {
+    value: bcs.u64()
+  }
+});
+var $moduleName6 = "0x2::vec_map";
+function Entry2(...typeParameters) {
+  return new MoveStruct({
+    name: `${$moduleName6}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      key: typeParameters[0],
+      value: typeParameters[1]
+    }
+  });
+}
+function VecMap2(...typeParameters) {
+  return new MoveStruct({
+    name: `${$moduleName6}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      contents: bcs.vector(Entry2(typeParameters[0], typeParameters[1]))
+    }
+  });
+}
+
+// src/contracts/pvp-coinflip/pvp_coinflip.ts
+var $moduleName7 = "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip";
+var Game = new MoveStruct({
+  name: `${$moduleName7}::Game<phantom T0>`,
+  fields: {
+    id: bcs.Address,
+    creator: bcs.Address,
+    creator_is_tails: bcs.bool(),
+    is_private: bcs.bool(),
+    creator_metadata: VecMap2(bcs.string(), bcs.vector(bcs.u8())),
+    joiner: bcs.Address,
+    winner: bcs.Address,
+    stake_per_player: bcs.u64(),
+    house_edge_bps: bcs.u64(),
+    stake_pot: Balance
+  }
+});
+var GameCreatedEvent = new MoveStruct({
+  name: `${$moduleName7}::GameCreatedEvent<phantom T0>`,
+  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: TypeName2
+  }
+});
+var GameResolvedEvent = new MoveStruct({
+  name: `${$moduleName7}::GameResolvedEvent<phantom T0>`,
+  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: TypeName2
+  }
+});
+var GameCancelledEvent = new MoveStruct({
+  name: `${$moduleName7}::GameCancelledEvent<phantom T0>`,
+  fields: {
+    game_id: bcs.Address,
+    creator: bcs.Address,
+    creator_is_tails: bcs.bool(),
+    is_private: bcs.bool(),
+    stake_per_player: bcs.u64(),
+    coin_type: TypeName2
+  }
+});
+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",
-  pvp_coinflip: "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202",
+  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/usdc-coin-type.ts
-var DEFAULT_USDC_COIN_TYPE = "0xdba34672e30cb065b1f93e3a0e89fd79d1f22e12e55e88edbbcbac48609f4af0::usdc::USDC";
-var DEFAULT_USDC_FLOWX_COIN_TYPE = "0xbde4ba4c7f1193c4f1f5b9e8a9c1cdec42c6f3f3a73cf40e1f4cb12cc7e6a4c0::usdc::USDC";
+// src/configs/registry.ts
+var REGISTRY_IDS = {
+  mainnet: {
+    pvpCoinflip: PVP_COINFLIP_REGISTRY_ID
+  },
+  testnet: {
+    pvpCoinflip: PVP_COINFLIP_REGISTRY_ID2
+  }
+};
 
-// 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]
-    )
-  );
+// src/helpers/config.ts
+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 {
-    sweetHousePackageId: trim(options.sweetHousePackageId) || trim(DEFAULT_SWEETHOUSE_PACKAGE_ID),
+    packageIds: { ...packageIds },
+    registryIds: { ...registryIds },
     coinTypes: {
-      sui: suiCoinType,
-      usdc: usdcCoinType,
-      usdcFlowx: usdcFlowxCoinType
+      sui: normalizeStructTag(coinTypes.sui),
+      usdc: normalizeStructTag(coinTypes.usdc)
     },
-    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
+    priceInfoObjectIds: {
+      sui: priceInfoObjectIds.sui,
+      usdc: priceInfoObjectIds.usdc
     }
   };
 }
-function resolvePythPriceInfoObjectId(config, coinType) {
-  const normalizedCoinType = normalizeStructTag(coinType);
-  const explicitObjectId = config.pyth.priceInfoObjectIds[normalizedCoinType];
-  if (explicitObjectId) {
-    return explicitObjectId;
+function assertConfiguredBetGame(config, game) {
+  if (!resolveGamePackageId(config, game)) {
+    throw new Error(`Missing required config for ${game}: packageIds.${game}`);
   }
-  if (normalizedCoinType === config.coinTypes.sui && config.pyth.suiPriceInfoObjectId) {
-    return config.pyth.suiPriceInfoObjectId;
+}
+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;
   }
-  if ((normalizedCoinType === config.coinTypes.usdc || normalizedCoinType === config.coinTypes.usdcFlowx) && config.pyth.usdcPriceInfoObjectId) {
-    return config.pyth.usdcPriceInfoObjectId;
+}
+function resolvePriceInfoObjectId(config, coinType) {
+  const normalizedCoinType = 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}`
+    );
   }
-  throw new Error(
-    `Missing Pyth price object configuration for coin type ${coinType}`
-  );
+  return objectId;
 }
-function assertConfiguredBetGame(config, game) {
-  if (!config.gamesPackageId[game]) {
+function resolveSupportedCoin(config, coinType) {
+  const [supportedCoin] = Object.entries(config.coinTypes).find(([_, value]) => value === coinType) ?? [];
+  if (!supportedCoin) {
     throw new Error(
-      `Missing required config for ${game}: gamesPackageId.${game}`
+      `Unsupported coin type ${coinType}. Supported coin types: ${Object.values(
+        config.coinTypes
+      ).join(", ")}`
     );
   }
+  return supportedCoin;
 }
-var ADDRESS_METADATA_KEYS = /* @__PURE__ */ new Set(["referrer", "partner"]);
+var PARTNER_METADATA_KEY = "partner";
+var RESERVED_METADATA_KEYS = /* @__PURE__ */ new Set([PARTNER_METADATA_KEY, "referrer"]);
 var textEncoder = new TextEncoder();
-var parseHexAddress = (value) => {
-  const trimmed = value.trim();
-  if (!trimmed) return null;
+function encodeString(value) {
   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;
+    return fromHex(value);
   } 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 textEncoder.encode(value);
   }
-  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`);
+function encodeMetadataValue(value) {
+  if (value instanceof Uint8Array) {
+    return Array.from(value);
   }
-  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;
-    }
+  if (Array.isArray(value)) {
+    return value;
   }
-  return null;
+  return Array.from(encodeString(String(value)));
 }
-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));
+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 (typeof arg === "string") {
-      normalizedArgs.push((tx) => tx.object(arg));
+    if (value == null) {
       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);
+    keys.push(key);
+    values.push(encodeMetadataValue(value));
   }
-  if (typeof val === "bigint") {
-    return val.toString();
+  if (partner?.trim()) {
+    keys.unshift(PARTNER_METADATA_KEY);
+    values.unshift(encodeMetadataValue(partner));
   }
-  return val;
+  return {
+    keys,
+    values
+  };
 }
 
 // src/contracts/coinflip/coinflip.ts
@@ -309,39 +385,46 @@ function play(options) {
     typeArguments: options.typeArguments
   });
 }
+
+// src/types/network.type.ts
+var SUPPORTED_SUI_NETWORKS = [
+  "mainnet",
+  "testnet"
+];
+
+// src/transactions/shared.ts
 function createBaseGameTransaction({
   config,
   game,
-  owner,
-  sender,
+  playerAddress,
   gasBudget
 }) {
   assertConfiguredBetGame(config, game);
   const tx = new Transaction();
-  tx.setSenderIfNotSet(normalizeSuiAddress(sender ?? owner));
+  tx.setSenderIfNotSet(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 = normalizeSuiAddress(sender ?? owner);
+    const normalizedPlayerAddress = normalizeSuiAddress(playerAddress);
     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(
+    const resolvedStake = toBigInt(stake);
+    const resolvedCashStake = toBigInt(cashStake ?? stake);
+    const resolvedBetCount = toBigInt(betCount ?? 1);
+    const encodedMetadata = encodeBetMetadata(metadata, partner);
+    const priceInfoObjectId = resolvePriceInfoObjectId(
       config,
       normalizedCoinType
     );
@@ -353,16 +436,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;
   };
 }
@@ -384,20 +467,20 @@ 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)
   });
@@ -430,7 +513,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,
@@ -442,13 +525,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,
@@ -456,7 +539,7 @@ function buildLimboTransaction(options) {
         BigInt(scale),
         metadata.keys,
         metadata.values,
-        pythPriceInfoObjectId
+        priceInfoObjectId
       ]
     })(tx)
   });
@@ -488,7 +571,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",
@@ -499,134 +582,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.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);
+  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,
@@ -634,10 +618,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),
@@ -650,23 +634,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
           ]
         })
       );
@@ -676,11 +658,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
           ]
         })
       );
@@ -719,7 +701,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({
@@ -732,13 +714,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,
@@ -747,7 +729,7 @@ function buildRangeTransaction(options) {
         Boolean(options.outOfRange),
         metadata.keys,
         metadata.values,
-        pythPriceInfoObjectId
+        priceInfoObjectId
       ]
     })(tx)
   });
@@ -779,7 +761,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",
@@ -790,104 +772,161 @@ 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.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
+  partner
 } = {}) {
   return {
     name,
     register: (client) => {
-      return new SuigarClient({ client, options });
+      return new SuigarClient({ client, partner });
     }
   };
 }
 var SuigarClient = class {
   #client;
   #config;
+  #partner;
   constructor({
     client,
-    options
+    partner
   }) {
     this.#client = client;
-    this.#config = resolveSuigarConfig(options);
+    this.#partner = partner;
+    const network = this.#client.network;
+    if (!SUPPORTED_SUI_NETWORKS.includes(network)) {
+      throw new Error(`Unsupported network: ${network}`);
+    }
+    this.#config = resolveSuigarConfig(network);
   }
   /**
-   * Builds a transaction with the configured Sui client and returns the BCS bytes as a base64 string.
+   * 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 block to serialize.
+   * @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) {
-    const bytes = await transaction.build({ client: this.#client });
-    return Buffer.from(bytes).toString("base64");
+  async serializeTransactionToBase64(transaction, options) {
+    const bytes = await transaction.build({ ...options, client: this.#client });
+    return toBase64(bytes);
+  }
+  /**
+   * 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]
+    );
   }
   /**
-   * BCS struct constructors for decoding Suigar events emitted on-chain.
+   * 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.
      */
@@ -895,15 +934,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.
@@ -921,27 +960,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}`);
@@ -955,12 +999,46 @@ 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
+      });
+    };
+  }
 };
 
 export { SuigarClient, suigar };