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

package/dist/index.cjs

@@ -4,6 +4,8 @@ var utils = require('@mysten/sui/utils');
 var bcs = require('@mysten/sui/bcs');
 var transactions = require('@mysten/sui/transactions');
 
+// src/client.ts
+
 // src/types/network.type.ts
 var SUPPORTED_SUI_NETWORKS = [
   "mainnet",
@@ -64,13 +66,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: utils.normalizeStructTag(coinTypes.sui),
       usdc: utils.normalizeStructTag(coinTypes.usdc)
@@ -125,11 +145,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 || !utils.isValidSuiAddress(trimmed)) return null;
   try {
     const normalized = utils.normalizeSuiAddress(trimmed).slice(2);
     const bytes = new Uint8Array(normalized.length / 2);
@@ -143,53 +164,42 @@ var parseHexAddress = (value) => {
   } catch {
     return null;
   }
-};
-function encodeBetMetadata(metadata) {
+}
+function encodeMetadataValue(key, value) {
+  if (value instanceof Uint8Array) {
+    return Array.from(value);
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "string" && ADDRESS_METADATA_KEYS.has(key)) {
+    return Array.from(parseHexAddress(value) ?? textEncoder.encode(value));
+  }
+  return Array.from(textEncoder.encode(String(value)));
+}
+function encodeBetMetadata(metadata, partner) {
   const keys = [];
   const values = [];
   for (const [key, value] of Object.entries(metadata ?? {})) {
-    if (value === void 0 || value === null) {
+    if (RESERVED_METADATA_KEYS.has(key)) {
+      console.warn(
+        `Metadata key "${key}" is reserved and will be ignored when parsing metadata.`
+      );
       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)));
+    if (value == null) {
+      continue;
     }
     keys.push(key);
-    values.push(encodedValue);
+    values.push(encodeMetadataValue(key, 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`);
+  if (!partner?.trim()) {
+    return { keys, values };
   }
-  return value;
+  return {
+    keys: [...keys, "partner"],
+    values: [...values, encodeMetadataValue("partner", partner)]
+  };
 }
 var MOVE_STDLIB_ADDRESS = utils.normalizeSuiAddress("0x1");
 var SUI_FRAMEWORK_ADDRESS = utils.normalizeSuiAddress("0x2");
@@ -352,6 +362,41 @@ function play(options) {
     typeArguments: options.typeArguments
   });
 }
+var DEFAULT_GAS_BUDGET_MIST = utils.parseToMist("0.05");
+var DEFAULT_RANGE_SCALE = 1e6;
+var DEFAULT_LIMBO_MULTIPLIER_SCALE = 100;
+
+// src/utils/numeric.ts
+function 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 $moduleName = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
+var I64 = new MoveStruct({ name: `${$moduleName}::I64`, fields: {
+  bits: bcs.bcs.u64()
+} });
+
+// src/contracts/core/float.ts
+var $moduleName2 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
+var Float = new MoveStruct({ name: `${$moduleName2}::Float`, fields: {
+  is_negative: bcs.bcs.bool(),
+  exp: I64,
+  mant: bcs.bcs.u64()
+} });
 function createBaseGameTransaction({
   config,
   game,
@@ -374,6 +419,7 @@ function buildSharedStandardGameBetCall({
   cashStake,
   betCount,
   metadata,
+  partner,
   allowGasCoinShortcut = true,
   buildRewardCoin
 }) {
@@ -383,7 +429,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
@@ -473,7 +519,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,
@@ -560,14 +606,42 @@ function buildPlinkoTransaction(options) {
     })(tx)
   });
 }
-var $moduleName = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
-var TypeName = new MoveStruct({ name: `${$moduleName}::TypeName`, fields: {
+var $moduleName3 = "0x2::vec_map";
+function Entry(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName3}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+    key: typeParameters[0],
+    value: typeParameters[1]
+  } });
+}
+function VecMap(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName3}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+    contents: bcs.bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+  } });
+}
+var $moduleName4 = "0x2::balance";
+var Balance = new MoveStruct({ name: `${$moduleName4}::Balance<phantom T0>`, fields: {
+  value: bcs.bcs.u64()
+} });
+var $moduleName5 = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
+var TypeName = new MoveStruct({ name: `${$moduleName5}::TypeName`, fields: {
   name: bcs.bcs.string()
 } });
 
 // src/contracts/pvp-coinflip/pvp_coinflip.ts
-var $moduleName2 = "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip";
-var GameCreatedEvent = new MoveStruct({ name: `${$moduleName2}::GameCreatedEvent<phantom T0>`, fields: {
+var $moduleName6 = "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip";
+var Game = new MoveStruct({ name: `${$moduleName6}::Game<phantom T0>`, fields: {
+  id: bcs.bcs.Address,
+  creator: bcs.bcs.Address,
+  creator_is_tails: bcs.bcs.bool(),
+  is_private: bcs.bcs.bool(),
+  creator_metadata: VecMap(bcs.bcs.string(), bcs.bcs.vector(bcs.bcs.u8())),
+  joiner: bcs.bcs.Address,
+  winner: bcs.bcs.Address,
+  stake_per_player: bcs.bcs.u64(),
+  house_edge_bps: bcs.bcs.u64(),
+  stake_pot: Balance
+} });
+var GameCreatedEvent = new MoveStruct({ name: `${$moduleName6}::GameCreatedEvent<phantom T0>`, fields: {
   game_id: bcs.bcs.Address,
   creator: bcs.bcs.Address,
   creator_is_tails: bcs.bcs.bool(),
@@ -577,7 +651,7 @@ var GameCreatedEvent = new MoveStruct({ name: `${$moduleName2}::GameCreatedEvent
   house_edge_bps: bcs.bcs.u64(),
   coin_type: TypeName
 } });
