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

package/dist/chunk-W3WZ2BHO.js

@@ -0,0 +1,310 @@
+import { parseToMist, normalizeSuiAddress } from '@mysten/sui/utils';
+import { bcs, BcsStruct, TypeTagSerializer } from '@mysten/sui/bcs';
+import { isArgument } from '@mysten/sui/transactions';
+
+// src/utils/constants.ts
+var DEFAULT_GAS_BUDGET_MIST = parseToMist("0.05");
+var DEFAULT_RANGE_SCALE = 1e6;
+var RANGE_POINT_LIMIT = DEFAULT_RANGE_SCALE * 100;
+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 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) {
+  const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+  if (parameterNames && argLen !== parameterNames.length) {
+    throw new Error(
+      `Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`
+    );
+  }
+  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 {
+      if (!parameterNames) {
+        throw new Error(`Expected arguments to be passed as an array`);
+      }
+      const name = parameterNames[index];
+      arg = args[name];
+      if (arg === void 0) {
+        throw new Error(`Parameter ${name} is required`);
+      }
+    }
+    index += 1;
+    if (typeof arg === "function" || isArgument(arg)) {
+      normalizedArgs.push(arg);
+      continue;
+    }
+    const type = argTypes[i];
+    const bcsType = type === null ? null : getPureBcsSchema(type);
+    if (bcsType) {
+      const bytes = bcsType.serialize(arg);
+      normalizedArgs.push((tx) => tx.pure(bytes));
+      continue;
+    }
+    if (typeof arg === "string") {
+      normalizedArgs.push((tx) => tx.object(arg));
+      continue;
+    }
+    throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
+  }
+  return normalizedArgs;
+}
+var MoveStruct = class extends BcsStruct {
+  async get({
+    objectId,
+    ...options
+  }) {
+    const [res] = await this.getMany({
+      ...options,
+      objectIds: [objectId]
+    });
+    return res;
+  }
+  async getMany({
+    client,
+    ...options
+  }) {
+    const response = await client.core.getObjects({
+      ...options,
+      include: {
+        ...options.include,
+        content: true
+      }
+    });
+    return response.objects.map((obj) => {
+      if (obj instanceof Error) {
+        throw obj;
+      }
+      return {
+        ...obj,
+        json: this.parse(obj.content)
+      };
+    });
+  }
+};
+function stringify(val) {
+  if (typeof val === "object") {
+    return JSON.stringify(val, (val2) => val2);
+  }
+  if (typeof val === "bigint") {
+    return val.toString();
+  }
+  return val;
+}
+var $moduleName = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64";
+var I64 = new MoveStruct({ name: `${$moduleName}::I64`, fields: {
+  bits: bcs.u64()
+} });
+
+// src/contracts/core/float.ts
+var $moduleName2 = "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float";
+var Float = new MoveStruct({ name: `${$moduleName2}::Float`, fields: {
+  is_negative: bcs.bool(),
+  exp: I64,
+  mant: bcs.u64()
+} });
+
+// src/types/game-details.type.ts
+var COINFLIP_GAME_DETAILS_SCHEMA = {
+  player_bet: "string",
+  coin_outcome: "string"
+};
+var PVP_COINFLIP_GAME_DETAILS_SCHEMA = {
+  pvp_result: "string"
+};
+var LIMBO_GAME_DETAILS_SCHEMA = {
+  payout_amount: "u64",
+  win: "bool",
+  roll_multiplier: "float",
+  payout_multiplier: "float",
+  target_multiplier: "float",
+  actual_rtp: "float"
+};
+var RANGE_GAME_DETAILS_SCHEMA = {
+  roll_value: "u64",
+  win: "bool",
+  payout_amount: "u64",
+  payout_multiplier: "float",
+  left_point: "u64",
+  right_point: "u64",
+  zone_size: "u64",
+  winning_zone_size: "u64",
+  is_out_range: "bool",
+  bet_threshold: "u64",
+  roll_under: "bool",
+  range_mode: "u8",
+  win_probability: "float",
+  win_multiplier: "float",
+  actual_rtp: "float"
+};
+var PLINKO_GAME_DETAILS_SCHEMA = {
+  slot_index: "u8",
+  multiplier: "float",
+  payout_amount: "u64",
+  plinko_config: "u8"
+};
+var WHEEL_GAME_DETAILS_SCHEMA = {
+  case_index: "u8",
+  multiplier: "float",
+  payout_amount: "u64",
+  wheel_config: "u8",
+  spin_value: "u64"
+};
+var GAME_DETAILS_SCHEMA = {
+  ...COINFLIP_GAME_DETAILS_SCHEMA,
+  ...PVP_COINFLIP_GAME_DETAILS_SCHEMA,
+  ...LIMBO_GAME_DETAILS_SCHEMA,
+  ...RANGE_GAME_DETAILS_SCHEMA,
+  ...PLINKO_GAME_DETAILS_SCHEMA,
+  ...WHEEL_GAME_DETAILS_SCHEMA
+};
+
+// src/utils/parser.ts
+var bcsU8 = bcs.u8();
+var bcsU64 = bcs.u64();
+var bcsBool = bcs.bool();
+var bcsString = bcs.string();
+var textDecoder = new TextDecoder();
+var GAME_DETAIL_BCS = {
+  u8: bcsU8,
+  u64: bcsU64,
+  bool: bcsBool,
+  float: Float,
+  string: bcsString
+};
+function parseI64(i64) {
+  try {
+    const value = BigInt(i64.bits ?? 0);
+    const maxPositive = 1n << 63n;
+    const twoPow64 = 1n << 64n;
+    const signed = value >= maxPositive ? value - twoPow64 : value;
+    return Number(signed);
+  } catch {
+    return 0;
+  }
+}
+function parseFloat(float) {
+  const mantissa = BigInt(float.mant);
+  if (mantissa === 0n) {
+    return 0;
+  }
+  const exponent = parseI64(float.exp) - 52;
+  const magnitude = Number(mantissa) * Math.pow(2, exponent);
+  return float.is_negative ? -magnitude : magnitude;
+}
+function normalizeGameDetailValue(valueType, parsed) {
+  if (valueType === "float") {
+    return parseFloat(parsed);
+  }
+  if (valueType === "u64") {
+    return Number(parsed);
+  }
+  return parsed;
+}
+function parseStringGameDetail(value) {
+  const bytes = Uint8Array.from(value);
+  try {
+    return bcsString.parse(bytes);
+  } catch {
+    return textDecoder.decode(bytes);
+  }
+}
+function parseGameDetail(valueType, value) {
+  if (valueType === "string") {
+    return parseStringGameDetail(value);
+  }
+  const parsed = GAME_DETAIL_BCS[valueType].parse(Uint8Array.from(value));
+  return normalizeGameDetailValue(valueType, parsed);
+}
+function parseGameDetails(gameDetails) {
+  return gameDetails.contents.reduce((details, entry) => {
+    const valueType = GAME_DETAILS_SCHEMA[entry.key] ?? "string";
+    details[entry.key] = parseGameDetail(valueType, entry.value);
+    return details;
+  }, {});
+}
+
+export { DEFAULT_GAS_BUDGET_MIST, DEFAULT_LIMBO_MULTIPLIER_SCALE, DEFAULT_RANGE_SCALE, Float, MoveStruct, RANGE_POINT_LIMIT, normalizeMoveArguments, parseFloat, parseGameDetails, parseI64, toBigIntAmount, toU8Number };

