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

package/dist/index.js

@@ -1,6 +1,7 @@
-import { normalizeSuiAddress, toBase64, normalizeStructTag } from '@mysten/sui/utils';
-import { bcs, BcsStruct, TypeTagSerializer } from '@mysten/sui/bcs';
-import { Transaction, isArgument } from '@mysten/sui/transactions';
+import { MoveStruct, Float, toBigIntAmount, toU8Number, DEFAULT_GAS_BUDGET_MIST, normalizeMoveArguments, DEFAULT_LIMBO_MULTIPLIER_SCALE, DEFAULT_RANGE_SCALE } from './chunk-W3WZ2BHO.js';
+import { toBase64, normalizeStructTag, parseStructTag, normalizeSuiAddress, isValidSuiAddress } from '@mysten/sui/utils';
+import { Transaction } from '@mysten/sui/transactions';
+import { bcs } from '@mysten/sui/bcs';
 
 // src/types/network.type.ts
 var SUPPORTED_SUI_NETWORKS = [
@@ -62,13 +63,31 @@ var PRICE_INFO_OBJECT_IDS = {
   testnet: { ...TESTNET_PRICE_INFO_OBJECT_IDS }
 };
 
-// src/utils/config.ts
+// src/configs/registry.mainnet.ts
+var PVP_COINFLIP_REGISTRY_ID = "0x3d73568546c539c1da3eb2b8fe917faef3c0acdbec78a67fe6d52800a0729349";
+
+// src/configs/registry.testnet.ts
+var PVP_COINFLIP_REGISTRY_ID2 = "0x99f20d8e4be012ea14a681144ae72ac349d0a1a1585205880183eb167f075bad";
+
+// src/configs/registry.ts
+var REGISTRY_IDS = {
+  mainnet: {
+    pvpCoinflip: PVP_COINFLIP_REGISTRY_ID
+  },
+  testnet: {
+    pvpCoinflip: PVP_COINFLIP_REGISTRY_ID2
+  }
+};
+
+// src/helpers/config.ts
 function resolveSuigarConfig(network) {
   const packageIds = PACKAGE_IDS[network];
+  const registryIds = REGISTRY_IDS[network];
   const coinTypes = COIN_TYPES[network];
   const priceInfoObjectIds = PRICE_INFO_OBJECT_IDS[network];
   return {
     packageIds: { ...packageIds },
+    registryIds: { ...registryIds },
     coinTypes: {
       sui: normalizeStructTag(coinTypes.sui),
       usdc: normalizeStructTag(coinTypes.usdc)
@@ -123,11 +142,12 @@ function resolveSupportedCoin(config, coinType) {
     `Unsupported coin type ${coinType}. Supported coin types: ${entries.map(([, configuredCoinType]) => configuredCoinType).join(", ")}`
   );
 }
-var ADDRESS_METADATA_KEYS = /* @__PURE__ */ new Set(["referrer", "partner"]);
+var ADDRESS_METADATA_KEYS = /* @__PURE__ */ new Set(["partner"]);
+var RESERVED_METADATA_KEYS = /* @__PURE__ */ new Set([...ADDRESS_METADATA_KEYS, "referrer"]);
 var textEncoder = new TextEncoder();
-var parseHexAddress = (value) => {
+function parseHexAddress(value) {
   const trimmed = value.trim();
-  if (!trimmed) return null;
+  if (!trimmed || !isValidSuiAddress(trimmed)) return null;
   try {
     const normalized = normalizeSuiAddress(trimmed).slice(2);
     const bytes = new Uint8Array(normalized.length / 2);
@@ -141,190 +161,42 @@ var parseHexAddress = (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 { 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;
+function encodeMetadataValue(key, value) {
+  if (value instanceof Uint8Array) {
+    return Array.from(value);
   }
-  if (!Number.isFinite(value) || value < 0) {
-    throw new Error(`${fieldName} must be a finite non-negative number`);
+  if (Array.isArray(value)) {
+    return value;
   }
-  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`);
+  if (typeof value === "string" && ADDRESS_METADATA_KEYS.has(key)) {
+    return Array.from(parseHexAddress(value) ?? textEncoder.encode(value));
   }
-  return value;
+  return Array.from(textEncoder.encode(String(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));
+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(key, value));
   }
-  if (typeof val === "bigint") {
-    return val.toString();
+  if (!partner?.trim()) {
+    return { keys, values };
   }
-  return val;
+  return {
+    keys: [...keys, "partner"],
+    values: [...values, encodeMetadataValue("partner", partner)]
+  };
 }
 
 // src/contracts/coinflip/coinflip.ts
@@ -372,6 +244,7 @@ function buildSharedStandardGameBetCall({
   cashStake,
   betCount,
   metadata,
+  partner,
   allowGasCoinShortcut = true,
   buildRewardCoin
 }) {
@@ -381,7 +254,7 @@ function buildSharedStandardGameBetCall({
     const resolvedStake = toBigIntAmount(stake, "stake");
     const resolvedCashStake = toBigIntAmount(cashStake ?? stake, "cashStake");
     const resolvedBetCount = toBigIntAmount(betCount ?? 1, "betCount");
-    const encodedMetadata = encodeBetMetadata(metadata);
+    const encodedMetadata = encodeBetMetadata(metadata, partner);
     const priceInfoObjectId = resolvePriceInfoObjectId(
       config,
       normalizedCoinType
@@ -471,7 +344,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,
@@ -558,14 +431,42 @@ function buildPlinkoTransaction(options) {
     })(tx)
   });
 }
-var $moduleName = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
-var TypeName = new MoveStruct({ name: `${$moduleName}::TypeName`, fields: {
+var $moduleName = "0x2::vec_map";
+function Entry(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+    key: typeParameters[0],
+    value: typeParameters[1]
+  } });
+}
+function VecMap(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+    contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+  } });
+}
+var $moduleName2 = "0x2::balance";
+var Balance = new MoveStruct({ name: `${$moduleName2}::Balance<phantom T0>`, fields: {
+  value: bcs.u64()
+} });
+var $moduleName3 = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
+var TypeName = new MoveStruct({ name: `${$moduleName3}::TypeName`, fields: {
   name: bcs.string()
 } });
 
 // src/contracts/pvp-coinflip/pvp_coinflip.ts
-var $moduleName2 = "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip";
-var GameCreatedEvent = new MoveStruct({ name: `${$moduleName2}::GameCreatedEvent<phantom T0>`, fields: {
+var $moduleName4 = "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip";
+var Game = new MoveStruct({ name: `${$moduleName4}::Game<phantom T0>`, fields: {
+  id: bcs.Address,
+  creator: bcs.Address,
+  creator_is_tails: bcs.bool(),
+  is_private: bcs.bool(),
+  creator_metadata: VecMap(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: `${$moduleName4}::GameCreatedEvent<phantom T0>`, fields: {
   game_id: bcs.Address,
   creator: bcs.Address,
   creator_is_tails: bcs.bool(),
@@ -575,7 +476,7 @@ var GameCreatedEvent = new MoveStruct({ name: `${$moduleName2}::GameCreatedEvent
   house_edge_bps: bcs.u64(),
   coin_type: TypeName
 } });
-var GameResolvedEvent = new MoveStruct({ name: `${$moduleName2}::GameResolvedEvent<phantom T0>`, fields: {
+var GameResolvedEvent = new MoveStruct({ name: `${$moduleName4}::GameResolvedEvent<phantom T0>`, fields: {
   game_id: bcs.Address,
   creator: bcs.Address,
   joiner: bcs.Address,
@@ -589,7 +490,7 @@ var GameResolvedEvent = new MoveStruct({ name: `${$moduleName2}::GameResolvedEve
   payout_amount: bcs.u64(),
   coin_type: TypeName
 } });
-var GameCancelledEvent = new MoveStruct({ name: `${$moduleName2}::GameCancelledEvent<phantom T0>`, fields: {
+var GameCancelledEvent = new MoveStruct({ name: `${$moduleName4}::GameCancelledEvent<phantom T0>`, fields: {
   game_id: bcs.Address,
   creator: bcs.Address,
   creator_is_tails: bcs.bool(),
@@ -657,7 +558,7 @@ function buildPvPCoinflipTransaction(action, 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;
@@ -685,12 +586,10 @@ 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.packageIds.pvpCoinflip,
@@ -698,10 +597,10 @@ function buildPvPCoinflipTransaction(action, options) {
           arguments: [
             joinOptions.gameId,
             joinOptions.config.packageIds.sweetHouse,
-            betCoin,
+            tx.add(joinOptions.betCoin),
             encodedMetadata.keys,
             encodedMetadata.values,
-            joinOptions.extraObjectId
+            priceInfoObjectId
           ]
         })
       );
@@ -754,7 +653,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({
@@ -843,32 +742,20 @@ function buildWheelTransaction(options) {
     })(tx)
   });
 }
-var $moduleName3 = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
-var TypeName2 = new MoveStruct({ name: `${$moduleName3}::TypeName`, fields: {
+var $moduleName5 = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
+var TypeName2 = new MoveStruct({ name: `${$moduleName5}::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) {
+function Entry2(...typeParameters) {
   return new MoveStruct({ name: `${$moduleName6}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
     key: typeParameters[0],
     value: typeParameters[1]
   } });
 }
-function VecMap(...typeParameters) {
+function VecMap2(...typeParameters) {
   return new MoveStruct({ name: `${$moduleName6}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
-    contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+    contents: bcs.vector(Entry2(typeParameters[0], typeParameters[1]))
   } });
 }
 
@@ -881,24 +768,32 @@ var BetResultEvent = new MoveStruct({ name: `${$moduleName7}::BetResultEvent<pha
   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()))
+  game_details: VecMap2(bcs.string(), bcs.vector(bcs.u8())),
+  metadata: VecMap2(bcs.string(), bcs.vector(bcs.u8()))
 } });
+
+// src/client.ts
 function suigar({
-  name = "suigar"
+  name = "suigar",
+  partner
 } = {}) {
   return {
     name,
     register: (client) => {
-      return new SuigarClient({ client });
+      return new SuigarClient({ client, partner });
     }
   };
 }
 var SuigarClient = class {
   #client;
   #config;
-  constructor({ client }) {
+  #partner;
+  constructor({
+    client,
+    partner
+  }) {
     this.#client = client;
+    this.#partner = partner;
     const network = this.#client.network;
     if (!SUPPORTED_SUI_NETWORKS.includes(network)) {
       throw new Error(`Unsupported network: ${network}`);
@@ -933,9 +828,74 @@ var SuigarClient = class {
     return toBase64(bytes);
   }
   /**
-   * BCS struct constructors for decoding Suigar events emitted on-chain.
+   * 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 loads
+   * each referenced game object through `resolvePvPConflipGame()`. 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`.
+   * @returns Parsed unresolved PvP coinflip game objects for the requested registry page.
+   */
+  async getPvPCoinflipGames(options = {
+    limit: 50
+  }) {
+    const { dynamicFields } = await this.#client.core.listDynamicFields({
+      parentId: this.#config.registryIds.pvpCoinflip,
+      ...options
+    });
+    return await Promise.all(
+      dynamicFields.map(({ childId }) => this.resolvePvPConflipGame(childId))
+    );
+  }
+  /**
+   * Fetches a PvP coinflip game object from chain and parses it into the SDK's
+   * normalized runtime shape.
+   *
+   * This resolves the raw object through the configured client, requires the
+   * object's `content` to be present, decodes that content with the generated
+   * `PvPCoinflipGame` BCS parser, and normalizes the generic coin type into a
+   * standard struct tag string. Use this when a product needs the current state
+   * of a specific PvP coinflip match before rendering join, cancel, or result UI.
+   *
+   * @param gameId On-chain object id of the PvP coinflip game.
+   * @returns Parsed PvP coinflip game state with a normalized `coinType`.
+   * @throws Error If the object cannot be decoded because no content was returned.
+   */
+  async resolvePvPConflipGame(gameId) {
+    const { object } = await this.#client.core.getObject({
+      objectId: gameId,
+      include: { content: true }
+    });
+    if (!object.content) {
+      throw new Error("Unable to resolve PvP coinflip from game object");
+    }
+    return {
+      ...Game.parse(object.content),
+      coinType: normalizeStructTag(parseStructTag(object.type).typeParams[0])
+    };
+  }
+  /**
+   * 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.
      */
@@ -969,27 +929,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}`);
@@ -1003,12 +968,45 @@ 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 { stake_per_player } = await this.resolvePvPConflipGame(
+        options.gameId
+      );
+      return tx.coin({
+        type: options.coinType,
+        balance: BigInt(stake_per_player),
+        useGasCoin: options.allowGasCoinShortcut
+      });
+    };
+  }
 };
 
-export { suigar };
+export { SuigarClient, suigar };