-var GameResolvedEvent = new MoveStruct({ name: `${$moduleName2}::GameResolvedEvent<phantom T0>`, fields: {
+var GameResolvedEvent = new MoveStruct({ name: `${$moduleName6}::GameResolvedEvent<phantom T0>`, fields: {
   game_id: bcs.bcs.Address,
   creator: bcs.bcs.Address,
   joiner: bcs.bcs.Address,
@@ -591,7 +665,7 @@ var GameResolvedEvent = new MoveStruct({ name: `${$moduleName2}::GameResolvedEve
   payout_amount: bcs.bcs.u64(),
   coin_type: TypeName
 } });
-var GameCancelledEvent = new MoveStruct({ name: `${$moduleName2}::GameCancelledEvent<phantom T0>`, fields: {
+var GameCancelledEvent = new MoveStruct({ name: `${$moduleName6}::GameCancelledEvent<phantom T0>`, fields: {
   game_id: bcs.bcs.Address,
   creator: bcs.bcs.Address,
   creator_is_tails: bcs.bcs.bool(),
@@ -659,7 +733,7 @@ function buildPvPCoinflipTransaction(action, options) {
     game: "pvp-coinflip"
   });
   const normalizedCoinType = utils.normalizeStructTag(options.coinType);
-  const encodedMetadata = encodeBetMetadata(options.metadata);
+  const encodedMetadata = encodeBetMetadata(options.metadata, options.partner);
   switch (action) {
     case "create": {
       const createOptions = options;
@@ -687,12 +761,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,
@@ -700,10 +772,10 @@ function buildPvPCoinflipTransaction(action, options) {
           arguments: [
             joinOptions.gameId,
             joinOptions.config.packageIds.sweetHouse,
-            betCoin,
+            tx.add(joinOptions.betCoin),
             encodedMetadata.keys,
             encodedMetadata.values,
-            joinOptions.extraObjectId
+            priceInfoObjectId
           ]
         })
       );
@@ -756,7 +828,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({
@@ -845,62 +917,58 @@ function buildWheelTransaction(options) {
     })(tx)
   });
 }
-var $moduleName3 = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
-var TypeName2 = new MoveStruct({ name: `${$moduleName3}::TypeName`, fields: {
+var $moduleName7 = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
+var TypeName2 = new MoveStruct({ name: `${$moduleName7}::TypeName`, fields: {
   name: bcs.bcs.string()
 } });
-var $moduleName4 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
-var I64 = new MoveStruct({ name: `${$moduleName4}::I64`, fields: {
-  bits: bcs.bcs.u64()
-} });
-
-// src/contracts/core/float.ts
-var $moduleName5 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
-var Float = new MoveStruct({ name: `${$moduleName5}::Float`, fields: {
-  is_negative: bcs.bcs.bool(),
-  exp: I64,
-  mant: bcs.bcs.u64()
-} });
-var $moduleName6 = "0x2::vec_map";
-function Entry(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName6}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+var $moduleName8 = "0x2::vec_map";
+function Entry2(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName8}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
     key: typeParameters[0],
     value: typeParameters[1]
   } });
 }
-function VecMap(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName6}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
-    contents: bcs.bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+function VecMap2(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName8}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+    contents: bcs.bcs.vector(Entry2(typeParameters[0], typeParameters[1]))
   } });
 }
 
 // src/contracts/core/core.ts
-var $moduleName7 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::core";
-var BetResultEvent = new MoveStruct({ name: `${$moduleName7}::BetResultEvent<phantom T0>`, fields: {
+var $moduleName9 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::core";
+var BetResultEvent = new MoveStruct({ name: `${$moduleName9}::BetResultEvent<phantom T0>`, fields: {
   player: bcs.bcs.Address,
   coin_type: TypeName2,
   stake_amount: bcs.bcs.u64(),
   unsafe_oracle_usd_coin_price: Float,
   adjusted_oracle_usd_coin_price: Float,
   outcome_amount: bcs.bcs.u64(),
-  game_details: VecMap(bcs.bcs.string(), bcs.bcs.vector(bcs.bcs.u8())),
-  metadata: VecMap(bcs.bcs.string(), bcs.bcs.vector(bcs.bcs.u8()))
+  game_details: VecMap2(bcs.bcs.string(), bcs.bcs.vector(bcs.bcs.u8())),
+  metadata: VecMap2(bcs.bcs.string(), bcs.bcs.vector(bcs.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}`);
@@ -935,9 +1003,74 @@ var SuigarClient = class {
     return utils.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: utils.normalizeStructTag(utils.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.
      */
@@ -971,27 +1104,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}`);
@@ -1005,12 +1143,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 { stake_per_player } = await this.resolvePvPConflipGame(
+        options.gameId
+      );
+      return tx.coin({
+        type: options.coinType,
+        balance: BigInt(stake_per_player),
+        useGasCoin: options.allowGasCoinShortcut
+      });
+    };
+  }
 };
 
+exports.SuigarClient = SuigarClient;
 exports.suigar = suigar;