package/dist/games-nFnPbPuK.d.cts

@@ -0,0 +1,84 @@
+declare const GAMES: readonly ["coinflip", "limbo", "plinko", "pvp-coinflip", "range", "wheel"];
+type Game = (typeof GAMES)[number];
+type StandardGame = Exclude<Game, PvPGame>;
+type PvPGame = 'pvp-coinflip';
+type CoinSide = 'heads' | 'tails';
+
+type BetMetadataPrimitive = string | number | boolean | bigint;
+type BetMetadataValue = BetMetadataPrimitive | Uint8Array | number[];
+type BetMetadataInput = Record<string, BetMetadataValue | null | undefined>;
+
+interface SuigarExtensionOptions<Name = 'suigar'> {
+    name?: Name;
+    partner?: string;
+}
+type SuigarCoin = 'sui' | 'usdc';
+type SuigarCoinTypes = Record<SuigarCoin, string>;
+type SuigarPackageKey = 'sweetHouse' | 'core' | 'coinflip' | 'limbo' | 'plinko' | 'pvpCoinflip' | 'range' | 'wheel';
+type SuigarPackage = Record<SuigarPackageKey, string>;
+type SuigarPriceInfoObjectId = Record<SuigarCoin, string>;
+type SuigarRegistryKey = 'pvpCoinflip';
+type SuigarRegistryId = Record<SuigarRegistryKey, string>;
+type SuigarConfig = {
+    packageIds: SuigarPackage;
+    registryIds: SuigarRegistryId;
+    coinTypes: SuigarCoinTypes;
+    priceInfoObjectIds: SuigarPriceInfoObjectId;
+};
+
+type SharedBetTransactionOptions = {
+    config: SuigarConfig;
+    owner: string;
+    coinType: string;
+    stake: number | bigint;
+    cashStake?: number | bigint;
+    betCount?: number | bigint;
+    metadata?: BetMetadataInput;
+    gasBudget?: number | bigint;
+    sender?: string;
+    allowGasCoinShortcut?: boolean;
+};
+
+type BuildCoinflipTransactionOptions = SharedBetTransactionOptions & {
+    side: CoinSide;
+};
+type BuildLimboTransactionOptions = SharedBetTransactionOptions & {
+    targetMultiplier: number;
+    scale?: number;
+};
+type BuildPlinkoTransactionOptions = SharedBetTransactionOptions & {
+    configId: number;
+};
+type BuildRangeTransactionOptions = SharedBetTransactionOptions & {
+    leftPoint: number;
+    rightPoint: number;
+    outOfRange?: boolean;
+    scale?: number;
+};
+type BuildWheelTransactionOptions = SharedBetTransactionOptions & {
+    configId: number;
+};
+type PvPCoinflipAction = 'create' | 'join' | 'cancel';
+type SharedPvPCoinflipTransactionOptions = {
+    config: SuigarConfig;
+    owner: string;
+    coinType: string;
+    metadata?: BetMetadataInput;
+    gasBudget?: number | bigint;
+    sender?: string;
+    allowGasCoinShortcut?: boolean;
+};
+type BuildCreatePvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    stake: number | bigint;
+    side: CoinSide;
+    isPrivate?: boolean;
+};
+type BuildJoinPvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    gameId: string;
+};
+type BuildCancelPvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    gameId: string;
+};
+type BuildPvPCoinflipTransactionOptions<Action extends PvPCoinflipAction = PvPCoinflipAction> = Action extends 'create' ? BuildCreatePvPCoinflipTransactionOptions : Action extends 'join' ? BuildJoinPvPCoinflipTransactionOptions : Action extends 'cancel' ? BuildCancelPvPCoinflipTransactionOptions : never;
+
+export type { BuildCoinflipTransactionOptions as B, CoinSide as C, PvPCoinflipAction as P, StandardGame as S, BuildWheelTransactionOptions as a, BuildLimboTransactionOptions as b, BuildPlinkoTransactionOptions as c, BuildRangeTransactionOptions as d, SuigarConfig as e, BuildPvPCoinflipTransactionOptions as f, SuigarExtensionOptions as g, BuildCancelPvPCoinflipTransactionOptions as h, BuildCreatePvPCoinflipTransactionOptions as i, BuildJoinPvPCoinflipTransactionOptions as j };

