@suigar/sdk 2.0.0-beta.13 → 2.0.0-beta.15

package/dist/types/game-settings.type.d.mts

@@ -0,0 +1,201 @@
+import { Game } from "./game.type.mjs";
+import { MoveStruct } from "../contracts/utils/index.mjs";
+import { SuiClientTypes } from "@mysten/sui/client";
+import * as _$_mysten_bcs0 from "@mysten/bcs";
+
+//#region src/types/game-settings.type.d.ts
+declare const GAME_SETTINGS: {
+  readonly coinflip: {
+    readonly settingsKey: MoveStruct<{
+      dummy_field: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+    }, "0xb35c5f286c443752afc8ccb40125a578a4f32df35617170ccfa17fe180ab80ea::coinflip::CoinFlipSettingsKey">;
+    readonly parameters: MoveStruct<{
+      id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      house_edge: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      min_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      max_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+    }, "0xb35c5f286c443752afc8ccb40125a578a4f32df35617170ccfa17fe180ab80ea::coinflip::Parameters<phantom T0>">;
+  };
+  readonly limbo: {
+    readonly settingsKey: MoveStruct<{
+      dummy_field: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+    }, "0x96c7841b9b32c59a219760fd656f1c3aceb53cc74a68ec9844a3a696374309f4::limbo::LimboSettingsKey">;
+    readonly parameters: MoveStruct<{
+      id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      min_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      max_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      max_payout: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      min_target_multiplier: MoveStruct<{
+        is_negative: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+          bits: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+      max_target_multiplier: MoveStruct<{
+        is_negative: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+          bits: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+      max_number_of_games: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      min_rtp: MoveStruct<{
+        is_negative: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+          bits: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+      max_rtp: MoveStruct<{
+        is_negative: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+          bits: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+    }, "0x96c7841b9b32c59a219760fd656f1c3aceb53cc74a68ec9844a3a696374309f4::limbo::Parameters<phantom T0>">;
+  };
+  readonly plinko: {
+    readonly settingsKey: MoveStruct<{
+      dummy_field: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+    }, "0xd3dd2200883af10811724f0bed97591ad155a02efd6332d471ff8b346030dfb7::plinko::PlinkoSettingsKey">;
+    readonly parameters: MoveStruct<{
+      id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      min_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      max_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      max_number_of_balls: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      configs: MoveStruct<{
+        contents: _$_mysten_bcs0.BcsType<{
+          key: number;
+          value: {
+            num_rows: number;
+            multipliers: {
+              is_negative: boolean;
+              exp: {
+                bits: string;
+              };
+              mant: string;
+            }[];
+            min_stake: string;
+            max_stake: string;
+            is_playable: boolean;
+          };
+        }[], Iterable<{
+          key: number;
+          value: {
+            num_rows: number;
+            multipliers: Iterable<{
+              is_negative: boolean;
+              exp: {
+                bits: string | number | bigint;
+              };
+              mant: string | number | bigint;
+            }> & {
+              length: number;
+            };
+            min_stake: string | number | bigint;
+            max_stake: string | number | bigint;
+            is_playable: boolean;
+          };
+        }> & {
+          length: number;
+        }, string>;
+      }, "0x2::vec_map::VecMap<u8, 0xd3dd2200883af10811724f0bed97591ad155a02efd6332d471ff8b346030dfb7::plinko::PlinkoConfig>">;
+    }, "0xd3dd2200883af10811724f0bed97591ad155a02efd6332d471ff8b346030dfb7::plinko::Parameters<phantom T0>">;
+  };
+  readonly 'pvp-coinflip': {
+    readonly settingsKey: MoveStruct<{
+      dummy_field: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+    }, "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip::PvpCoinflipSettingsKey">;
+    readonly parameters: MoveStruct<{
+      id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      house_edge_bps: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      min_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+    }, "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip::Parameters<phantom T0>">;
+  };
+  readonly range: {
+    readonly settingsKey: MoveStruct<{
+      dummy_field: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+    }, "0x096a4cf18b3661e76b2c62b90785418345d52f45b272448794f123a4cb6b6416::range::RangeSettingsKey">;
+    readonly parameters: MoveStruct<{
+      id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      min_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      max_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      min_zone_size: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      max_zone_size: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      max_number_of_games: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      min_rtp: MoveStruct<{
+        is_negative: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+          bits: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+      max_rtp: MoveStruct<{
+        is_negative: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+          bits: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+    }, "0x096a4cf18b3661e76b2c62b90785418345d52f45b272448794f123a4cb6b6416::range::Parameters<phantom T0>">;
+  };
+  readonly wheel: {
+    readonly settingsKey: MoveStruct<{
+      dummy_field: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+    }, "0x0997852ded7e13301c42317004bc49704a893aa82997c5706cebee59053a31b7::wheel::WheelSettingsKey">;
+    readonly parameters: MoveStruct<{
+      id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      min_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      max_stake: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      max_number_of_spins: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      configs: MoveStruct<{
+        contents: _$_mysten_bcs0.BcsType<{
+          key: number;
+          value: {
+            num_cases: number;
+            multipliers: {
+              is_negative: boolean;
+              exp: {
+                bits: string;
+              };
+              mant: string;
+            }[];
+            min_stake: string;
+            max_stake: string;
+            is_playable: boolean;
+          };
+        }[], Iterable<{
+          key: number;
+          value: {
+            num_cases: number;
+            multipliers: Iterable<{
+              is_negative: boolean;
+              exp: {
+                bits: string | number | bigint;
+              };
+              mant: string | number | bigint;
+            }> & {
+              length: number;
+            };
+            min_stake: string | number | bigint;
+            max_stake: string | number | bigint;
+            is_playable: boolean;
+          };
+        }> & {
+          length: number;
+        }, string>;
+      }, "0x2::vec_map::VecMap<u8, 0x0997852ded7e13301c42317004bc49704a893aa82997c5706cebee59053a31b7::wheel::WheelConfig>">;
+    }, "0x0997852ded7e13301c42317004bc49704a893aa82997c5706cebee59053a31b7::wheel::Parameters<phantom T0>">;
+  };
+};
+type GameParametersMap = { [TGame in Game]: ReturnType<(typeof GAME_SETTINGS)[TGame]['parameters']['parse']> };
+type GameParameters<TGame extends Game> = GameParametersMap[TGame];
+type GetGameParametersOptions = SuiClientTypes.CoreClientMethodOptions & {
+  coinType?: string;
+  ignoreCache?: boolean;
+};
+//#endregion
+export { GameParameters, GetGameParametersOptions };
+//# sourceMappingURL=game-settings.type.d.mts.map

package/dist/types/game-settings.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"game-settings.type.d.mts","names":[],"sources":["../../src/types/game-settings.type.ts"],"mappings":";;;;;;cA8Ba,aAAA;EAAA;;mBAyBH,cAAA,CAAA,OAAA;IAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEL,iBAAA,eACM,IAAA,GAAO,UAAA,SACR,aAAA,EAAe,KAAA;AAAA,KAIb,cAAA,eAA6B,IAAA,IAAQ,iBAAA,CAAkB,KAAA;AAAA,KAEvD,wBAAA,GACX,cAAA,CAAe,uBAAA;EACd,QAAA;EACA,WAAA;AAAA"}

package/dist/types/game-settings.type.mjs

@@ -0,0 +1,37 @@
+import { Parameters, PvpCoinflipSettingsKey } from "../contracts/pvp-coinflip/pvp_coinflip.mjs";
+import { CoinFlipSettingsKey, Parameters as Parameters$1 } from "../contracts/coinflip/coinflip.mjs";
+import { LimboSettingsKey, Parameters as Parameters$2 } from "../contracts/limbo/limbo.mjs";
+import { Parameters as Parameters$3, PlinkoSettingsKey } from "../contracts/plinko/plinko.mjs";
+import { Parameters as Parameters$4, RangeSettingsKey } from "../contracts/range/range.mjs";
+import { Parameters as Parameters$5, WheelSettingsKey } from "../contracts/wheel/wheel.mjs";
+//#region src/types/game-settings.type.ts
+const GAME_SETTINGS = {
+	coinflip: {
+		settingsKey: CoinFlipSettingsKey,
+		parameters: Parameters$1
+	},
+	limbo: {
+		settingsKey: LimboSettingsKey,
+		parameters: Parameters$2
+	},
+	plinko: {
+		settingsKey: PlinkoSettingsKey,
+		parameters: Parameters$3
+	},
+	"pvp-coinflip": {
+		settingsKey: PvpCoinflipSettingsKey,
+		parameters: Parameters
+	},
+	range: {
+		settingsKey: RangeSettingsKey,
+		parameters: Parameters$4
+	},
+	wheel: {
+		settingsKey: WheelSettingsKey,
+		parameters: Parameters$5
+	}
+};
+//#endregion
+export { GAME_SETTINGS };
+
+//# sourceMappingURL=game-settings.type.mjs.map

package/dist/types/game-settings.type.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"game-settings.type.mjs","names":["CoinflipParameters","LimboParameters","PlinkoParameters","PvPCoinflipParameters","RangeParameters","WheelParameters"],"sources":["../../src/types/game-settings.type.ts"],"sourcesContent":["// Copyright (c) Suigar\n// SPDX-License-Identifier: Apache-2.0\n\nimport { SuiClientTypes } from '@mysten/sui/client';\nimport {\n\tParameters as CoinflipParameters,\n\tCoinFlipSettingsKey,\n} from '../contracts/coinflip/coinflip';\nimport {\n\tParameters as LimboParameters,\n\tLimboSettingsKey,\n} from '../contracts/limbo/limbo';\nimport {\n\tParameters as PlinkoParameters,\n\tPlinkoSettingsKey,\n} from '../contracts/plinko/plinko';\nimport {\n\tParameters as PvPCoinflipParameters,\n\tPvpCoinflipSettingsKey,\n} from '../contracts/pvp-coinflip/pvp_coinflip';\nimport {\n\tParameters as RangeParameters,\n\tRangeSettingsKey,\n} from '../contracts/range/range';\nimport {\n\tParameters as WheelParameters,\n\tWheelSettingsKey,\n} from '../contracts/wheel/wheel';\nimport type { Game } from './game.type.js';\n\nexport const GAME_SETTINGS = {\n\tcoinflip: {\n\t\tsettingsKey: CoinFlipSettingsKey,\n\t\tparameters: CoinflipParameters,\n\t},\n\tlimbo: {\n\t\tsettingsKey: LimboSettingsKey,\n\t\tparameters: LimboParameters,\n\t},\n\tplinko: {\n\t\tsettingsKey: PlinkoSettingsKey,\n\t\tparameters: PlinkoParameters,\n\t},\n\t'pvp-coinflip': {\n\t\tsettingsKey: PvpCoinflipSettingsKey,\n\t\tparameters: PvPCoinflipParameters,\n\t},\n\trange: {\n\t\tsettingsKey: RangeSettingsKey,\n\t\tparameters: RangeParameters,\n\t},\n\twheel: {\n\t\tsettingsKey: WheelSettingsKey,\n\t\tparameters: WheelParameters,\n\t},\n} as const;\n\ntype GameParametersMap = {\n\t[TGame in Game]: ReturnType<\n\t\t(typeof GAME_SETTINGS)[TGame]['parameters']['parse']\n\t>;\n};\n\nexport type GameParameters<TGame extends Game> = GameParametersMap[TGame];\n\nexport type GetGameParametersOptions =\n\tSuiClientTypes.CoreClientMethodOptions & {\n\t\tcoinType?: string;\n\t\tignoreCache?: boolean;\n\t};\n"],"mappings":";;;;;;;AA8BA,MAAa,gBAAgB;CAC5B,UAAU;EACT,aAAa;EACb,YAAYA;EACZ;CACD,OAAO;EACN,aAAa;EACb,YAAYC;EACZ;CACD,QAAQ;EACP,aAAa;EACb,YAAYC;EACZ;CACD,gBAAgB;EACf,aAAa;EACb,YAAYC;EACZ;CACD,OAAO;EACN,aAAa;EACb,YAAYC;EACZ;CACD,OAAO;EACN,aAAa;EACb,YAAYC;EACZ;CACD"}

package/dist/types/game.type.d.mts

@@ -0,0 +1,15 @@
+//#region src/types/game.type.d.ts
+declare const GAMES: readonly ["coinflip", "limbo", "plinko", "pvp-coinflip", "range", "wheel"];
+declare const GAME_EVENTS: readonly ["BetResultEvent", "GameCreatedEvent", "GameResolvedEvent", "GameCancelledEvent"];
+type Game = (typeof GAMES)[number];
+type StandardGame = Exclude<Game, PvPGame>;
+type PvPGame = Extract<Game, `pvp-${string}`>;
+type CoinSide = 'heads' | 'tails';
+type GameEvent = (typeof GAME_EVENTS)[number];
+type SuigarGameEvent = {
+  gameId: Game;
+  eventName: GameEvent;
+};
+//#endregion
+export { CoinSide, GAMES, GAME_EVENTS, Game, GameEvent, PvPGame, StandardGame, SuigarGameEvent };
+//# sourceMappingURL=game.type.d.mts.map

package/dist/types/game.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"game.type.d.mts","names":[],"sources":["../../src/types/game.type.ts"],"mappings":";cAGa,KAAA;AAAA,cASA,WAAA;AAAA,KAOD,IAAA,WAAe,KAAA;AAAA,KAEf,YAAA,GAAe,OAAA,CAAQ,IAAA,EAAM,OAAA;AAAA,KAC7B,OAAA,GAAU,OAAA,CAAQ,IAAA;AAAA,KAElB,QAAA;AAAA,KAEA,SAAA,WAAoB,WAAA;AAAA,KAEpB,eAAA;EACX,MAAA,EAAQ,IAAA;EACR,SAAA,EAAW,SAAA;AAAA"}

package/dist/types/game.type.mjs

@@ -0,0 +1,19 @@
+//#region src/types/game.type.ts
+const GAMES = [
+	"coinflip",
+	"limbo",
+	"plinko",
+	"pvp-coinflip",
+	"range",
+	"wheel"
+];
+const GAME_EVENTS = [
+	"BetResultEvent",
+	"GameCreatedEvent",
+	"GameResolvedEvent",
+	"GameCancelledEvent"
+];
+//#endregion
+export { GAMES, GAME_EVENTS };
+
+//# sourceMappingURL=game.type.mjs.map

package/dist/types/game.type.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"game.type.mjs","names":[],"sources":["../../src/types/game.type.ts"],"sourcesContent":["// Copyright (c) Suigar\n// SPDX-License-Identifier: Apache-2.0\n\nexport const GAMES = [\n\t'coinflip',\n\t'limbo',\n\t'plinko',\n\t'pvp-coinflip',\n\t'range',\n\t'wheel',\n] as const;\n\nexport const GAME_EVENTS = [\n\t'BetResultEvent',\n\t'GameCreatedEvent',\n\t'GameResolvedEvent',\n\t'GameCancelledEvent',\n] as const;\n\nexport type Game = (typeof GAMES)[number];\n\nexport type StandardGame = Exclude<Game, PvPGame>;\nexport type PvPGame = Extract<Game, `pvp-${string}`>;\n\nexport type CoinSide = 'heads' | 'tails';\n\nexport type GameEvent = (typeof GAME_EVENTS)[number];\n\nexport type SuigarGameEvent = {\n\tgameId: Game;\n\teventName: GameEvent;\n};\n"],"mappings":";AAGA,MAAa,QAAQ;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;AAED,MAAa,cAAc;CAC1B;CACA;CACA;CACA;CACA"}

package/dist/types/index.d.mts

@@ -0,0 +1,7 @@
+import { CoinSide, GAMES, GAME_EVENTS, Game, GameEvent, PvPGame, StandardGame, SuigarGameEvent } from "./game.type.mjs";
+import { BetMetadataInput, BetMetadataPrimitive, BetMetadataValue } from "./bet-metadata.type.mjs";
+import { SuigarCoin, SuigarCoinTypes, SuigarConfig, SuigarExtensionOptions, SuigarPackage, SuigarPackageIds, SuigarPriceInfoObjectIds, SuigarRegistry, SuigarRegistryIds } from "./suigar-config.type.mjs";
+import { BaseTransactionOptions, BuildCancelPvPCoinflipTransactionOptions, BuildCoinflipTransactionOptions, BuildCreatePvPCoinflipTransactionOptions, BuildJoinPvPCoinflipTransactionOptions, BuildLimboTransactionOptions, BuildPlinkoTransactionOptions, BuildPvPCoinflipTransactionOptions, BuildRangeTransactionOptions, BuildWheelTransactionOptions, CoinTransactionOptions, PvPCoinflipAction, SharedBetTransactionOptions, SharedPvPCoinflipTransactionOptions, StakeTransactionOptions, WithGasBudget, WithThrowOnError } from "./transaction-options.type.mjs";
+import { BuildGameOptions } from "./build-game-transaction-options.type.mjs";
+import { BetResultGameDetails, GAME_DETAILS_SCHEMAS, GAME_DETAIL_BCS, GameDetail, GameDetailValueType, GameDetails } from "./game-details.type.mjs";
+import { MoveFloat } from "./move-float.type.mjs";

package/dist/types/move-float.type.d.mts

@@ -0,0 +1,7 @@
+import { Float } from "../contracts/core/float.mjs";
+
+//#region src/types/move-float.type.d.ts
+type MoveFloat = ReturnType<(typeof Float)['parse']>;
+//#endregion
+export { MoveFloat };
+//# sourceMappingURL=move-float.type.d.mts.map

package/dist/types/move-float.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-float.type.d.mts","names":[],"sources":["../../src/types/move-float.type.ts"],"mappings":";;;KAKY,SAAA,GAAY,UAAA,SAAmB,KAAA"}

package/dist/types/network.type.d.mts

@@ -0,0 +1 @@
+import { SuiClientTypes } from "@mysten/sui/client";

package/dist/types/network.type.mjs

@@ -0,0 +1,6 @@
+//#region src/types/network.type.ts
+const SUPPORTED_SUI_NETWORKS = ["mainnet", "testnet"];
+//#endregion
+export { SUPPORTED_SUI_NETWORKS };
+
+//# sourceMappingURL=network.type.mjs.map

package/dist/types/network.type.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.type.mjs","names":[],"sources":["../../src/types/network.type.ts"],"sourcesContent":["// Copyright (c) Suigar\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { SuiClientTypes } from '@mysten/sui/client';\n\nexport type SuiNetwork = Extract<SuiClientTypes.Network, 'mainnet' | 'testnet'>;\n\nexport const SUPPORTED_SUI_NETWORKS: SuiClientTypes.Network[] = [\n\t'mainnet',\n\t'testnet',\n];\n"],"mappings":";AAOA,MAAa,yBAAmD,CAC/D,WACA,UACA"}

package/dist/types/suigar-config.type.d.mts

@@ -0,0 +1,33 @@
+//#region src/types/suigar-config.type.d.ts
+interface SuigarExtensionOptions<Name = 'suigar'> {
+  name?: Name;
+  /**
+   * Partner wallet address injected into bet metadata for attribution.
+   *
+   * Configure this once when registering the `suigar()` client extension
+   * instead of passing partner data through per-transaction metadata.
+   */
+  partner?: string;
+  /**
+   * Cache TTL in milliseconds for SDK-managed on-chain config lookups.
+   *
+   * Defaults to 30 minutes.
+   */
+  cacheTtl?: number;
+}
+type SuigarCoin = 'sui' | 'usdc';
+type SuigarCoinTypes = Record<SuigarCoin, string>;
+type SuigarPackage = 'sweetHouse' | 'core' | 'coinflip' | 'limbo' | 'plinko' | 'pvpCoinflip' | 'range' | 'wheel';
+type SuigarPackageIds = Record<SuigarPackage, string>;
+type SuigarRegistry = 'pvpCoinflip';
+type SuigarRegistryIds = Record<SuigarRegistry, string>;
+type SuigarPriceInfoObjectIds = Record<SuigarCoin, string>;
+type SuigarConfig = {
+  packageIds: SuigarPackageIds;
+  registryIds: SuigarRegistryIds;
+  coinTypes: SuigarCoinTypes;
+  priceInfoObjectIds: SuigarPriceInfoObjectIds;
+};
+//#endregion
+export { SuigarCoin, SuigarCoinTypes, SuigarConfig, SuigarExtensionOptions, SuigarPackage, SuigarPackageIds, SuigarPriceInfoObjectIds, SuigarRegistry, SuigarRegistryIds };
+//# sourceMappingURL=suigar-config.type.d.mts.map

package/dist/types/suigar-config.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suigar-config.type.d.mts","names":[],"sources":["../../src/types/suigar-config.type.ts"],"mappings":";UAKiB,sBAAA;EAChB,IAAA,GAAO,IAAA;EADS;;;;;;EAQhB,OAAA;EAAA;;;;AASD;EAHC,QAAA;AAAA;AAAA,KAGW,UAAA;AAAA,KAEA,eAAA,GAAkB,MAAA,CAAO,UAAA;AAAA,KAEzB,aAAA;AAAA,KASA,gBAAA,GAAmB,MAAA,CAAO,aAAA;AAAA,KAE1B,cAAA;AAAA,KACA,iBAAA,GAAoB,MAAA,CAAO,cAAA;AAAA,KAE3B,wBAAA,GAA2B,MAAA,CAAO,UAAA;AAAA,KAIlC,YAAA;EACX,UAAA,EAAY,gBAAA;EACZ,WAAA,EAAa,iBAAA;EACb,SAAA,EAAW,eAAA;EACX,kBAAA,EAAoB,wBAAA;AAAA"}

package/dist/types/transaction-options.type.d.mts

@@ -0,0 +1,63 @@
+import { CoinSide } from "./game.type.mjs";
+import { BetMetadataInput } from "./bet-metadata.type.mjs";
+import { SuigarConfig } from "./suigar-config.type.mjs";
+import { Transaction } from "@mysten/sui/transactions";
+
+//#region src/types/transaction-options.type.d.ts
+type WithGasBudget = {
+  gasBudget?: Parameters<Transaction['setGasBudgetIfNotSet']>[0];
+};
+type WithThrowOnError<T = object> = T & {
+  throwOnError?: boolean;
+};
+type BaseTransactionOptions = WithGasBudget & {
+  config: SuigarConfig;
+  playerAddress: string;
+};
+type CoinTransactionOptions = {
+  coinType: string;
+  metadata?: BetMetadataInput;
+  allowGasCoinShortcut?: boolean;
+};
+type StakeTransactionOptions = {
+  stake: number | bigint;
+  cashStake?: number | bigint;
+  betCount?: number | bigint;
+};
+type SharedBetTransactionOptions = BaseTransactionOptions & CoinTransactionOptions & StakeTransactionOptions;
+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 = BaseTransactionOptions & CoinTransactionOptions;
+type BuildCreatePvPCoinflipTransactionOptions = SharedPvPCoinflipTransactionOptions & {
+  stake: StakeTransactionOptions['stake'];
+  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;
+//#endregion
+export { BaseTransactionOptions, BuildCancelPvPCoinflipTransactionOptions, BuildCoinflipTransactionOptions, BuildCreatePvPCoinflipTransactionOptions, BuildJoinPvPCoinflipTransactionOptions, BuildLimboTransactionOptions, BuildPlinkoTransactionOptions, BuildPvPCoinflipTransactionOptions, BuildRangeTransactionOptions, BuildWheelTransactionOptions, CoinTransactionOptions, PvPCoinflipAction, SharedBetTransactionOptions, SharedPvPCoinflipTransactionOptions, StakeTransactionOptions, WithGasBudget, WithThrowOnError };
+//# sourceMappingURL=transaction-options.type.d.mts.map

package/dist/types/transaction-options.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-options.type.d.mts","names":[],"sources":["../../src/types/transaction-options.type.ts"],"mappings":";;;;;;KAQY,aAAA;EACX,SAAA,GAAY,UAAA,CAAW,WAAA;AAAA;AAAA,KAOZ,gBAAA,eAA+B,CAAA;EAC1C,YAAA;AAAA;AAAA,KAGW,sBAAA,GAAyB,aAAA;EACpC,MAAA,EAAQ,YAAA;EACR,aAAA;AAAA;AAAA,KAGW,sBAAA;EACX,QAAA;EACA,QAAA,GAAW,gBAAA;EACX,oBAAA;AAAA;AAAA,KAGW,uBAAA;EACX,KAAA;EACA,SAAA;EACA,QAAA;AAAA;AAAA,KAGW,2BAAA,GAA8B,sBAAA,GACzC,sBAAA,GACA,uBAAA;AAAA,KAEW,+BAAA,GAAkC,2BAAA;EAC7C,IAAA,EAAM,QAAA;AAAA;AAAA,KAGK,4BAAA,GAA+B,2BAAA;EAC1C,gBAAA;EACA,KAAA;AAAA;AAAA,KAGW,6BAAA,GAAgC,2BAAA;EAC3C,QAAA;AAAA;AAAA,KAGW,4BAAA,GAA+B,2BAAA;EAC1C,SAAA;EACA,UAAA;EACA,UAAA;EACA,KAAA;AAAA;AAAA,KAGW,4BAAA,GAA+B,2BAAA;EAC1C,QAAA;AAAA;AAAA,KAGW,iBAAA;AAAA,KAEA,mCAAA,GAAsC,sBAAA,GACjD,sBAAA;AAAA,KAEW,wCAAA,GACX,mCAAA;EACC,KAAA,EAAO,uBAAA;EACP,IAAA,EAAM,QAAA;EACN,SAAA;AAAA;AAAA,KAGU,sCAAA,GACX,mCAAA;EACC,MAAA;AAAA;AAAA,KAQU,wCAAA,GACX,mCAAA;EACC,MAAA;AAAA;AAAA,KAGU,kCAAA,gBACI,iBAAA,GAAoB,iBAAA,IAChC,MAAA,oBACD,wCAAA,GACA,MAAA,kBACC,sCAAA,GACA,MAAA,oBACC,wCAAA"}

package/dist/utils/constants.d.mts

@@ -0,0 +1,8 @@
+//#region src/utils/constants.d.ts
+declare const DEFAULT_GAS_BUDGET_MIST: bigint;
+declare const DEFAULT_RANGE_SCALE = 1000000;
+declare const RANGE_POINT_LIMIT: number;
+declare const DEFAULT_LIMBO_MULTIPLIER_SCALE = 100;
+//#endregion
+export { DEFAULT_GAS_BUDGET_MIST, DEFAULT_LIMBO_MULTIPLIER_SCALE, DEFAULT_RANGE_SCALE, RANGE_POINT_LIMIT };
+//# sourceMappingURL=constants.d.mts.map

package/dist/utils/constants.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../../src/utils/constants.ts"],"mappings":";cAKa,uBAAA;AAAA,cACA,mBAAA;AAAA,cACA,iBAAA;AAAA,cACA,8BAAA"}

package/dist/utils/constants.mjs

@@ -0,0 +1,10 @@
+import { parseToMist } from "@mysten/sui/utils";
+//#region src/utils/constants.ts
+const DEFAULT_GAS_BUDGET_MIST = parseToMist("0.05");
+const DEFAULT_RANGE_SCALE = 1e6;
+const RANGE_POINT_LIMIT = DEFAULT_RANGE_SCALE * 100;
+const DEFAULT_LIMBO_MULTIPLIER_SCALE = 100;
+//#endregion
+export { DEFAULT_GAS_BUDGET_MIST, DEFAULT_LIMBO_MULTIPLIER_SCALE, DEFAULT_RANGE_SCALE, RANGE_POINT_LIMIT };
+
+//# sourceMappingURL=constants.mjs.map

package/dist/utils/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":["../../src/utils/constants.ts"],"sourcesContent":["// Copyright (c) Suigar\n// SPDX-License-Identifier: Apache-2.0\n\nimport { parseToMist } from '@mysten/sui/utils';\n\nexport const DEFAULT_GAS_BUDGET_MIST: bigint = parseToMist('0.05');\nexport const DEFAULT_RANGE_SCALE = 1_000_000;\nexport const RANGE_POINT_LIMIT: number = DEFAULT_RANGE_SCALE * 100;\nexport const DEFAULT_LIMBO_MULTIPLIER_SCALE = 100;\n"],"mappings":";;AAKA,MAAa,0BAAkC,YAAY,OAAO;AAClE,MAAa,sBAAsB;AACnC,MAAa,oBAA4B,sBAAsB;AAC/D,MAAa,iCAAiC"}

package/dist/utils/numeric.d.mts

@@ -0,0 +1,86 @@
+import { MoveFloat } from "../types/move-float.type.mjs";
+//#region src/utils/numeric.d.ts
+/**
+ * Converts a generated Move `i64` wrapper into a JavaScript number.
+ *
+ * The generated bindings expose signed 64-bit integers through a `{ bits }`
+ * field that stores the raw two's-complement bit pattern. This helper
+ * reinterprets those bits as a signed `i64` and returns a plain JS number.
+ * Invalid or missing input falls back to `0`.
+ *
+ * @param i64 Generated Move `i64` value, typically used for float exponents.
+ * @returns The signed 64-bit value as a JavaScript number.
+ */
+declare function fromMoveI64(i64: MoveFloat['exp']): number;
+/**
+ * Converts a generated Move `Float` struct into a JavaScript number.
+ *
+ * Suigar float values are represented as a sign flag, an unsigned mantissa,
+ * and a Move `i64` exponent. This helper rebuilds the numeric value using the
+ * same normalization expected by the on-chain format and applies the sign at
+ * the end. Missing mantissas are treated as `0`, and a zero mantissa returns `0`.
+ *
+ * @param float Generated Move float value with `mant`, `exp`, and `is_negative`.
+ * @returns The decoded floating-point value as a JavaScript number.
+ */
+declare function fromMoveFloat(float: MoveFloat): number;
+/**
+ * Normalizes a value into a non-negative `bigint`.
+ *
+ * Accepted inputs:
+ * - `bigint`
+ * - finite `number`
+ * - base-10 integer `string`
+ * - `boolean`
+ *
+ * Number inputs are truncated toward zero before conversion, so `5.9` becomes
+ * `5n`. String and boolean inputs are parsed through the native
+ * `BigInt(...)` constructor, so `true` becomes `1n`, `false` becomes `0n`,
+ * and only integer strings are accepted.
+ *
+ * @param value Value to normalize.
+ * @returns A non-negative `bigint`.
+ * @throws When `value` is not a bigint, finite number, integer string, or
+ * boolean.
+ * @throws When the normalized value is negative.
+ */
+declare function toBigInt(value: unknown): bigint;
+/**
+ * Validates that a value can be safely used as a Move `u8` in the `0..255`
+ * range.
+ *
+ * Accepted inputs:
+ * - finite `number`
+ * - base-10 integer `string`
+ *
+ * String inputs are accepted for parsed values such as `'1'`, but only when
+ * they are plain non-negative integer strings. This helper does not accept
+ * booleans and does not truncate fractional values.
+ *
+ * @param value Value to validate.
+ * @returns The validated `u8` value as a JavaScript `number`.
+ * @throws When `value` is not a finite number or integer string.
+ * @throws When `value` is not an integer between `0` and `255`.
+ */
+declare function toU8(value: unknown): number;
+/**
+ * Validates that a value can be safely used as a Move `u16` in the
+ * `0..65535` range.
+ *
+ * Accepted inputs:
+ * - finite `number`
+ * - base-10 integer `string`
+ *
+ * String inputs are accepted for parsed values such as `'1'`, but only when
+ * they are plain non-negative integer strings. This helper does not accept
+ * booleans and does not truncate fractional values.
+ *
+ * @param value Value to validate.
+ * @returns The validated `u16` value as a JavaScript `number`.
+ * @throws When `value` is not a finite number or integer string.
+ * @throws When `value` is not an integer between `0` and `65535`.
+ */
+declare function toU16(value: unknown): number;
+//#endregion
+export { fromMoveFloat, fromMoveI64, toBigInt, toU16, toU8 };
+//# sourceMappingURL=numeric.d.mts.map

package/dist/utils/numeric.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric.d.mts","names":[],"sources":["../../src/utils/numeric.ts"],"mappings":";;;;;AAgBA;;;;;AAmBA;;;iBAnBgB,WAAA,CAAY,GAAA,EAAK,SAAA;;AAgEjC;;;;;AAqFA;;;;;iBAlIgB,aAAA,CAAc,KAAA,EAAO,SAAA;;;;;;;;;;;;;;;;;;;;;iBA6CrB,QAAA,CAAS,KAAA;;;;;;;;;;;;;;;;;;iBAqFT,IAAA,CAAK,KAAA;;;;;;;;;;;;;;;;;;iBAqBL,KAAA,CAAM,KAAA"}