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

package/dist/index.js

@@ -1,7 +1,8 @@
-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 { MoveStruct, Float, parseCoinType, toBigInt, toU8, DEFAULT_GAS_BUDGET_MIST, normalizeMoveArguments, DEFAULT_LIMBO_MULTIPLIER_SCALE, DEFAULT_RANGE_SCALE } from './chunk-7N55D2TV.js';
+import { toBase64, normalizeStructTag, parseStructTag, normalizeSuiAddress, fromHex } from '@mysten/sui/utils';
 import { bcs } from '@mysten/sui/bcs';
 import { Transaction } from '@mysten/sui/transactions';
+import { ClientCache } from '@mysten/sui/client';
 
 var $moduleName = "0x0000000000000000000000000000000000000000000000000000000000000001::type_name";
 var TypeName = new MoveStruct({
@@ -79,6 +80,12 @@ function VecMap2(...typeParameters) {
 
 // src/contracts/pvp-coinflip/pvp_coinflip.ts
 var $moduleName7 = "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip";
+var PvpCoinflipSettingsKey = new MoveStruct({
+  name: `${$moduleName7}::PvpCoinflipSettingsKey`,
+  fields: {
+    dummy_field: bcs.bool()
+  }
+});
 var Game = new MoveStruct({
   name: `${$moduleName7}::Game<phantom T0>`,
   fields: {
@@ -135,6 +142,14 @@ var GameCancelledEvent = new MoveStruct({
     coin_type: TypeName2
   }
 });
+var Parameters = new MoveStruct({
+  name: `${$moduleName7}::Parameters<phantom T0>`,
+  fields: {
+    id: bcs.Address,
+    house_edge_bps: bcs.u64(),
+    min_stake: bcs.u64()
+  }
+});
 function createGame(options) {
   const packageAddress = options.package ?? "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202";
   const argumentsTypes = [
@@ -256,6 +271,7 @@ var REGISTRY_IDS = {
 };
 
 // src/helpers/config.ts
+var DEFAULT_CACHE_TTL_MS = 30 * 60 * 1e3;
 function resolveSuigarConfig(network) {
   const packageIds = PACKAGE_IDS[network];
   const registryIds = REGISTRY_IDS[network];
@@ -309,7 +325,7 @@ function resolvePriceInfoObjectId(config, coinType) {
 function resolveSupportedCoin(config, coinType) {
   const [supportedCoin] = Object.entries(config.coinTypes).find(([_, value]) => value === coinType) ?? [];
   if (!supportedCoin) {
-    throw new Error(
+    throw new RangeError(
       `Unsupported coin type ${coinType}. Supported coin types: ${Object.values(
         config.coinTypes
       ).join(", ")}`
@@ -317,6 +333,22 @@ function resolveSupportedCoin(config, coinType) {
   }
   return supportedCoin;
 }
+function replaceStructTagAddress(structName, address) {
+  return normalizeStructTag({
+    ...parseStructTag(structName),
+    address
+  });
+}
+function resolveGameSettingsKeyType(structName, packageId) {
+  return replaceStructTagAddress(structName, packageId);
+}
+function resolveCoinTypeNameForTypeNameKey(structName) {
+  const { address } = parseStructTag(structName);
+  return replaceStructTagAddress(
+    structName,
+    normalizeSuiAddress(address).replace(/^0x/, "")
+  );
+}
 var PARTNER_METADATA_KEY = "partner";
 var RESERVED_METADATA_KEYS = /* @__PURE__ */ new Set([PARTNER_METADATA_KEY, "referrer"]);
 var textEncoder = new TextEncoder();
@@ -361,8 +393,22 @@ function encodeBetMetadata(metadata, partner) {
     values
   };
 }
-
-// src/contracts/coinflip/coinflip.ts
+var $moduleName8 = "0xb35c5f286c443752afc8ccb40125a578a4f32df35617170ccfa17fe180ab80ea::coinflip";
+var CoinFlipSettingsKey = new MoveStruct({
+  name: `${$moduleName8}::CoinFlipSettingsKey`,
+  fields: {
+    dummy_field: bcs.bool()
+  }
+});
+var Parameters2 = new MoveStruct({
+  name: `${$moduleName8}::Parameters<phantom T0>`,
+  fields: {
+    id: bcs.Address,
+    house_edge: bcs.u64(),
+    min_stake: bcs.u64(),
+    max_stake: bcs.u64()
+  }
+});
 function play(options) {
   const packageAddress = options.package ?? "0xb35c5f286c443752afc8ccb40125a578a4f32df35617170ccfa17fe180ab80ea";
   const argumentsTypes = [
@@ -485,8 +531,47 @@ function buildCoinflipTransaction(options) {
     })(tx)
   });
 }
+var $moduleName9 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
+var I64 = new MoveStruct({
+  name: `${$moduleName9}::I64`,
+  fields: {
+    bits: bcs.u64()
+  }
+});
+
+// src/contracts/limbo/deps/0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc/float.ts
+var $moduleName10 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
+var Float2 = new MoveStruct({
+  name: `${$moduleName10}::Float`,
+  fields: {
+    is_negative: bcs.bool(),
+    exp: I64,
+    mant: bcs.u64()
+  }
+});
 
 // src/contracts/limbo/limbo.ts
+var $moduleName11 = "0x96c7841b9b32c59a219760fd656f1c3aceb53cc74a68ec9844a3a696374309f4::limbo";
+var LimboSettingsKey = new MoveStruct({
+  name: `${$moduleName11}::LimboSettingsKey`,
+  fields: {
+    dummy_field: bcs.bool()
+  }
+});
+var Parameters3 = new MoveStruct({
+  name: `${$moduleName11}::Parameters<phantom T0>`,
+  fields: {
+    id: bcs.Address,
+    min_stake: bcs.u64(),
+    max_stake: bcs.u64(),
+    max_payout: bcs.u64(),
+    min_target_multiplier: Float2,
+    max_target_multiplier: Float2,
+    max_number_of_games: bcs.u64(),
+    min_rtp: Float2,
+    max_rtp: Float2
+  }
+});
 function play2(options) {
   const packageAddress = options.package ?? "0x96c7841b9b32c59a219760fd656f1c3aceb53cc74a68ec9844a3a696374309f4";
   const argumentsTypes = [
@@ -544,8 +629,71 @@ function buildLimboTransaction(options) {
     })(tx)
   });
 }
+var $moduleName12 = "0x2::vec_map";
+function Entry3(...typeParameters) {
+  return new MoveStruct({
+    name: `${$moduleName12}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      key: typeParameters[0],
+      value: typeParameters[1]
+    }
+  });
+}
+function VecMap3(...typeParameters) {
+  return new MoveStruct({
+    name: `${$moduleName12}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      contents: bcs.vector(Entry3(typeParameters[0], typeParameters[1]))
+    }
+  });
+}
+var $moduleName13 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
+var I642 = new MoveStruct({
+  name: `${$moduleName13}::I64`,
+  fields: {
+    bits: bcs.u64()
+  }
+});
+
+// src/contracts/plinko/deps/0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc/float.ts
+var $moduleName14 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
+var Float3 = new MoveStruct({
+  name: `${$moduleName14}::Float`,
+  fields: {
+    is_negative: bcs.bool(),
+    exp: I642,
+    mant: bcs.u64()
+  }
+});
 
 // src/contracts/plinko/plinko.ts
+var $moduleName15 = "0xd3dd2200883af10811724f0bed97591ad155a02efd6332d471ff8b346030dfb7::plinko";
+var PlinkoSettingsKey = new MoveStruct({
+  name: `${$moduleName15}::PlinkoSettingsKey`,
+  fields: {
+    dummy_field: bcs.bool()
+  }
+});
+var PlinkoConfig = new MoveStruct({
+  name: `${$moduleName15}::PlinkoConfig`,
+  fields: {
+    num_rows: bcs.u8(),
+    multipliers: bcs.vector(Float3),
+    min_stake: bcs.u64(),
+    max_stake: bcs.u64(),
+    is_playable: bcs.bool()
+  }
+});
+var Parameters4 = new MoveStruct({
+  name: `${$moduleName15}::Parameters<phantom T0>`,
+  fields: {
+    id: bcs.Address,
+    min_stake: bcs.u64(),
+    max_stake: bcs.u64(),
+    max_number_of_balls: bcs.u64(),
+    configs: VecMap3(bcs.u8(), PlinkoConfig)
+  }
+});
 function play3(options) {
   const packageAddress = options.package ?? "0xd3dd2200883af10811724f0bed97591ad155a02efd6332d471ff8b346030dfb7";
   const argumentsTypes = [
@@ -669,11 +817,49 @@ function buildPvPCoinflipTransaction(action, options) {
       return tx;
     }
     default:
-      throw new Error(`Unsupported PvP coinflip action: ${action}`);
+      throw new RangeError(`Unsupported PvP coinflip action: ${action}`);
   }
 }
+var $moduleName16 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
+var I643 = new MoveStruct({
+  name: `${$moduleName16}::I64`,
+  fields: {
+    bits: bcs.u64()
+  }
+});
+
+// src/contracts/range/deps/0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc/float.ts
+var $moduleName17 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
+var Float4 = new MoveStruct({
+  name: `${$moduleName17}::Float`,
+  fields: {
+    is_negative: bcs.bool(),
+    exp: I643,
+    mant: bcs.u64()
+  }
+});
 
 // src/contracts/range/range.ts
+var $moduleName18 = "0x096a4cf18b3661e76b2c62b90785418345d52f45b272448794f123a4cb6b6416::range";
+var RangeSettingsKey = new MoveStruct({
+  name: `${$moduleName18}::RangeSettingsKey`,
+  fields: {
+    dummy_field: bcs.bool()
+  }
+});
+var Parameters5 = new MoveStruct({
+  name: `${$moduleName18}::Parameters<phantom T0>`,
+  fields: {
+    id: bcs.Address,
+    min_stake: bcs.u64(),
+    max_stake: bcs.u64(),
+    min_zone_size: bcs.u64(),
+    max_zone_size: bcs.u64(),
+    max_number_of_games: bcs.u64(),
+    min_rtp: Float4,
+    max_rtp: Float4
+  }
+});
 function play4(options) {
   const packageAddress = options.package ?? "0x096a4cf18b3661e76b2c62b90785418345d52f45b272448794f123a4cb6b6416";
   const argumentsTypes = [
@@ -734,8 +920,71 @@ function buildRangeTransaction(options) {
     })(tx)
   });
 }
+var $moduleName19 = "0x2::vec_map";
+function Entry4(...typeParameters) {
+  return new MoveStruct({
+    name: `${$moduleName19}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      key: typeParameters[0],
+      value: typeParameters[1]
+    }
+  });
+}
+function VecMap4(...typeParameters) {
+  return new MoveStruct({
+    name: `${$moduleName19}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`,
+    fields: {
+      contents: bcs.vector(Entry4(typeParameters[0], typeParameters[1]))
+    }
+  });
+}
+var $moduleName20 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
+var I644 = new MoveStruct({
+  name: `${$moduleName20}::I64`,
+  fields: {
+    bits: bcs.u64()
+  }
+});
+
+// src/contracts/wheel/deps/0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc/float.ts
+var $moduleName21 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
+var Float5 = new MoveStruct({
+  name: `${$moduleName21}::Float`,
+  fields: {
+    is_negative: bcs.bool(),
+    exp: I644,
+    mant: bcs.u64()
+  }
+});
 
 // src/contracts/wheel/wheel.ts
+var $moduleName22 = "0x0997852ded7e13301c42317004bc49704a893aa82997c5706cebee59053a31b7::wheel";
+var WheelSettingsKey = new MoveStruct({
+  name: `${$moduleName22}::WheelSettingsKey`,
+  fields: {
+    dummy_field: bcs.bool()
+  }
+});
+var WheelConfig = new MoveStruct({
+  name: `${$moduleName22}::WheelConfig`,
+  fields: {
+    num_cases: bcs.u8(),
+    multipliers: bcs.vector(Float5),
+    min_stake: bcs.u64(),
+    max_stake: bcs.u64(),
+    is_playable: bcs.bool()
+  }
+});
+var Parameters6 = new MoveStruct({
+  name: `${$moduleName22}::Parameters<phantom T0>`,
+  fields: {
+    id: bcs.Address,
+    min_stake: bcs.u64(),
+    max_stake: bcs.u64(),
+    max_number_of_spins: bcs.u64(),
+    configs: VecMap4(bcs.u8(), WheelConfig)
+  }
+});
 function play5(options) {
   const packageAddress = options.package ?? "0x0997852ded7e13301c42317004bc49704a893aa82997c5706cebee59053a31b7";
   const argumentsTypes = [
@@ -790,16 +1039,127 @@ function buildWheelTransaction(options) {
     })(tx)
   });
 }
+var TtlClientCache = class extends ClientCache {
+  #ttlMs;
+  constructor({ ttlMs, ...options }) {
+    super({
+      ...options,
+      prefix: options.prefix ?? ["ttl"]
+    });
+    this.#ttlMs = ttlMs;
+  }
+  read(key, load, options) {
+    if (options?.ignoreCache) {
+      super.clear(key);
+    }
+    if (this.#ttlMs <= 0) {
+      return load();
+    }
+    const cached = super.read(
+      key,
+      () => this.#loadEntry(key, load)
+    );
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.value;
+    }
+    super.clear(key);
+    return super.read(
+      key,
+      () => this.#loadEntry(key, load)
+    ).value;
+  }
+  readSync(key, load, options) {
+    if (options?.ignoreCache) {
+      super.clear(key);
+    }
+    if (this.#ttlMs <= 0) {
+      return load();
+    }
+    const cached = super.readSync(
+      key,
+      () => this.#loadSyncEntry(load)
+    );
+    if (cached.expiresAt > Date.now()) {
+      return cached.value;
+    }
+    super.clear(key);
+    return super.readSync(key, () => this.#loadSyncEntry(load)).value;
+  }
+  #loadEntry(key, load) {
+    const value = load();
+    const entry = {
+      value,
+      expiresAt: Date.now() + this.#ttlMs
+    };
+    if (isPromiseLike(value)) {
+      entry.value = Promise.resolve(value).then((resolved) => {
+        super.clear(key);
+        super.read(key, () => ({
+          value: resolved,
+          expiresAt: Date.now() + this.#ttlMs
+        }));
+        return resolved;
+      }).catch((error) => {
+        super.clear(key);
+        throw error;
+      });
+    }
+    return entry;
+  }
+  #loadSyncEntry(load) {
+    return {
+      value: load(),
+      expiresAt: Date.now() + this.#ttlMs
+    };
+  }
+};
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value;
+}
+
+// src/types/game-settings.type.ts
+var GAME_SETTINGS = {
+  coinflip: {
+    settingsKey: CoinFlipSettingsKey,
+    parameters: Parameters2
+  },
+  limbo: {
+    settingsKey: LimboSettingsKey,
+    parameters: Parameters3
+  },
+  plinko: {
+    settingsKey: PlinkoSettingsKey,
+    parameters: Parameters4
+  },
+  "pvp-coinflip": {
+    settingsKey: PvpCoinflipSettingsKey,
+    parameters: Parameters
+  },
+  range: {
+    settingsKey: RangeSettingsKey,
+    parameters: Parameters5
+  },
+  wheel: {
+    settingsKey: WheelSettingsKey,
+    parameters: Parameters6
+  }
+};
 
 // src/client.ts
 function suigar({
   name = "suigar",
-  partner
+  partner,
+  cacheTtl
 } = {}) {
   return {
     name,
     register: (client) => {
-      return new SuigarClient({ client, partner });
+      return new SuigarClient({
+        client,
+        name: String(name),
+        partner,
+        cacheTtl
+      });
     }
   };
 }
@@ -807,15 +1167,23 @@ var SuigarClient = class {
   #client;
   #config;
   #partner;
+  #cache;
   constructor({
     client,
-    partner
+    name,
+    partner,
+    cacheTtl
   }) {
     this.#client = client;
     this.#partner = partner;
+    this.#cache = client.cache.scope("@suigar/sdk").readSync([name, "ttl-cache"], () => {
+      return new TtlClientCache({
+        ttlMs: cacheTtl ?? DEFAULT_CACHE_TTL_MS
+      });
+    });
     const network = this.#client.network;
     if (!SUPPORTED_SUI_NETWORKS.includes(network)) {
-      throw new Error(`Unsupported network: ${network}`);
+      throw new RangeError(`Unsupported network: ${network}`);
     }
     this.#config = resolveSuigarConfig(network);
   }
@@ -823,8 +1191,8 @@ var SuigarClient = class {
    * 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.
+   * registry ids, supported coin types, and price info object ids the SDK
+   * resolved for the current client network.
    *
    * @returns Network-resolved Suigar configuration.
    */
@@ -846,6 +1214,29 @@ var SuigarClient = class {
     const bytes = await transaction.build({ ...options, client: this.#client });
     return toBase64(bytes);
   }
+  /**
+   * Reads on-chain game parameters for the requested game.
+   *
+   * The SDK first reads the selected game's settings object from SweetHouse,
+   * then reads that game's coin-specific `Parameters<T>` object. Results are
+   * cached according to the extension `cacheTtl` option. Pass
+   * `ignoreCache: true` to refresh the onchain read and replace the cached
+   * value.
+   *
+   * @param game Game whose parameters should be loaded.
+   * @param options Optional coin type, cache override, and abort signal.
+   * @returns Parsed game parameters typed for the requested game.
+   */
+  async getGameParameters(game, options = {}) {
+    const coinType = normalizeStructTag(
+      options.coinType ?? this.#config.coinTypes.sui
+    );
+    return this.#cache.read(
+      ["parameters", this.#client.network, game, coinType],
+      () => this.#fetchGameParameters(game, coinType, options.signal),
+      { ignoreCache: options.ignoreCache }
+    );
+  }
   /**
    * Lists unresolved PvP coinflip games from the configured registry and resolves
    * each entry into parsed onchain game state.
@@ -988,7 +1379,7 @@ var SuigarClient = class {
             partner: this.#partner
           });
         default:
-          throw new Error(`Unsupported game: ${gameId}`);
+          throw new RangeError(`Unsupported game: ${gameId}`);
       }
     },
     /**
@@ -1022,7 +1413,7 @@ var SuigarClient = class {
             partner: this.#partner
           });
         default:
-          throw new Error(`Unsupported PvP coinflip action: ${action}`);
+          throw new RangeError(`Unsupported PvP coinflip action: ${action}`);
       }
     }
   };
@@ -1039,6 +1430,41 @@ var SuigarClient = class {
       });
     };
   }
+  async #fetchGameParameters(game, coinType, signal) {
+    const gameDefinition = GAME_SETTINGS[game];
+    const { object: settingsObject } = await this.#client.core.getDynamicObjectField({
+      parentId: this.#config.packageIds.sweetHouse,
+      name: {
+        type: resolveGameSettingsKeyType(
+          gameDefinition.settingsKey.name,
+          resolveGamePackageId(this.#config, game)
+        ),
+        bcs: gameDefinition.settingsKey.serialize({ dummy_field: false }).toBytes()
+      },
+      signal
+    });
+    const { object } = await this.#client.core.getDynamicObjectField({
+      parentId: settingsObject.objectId,
+      name: {
+        type: TypeName.name,
+        bcs: TypeName.serialize({
+          name: resolveCoinTypeNameForTypeNameKey(coinType)
+        }).toBytes()
+      },
+      include: {
+        content: true
+      },
+      signal
+    });
+    if (!object?.content) {
+      throw new Error(
+        `Missing parameters object content for ${game} and coin type ${coinType}`
+      );
+    }
+    return gameDefinition.parameters.parse(
+      object.content
+    );
+  }
 };
 
 export { SuigarClient, suigar };

package/dist/utils.cjs

@@ -11,36 +11,48 @@ var RANGE_POINT_LIMIT = DEFAULT_RANGE_SCALE * 100;
 var DEFAULT_LIMBO_MULTIPLIER_SCALE = 100;
 
 // src/utils/numeric.ts
-function isFiniteNumber(value, message) {
-  if (typeof value !== "number") {
-    throw new Error(`${message}: ${String(value)}`);
-  }
-  if (!Number.isFinite(value)) {
-    throw new Error(`Value must be a finite number: ${value}`);
+function assertFiniteNumber(value, errorMessage) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(`${errorMessage}: ${String(value)}`);
   }
 }
 function toBigInt(value) {
-  if (typeof value === "bigint") {
-    if (value < 0n) {
-      throw new Error(`Value must be non-negative: ${value}`);
+  let result;
+  try {
+    if (typeof value === "bigint" || typeof value === "string" || typeof value === "boolean") {
+      result = BigInt(value);
+    } else {
+      assertFiniteNumber(
+        value,
+        "Value must be a bigint, number, integer string, or boolean"
+      );
+      result = BigInt(Math.trunc(value));
     }
-    return value;
+  } catch {
+    throw new TypeError(
+      `Value must be a bigint, number, integer string, or boolean: ${value}`
+    );
   }
-  isFiniteNumber(value, "Value must be a bigint or number");
-  if (value < 0) {
-    throw new Error(`Value must be a finite non-negative number: ${value}`);
+  if (result < 0n) {
+    throw new RangeError(`Value must be non-negative: ${value}`);
   }
-  return BigInt(Math.trunc(value));
+  return result;
+}
+function toBoundedInt(value, max, typeName) {
+  const num = typeof value === "string" && value.trim() === "" ? NaN : Number(value);
+  assertFiniteNumber(num, "Value must be a finite number or integer string");
+  if (typeof value === "boolean" || value == null || !Number.isInteger(num) || num < 0 || num > max) {
+    throw new RangeError(
+      `Value must be a ${typeName} integer (0-${max}): ${value}`
+    );
+  }
+  return num;
 }
 function toU8(value) {
-  isFiniteNumber(value, "Value must be a number");
-  if (!Number.isInteger(value)) {
-    throw new Error(`Value must be an integer: ${value}`);
-  }
-  if (value < 0 || value > 255) {
-    throw new Error(`Value must be an integer between 0 and 255: ${value}`);
-  }
-  return value;
+  return toBoundedInt(value, 255, "u8");
+}
+function toU16(value) {
+  return toBoundedInt(value, 65535, "u16");
 }
 utils.normalizeSuiAddress("0x1");
 utils.normalizeSuiAddress("0x2");
@@ -182,7 +194,7 @@ function fromMoveFloat(float) {
 function parseCoinType(type) {
   const coinType = utils.parseStructTag(type).typeParams[0];
   if (!coinType) {
-    throw new Error(`Unable to parse coin type from ${type}`);
+    throw new TypeError(`Unable to parse coin type from ${type}`);
   }
   return utils.normalizeStructTag(coinType);
 }
@@ -227,4 +239,5 @@ exports.fromMoveI64 = fromMoveI64;
 exports.parseCoinType = parseCoinType;
 exports.parseGameDetails = parseGameDetails;
 exports.toBigInt = toBigInt;
+exports.toU16 = toU16;
 exports.toU8 = toU8;