package/dist/games-nFnPbPuK.d.ts

@@ -0,0 +1,84 @@
+declare const GAMES: readonly ["coinflip", "limbo", "plinko", "pvp-coinflip", "range", "wheel"];
+type Game = (typeof GAMES)[number];
+type StandardGame = Exclude<Game, PvPGame>;
+type PvPGame = 'pvp-coinflip';
+type CoinSide = 'heads' | 'tails';
+
+type BetMetadataPrimitive = string | number | boolean | bigint;
+type BetMetadataValue = BetMetadataPrimitive | Uint8Array | number[];
+type BetMetadataInput = Record<string, BetMetadataValue | null | undefined>;
+
+interface SuigarExtensionOptions<Name = 'suigar'> {
+    name?: Name;
+    partner?: string;
+}
+type SuigarCoin = 'sui' | 'usdc';
+type SuigarCoinTypes = Record<SuigarCoin, string>;
+type SuigarPackageKey = 'sweetHouse' | 'core' | 'coinflip' | 'limbo' | 'plinko' | 'pvpCoinflip' | 'range' | 'wheel';
+type SuigarPackage = Record<SuigarPackageKey, string>;
+type SuigarPriceInfoObjectId = Record<SuigarCoin, string>;
+type SuigarRegistryKey = 'pvpCoinflip';
+type SuigarRegistryId = Record<SuigarRegistryKey, string>;
+type SuigarConfig = {
+    packageIds: SuigarPackage;
+    registryIds: SuigarRegistryId;
+    coinTypes: SuigarCoinTypes;
+    priceInfoObjectIds: SuigarPriceInfoObjectId;
+};
+
+type SharedBetTransactionOptions = {
+    config: SuigarConfig;
+    owner: string;
+    coinType: string;
+    stake: number | bigint;
+    cashStake?: number | bigint;
+    betCount?: number | bigint;
+    metadata?: BetMetadataInput;
+    gasBudget?: number | bigint;
+    sender?: string;
+    allowGasCoinShortcut?: boolean;
+};
+
+type BuildCoinflipTransactionOptions = SharedBetTransactionOptions & {
+    side: CoinSide;
+};
+type BuildLimboTransactionOptions = SharedBetTransactionOptions & {
+    targetMultiplier: number;
+    scale?: number;
+};
+type BuildPlinkoTransactionOptions = SharedBetTransactionOptions & {
+    configId: number;
+};
+type BuildRangeTransactionOptions = SharedBetTransactionOptions & {
+    leftPoint: number;
+    rightPoint: number;
+    outOfRange?: boolean;
+    scale?: number;
+};
+type BuildWheelTransactionOptions = SharedBetTransactionOptions & {
+    configId: number;
+};
+type PvPCoinflipAction = 'create' | 'join' | 'cancel';
+type SharedPvPCoinflipTransactionOptions = {
+    config: SuigarConfig;
+    owner: string;
+    coinType: string;
+    metadata?: BetMetadataInput;
+    gasBudget?: number | bigint;
+    sender?: string;
+    allowGasCoinShortcut?: boolean;
+};
+type BuildCreatePvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    stake: number | bigint;
+    side: CoinSide;
+    isPrivate?: boolean;
+};
+type BuildJoinPvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    gameId: string;
+};
+type BuildCancelPvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+    gameId: string;
+};
+type BuildPvPCoinflipTransactionOptions<Action extends PvPCoinflipAction = PvPCoinflipAction> = Action extends 'create' ? BuildCreatePvPCoinflipTransactionOptions : Action extends 'join' ? BuildJoinPvPCoinflipTransactionOptions : Action extends 'cancel' ? BuildCancelPvPCoinflipTransactionOptions : never;
+
+export type { BuildCoinflipTransactionOptions as B, CoinSide as C, PvPCoinflipAction as P, StandardGame as S, BuildWheelTransactionOptions as a, BuildLimboTransactionOptions as b, BuildPlinkoTransactionOptions as c, BuildRangeTransactionOptions as d, SuigarConfig as e, BuildPvPCoinflipTransactionOptions as f, SuigarExtensionOptions as g, BuildCancelPvPCoinflipTransactionOptions as h, BuildCreatePvPCoinflipTransactionOptions as i, BuildJoinPvPCoinflipTransactionOptions as j };

package/dist/games.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/games.d.cts

@@ -0,0 +1 @@
+export { h as BuildCancelPvPCoinflipTransactionOptions, B as BuildCoinflipTransactionOptions, i as BuildCreatePvPCoinflipTransactionOptions, j as BuildJoinPvPCoinflipTransactionOptions, b as BuildLimboTransactionOptions, c as BuildPlinkoTransactionOptions, d as BuildRangeTransactionOptions, a as BuildWheelTransactionOptions, C as CoinSide, P as PvPCoinflipAction } from './games-nFnPbPuK.cjs';

package/dist/games.d.ts

@@ -0,0 +1 @@
+export { h as BuildCancelPvPCoinflipTransactionOptions, B as BuildCoinflipTransactionOptions, i as BuildCreatePvPCoinflipTransactionOptions, j as BuildJoinPvPCoinflipTransactionOptions, b as BuildLimboTransactionOptions, c as BuildPlinkoTransactionOptions, d as BuildRangeTransactionOptions, a as BuildWheelTransactionOptions, C as CoinSide, P as PvPCoinflipAction } from './games-nFnPbPuK.js';

package/dist/games.js

@@ -0,0 +1 @@
+

package/dist/index-jwSXA8q3.d.cts

@@ -0,0 +1,25 @@
+import { BcsType, BcsStruct } from '@mysten/sui/bcs';
+import { SuiClientTypes, ClientWithCoreApi } from '@mysten/sui/client';
+
+interface GetOptions<Include extends Omit<SuiClientTypes.ObjectInclude, 'content'> = {}> extends SuiClientTypes.GetObjectOptions<Include> {
+    client: ClientWithCoreApi;
+}
+interface GetManyOptions<Include extends Omit<SuiClientTypes.ObjectInclude, 'content'> = {}> extends SuiClientTypes.GetObjectsOptions<Include> {
+    client: ClientWithCoreApi;
+}
+declare class MoveStruct<T extends Record<string, BcsType<any>>, const Name extends string = string> extends BcsStruct<T, Name> {
+    get<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({ objectId, ...options }: GetOptions<Include>): Promise<SuiClientTypes.Object<Include & {
+        content: true;
+        json: true;
+    }> & {
+        json: BcsStruct<T>['$inferType'];
+    }>;
+    getMany<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({ client, ...options }: GetManyOptions<Include>): Promise<Array<SuiClientTypes.Object<Include & {
+        content: true;
+        json: true;
+    }> & {
+        json: BcsStruct<T>['$inferType'];
+    }>>;
+}
+
+export { MoveStruct as M };

package/dist/index-jwSXA8q3.d.ts

@@ -0,0 +1,25 @@
+import { BcsType, BcsStruct } from '@mysten/sui/bcs';
+import { SuiClientTypes, ClientWithCoreApi } from '@mysten/sui/client';
+
+interface GetOptions<Include extends Omit<SuiClientTypes.ObjectInclude, 'content'> = {}> extends SuiClientTypes.GetObjectOptions<Include> {
+    client: ClientWithCoreApi;
+}
+interface GetManyOptions<Include extends Omit<SuiClientTypes.ObjectInclude, 'content'> = {}> extends SuiClientTypes.GetObjectsOptions<Include> {
+    client: ClientWithCoreApi;
+}
+declare class MoveStruct<T extends Record<string, BcsType<any>>, const Name extends string = string> extends BcsStruct<T, Name> {
+    get<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({ objectId, ...options }: GetOptions<Include>): Promise<SuiClientTypes.Object<Include & {
+        content: true;
+        json: true;
+    }> & {
+        json: BcsStruct<T>['$inferType'];
+    }>;
+    getMany<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({ client, ...options }: GetManyOptions<Include>): Promise<Array<SuiClientTypes.Object<Include & {
+        content: true;
+        json: true;
+    }> & {
+        json: BcsStruct<T>['$inferType'];
+    }>>;
+}
+
+export { MoveStruct as M };