@suigar/mcp 0.1.0 → 0.2.0-beta.0

package/dist/tools.mjs

@@ -1,608 +1,352 @@
-import { getRequiredConfigKeysForGame, inspectResolvedConfig, resolveGamePackageId, resolveSuigarConfig } from "./config.mjs";
-import { getCurrencyInfo, getGameMetadata, readConfigMetadata } from "./metadata.mjs";
-import { createReadOnlyClientBundle, dryRunTransaction, serializeTransactionToBase64 } from "./client.mjs";
-import { buildCoinflipTransaction, buildLimboTransaction, buildPlinkoTransaction, buildPvpCoinflipCancelTransaction, buildPvpCoinflipCreateTransaction, buildPvpCoinflipJoinTransaction, buildRangeTransaction, buildWheelTransaction, summarizeTransaction } from "./transactions.mjs";
-import { normalizeCoinType } from "@suigar/currency-registry";
-import { SuiGrpcClient } from "@mysten/sui/grpc";
-import { suigar } from "@suigar/sdk";
+import { buildTransactionResult, createSuigarClient, resolveDefaultCoinType, resolveOwnerAddress } from "./client.mjs";
+import { GAMES } from "@suigar/sdk/games";
 //#region src/tools.ts
-const asRecord = (value) => value && typeof value === "object" ? value : {};
-const asString = (value, fieldName, fallback) => {
+const GAME_LABELS = {
+	coinflip: "Coinflip",
+	limbo: "Limbo",
+	plinko: "Plinko",
+	range: "Range",
+	wheel: "Wheel",
+	"pvp-coinflip": "PvP Coinflip"
+};
+const GAME_TO_PACKAGE_KEY = {
+	coinflip: "coinflip",
+	limbo: "limbo",
+	plinko: "plinko",
+	range: "range",
+	wheel: "wheel",
+	"pvp-coinflip": "pvpCoinflip"
+};
+const GAME_TO_TOOLS = {
+	coinflip: ["build_coinflip_transaction"],
+	limbo: ["build_limbo_transaction"],
+	plinko: ["build_plinko_transaction"],
+	range: ["build_range_transaction"],
+	wheel: ["build_wheel_transaction"],
+	"pvp-coinflip": [
+		"build_pvp_coinflip_create_transaction",
+		"build_pvp_coinflip_join_transaction",
+		"build_pvp_coinflip_cancel_transaction"
+	]
+};
+const json = (value) => JSON.stringify(value, (_key, item) => typeof item === "bigint" ? item.toString() : item, 2);
+const asTextResponse = (structuredContent) => ({
+	content: [{
+		type: "text",
+		text: json(structuredContent)
+	}],
+	structuredContent
+});
+const currencyAmountPattern = /^(?:\d+|\d+\.\d+|\.\d+)$/u;
+const coinMetadataForAmount = (config, coinType) => {
+	const resolvedCoinType = resolveDefaultCoinType(config, coinType);
+	const coin = Object.values(config.sdk.coins).find((metadata) => resolveDefaultCoinType(config, metadata.coinType) === resolvedCoinType);
+	if (!coin) throw new RangeError(`Unable to resolve decimals for coin type ${resolvedCoinType}. Add the coin to config.coins before using currency-denominated amounts.`);
+	return {
+		coinType: resolvedCoinType,
+		decimals: coin.decimals
+	};
+};
+const toCurrencyAmountText = (value, fieldName) => {
+	if (typeof value === "number" && Number.isFinite(value) && value >= 0) return String(value);
+	if (typeof value === "string" && currencyAmountPattern.test(value.trim())) return value.trim();
+	throw new TypeError(`Missing or invalid ${fieldName}. Provide a non-negative currency amount such as 1, 2, or 1.5.`);
+};
+const toBaseUnits = (value, fieldName, decimals) => {
+	const [rawWhole, rawFraction = ""] = toCurrencyAmountText(value, fieldName).split(".");
+	const whole = rawWhole === "" ? "0" : rawWhole;
+	const overflow = rawFraction.slice(decimals);
+	if (/[^0]/u.test(overflow)) throw new RangeError(`${fieldName} has more fractional digits than the configured coin decimals (${decimals}).`);
+	const fraction = rawFraction.slice(0, decimals).padEnd(decimals, "0");
+	return BigInt(whole) * 10n ** BigInt(decimals) + BigInt(fraction || "0");
+};
+const toPositiveInteger = (value, fieldName) => {
+	if (typeof value === "number" && Number.isSafeInteger(value) && value > 0) return value;
+	if (typeof value === "string" && /^[1-9]\d*$/u.test(value)) return BigInt(value);
+	throw new TypeError(`Missing or invalid ${fieldName}. Provide a positive integer.`);
+};
+const requireString = (value, fieldName) => {
 	if (typeof value === "string" && value.trim()) return value.trim();
-	if (fallback !== void 0) return fallback;
-	throw new Error(`Missing required string field: ${fieldName}`);
+	throw new TypeError(`Missing required field: ${fieldName}.`);
+};
+const requireNumber = (value, fieldName) => {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	throw new TypeError(`Missing or invalid numeric field: ${fieldName}.`);
 };
-const asOptionalString = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
-const asNumber = (value, fieldName) => {
-	const numeric = typeof value === "bigint" ? Number(value) : Number(value);
-	if (!Number.isFinite(numeric)) throw new Error(`Missing or invalid numeric field: ${fieldName}`);
-	return numeric;
+const getMode = (mode) => mode ?? "build";
+const getConfigInput = (input) => ({
+	network: input.network,
+	providerUrl: input.providerUrl,
+	config: input.config,
+	partner: input.partner
+});
+const supportedGames = () => GAMES.map((id) => ({
+	id,
+	label: GAME_LABELS[id],
+	tools: [...GAME_TO_TOOLS[id]]
+}));
+const getPackageId = (config, game) => config.sdk.packageIds[GAME_TO_PACKAGE_KEY[game]];
+const getTarget = (config, game, action) => {
+	const packageId = getPackageId(config, game);
+	if (game === "pvp-coinflip") return `${packageId}::pvp_coinflip::${action === "join" ? "join_game" : action === "cancel" ? "cancel_game" : "create_game"}`;
+	return `${packageId}::${game}::play`;
 };
-const asBoolean = (value, fallback = false) => typeof value === "boolean" ? value : fallback;
-const asStringArray = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
-const asMode = (value) => value === "dry-run" || value === "read-only" || value === "build" ? value : "build";
-const SDK_BUILD_NETWORKS = /* @__PURE__ */ new Set(["mainnet", "testnet"]);
-const SDK_UNSUPPORTED_CONFIG_OVERRIDE_KEYS = [
-	"suigarPackageId",
-	"coinflipPackageId",
-	"pvpCoinflipPackageId",
-	"plinkoPackageId",
-	"limboPackageId",
-	"rangePackageId",
-	"wheelPackageId",
-	"sweethouseId",
-	"suiPythPriceInfoObjectId",
-	"usdcPythPriceInfoObjectId",
-	"pvpCoinflipRegistryId"
-];
-const buildReadOnlyPlan = ({ game, config, coinType, targetSuffix, notes }) => {
-	const resolvedConfig = resolveSuigarConfig(config);
-	const packageId = resolveGamePackageId(game, resolvedConfig);
+const readOnlyPlan = ({ input, game, action, requiredInputs, notes }) => {
+	const { config } = createSuigarClient(getConfigInput(input));
+	const coinType = resolveDefaultCoinType(config, input.coinType);
 	return {
 		mode: "read-only",
-		network: resolvedConfig.network,
+		network: config.network,
 		game,
-		config: inspectResolvedConfig(resolvedConfig),
+		action,
+		config,
 		plan: {
-			target: packageId ? `${packageId}${targetSuffix}` : null,
-			typeArguments: coinType ? [normalizeCoinType(coinType)] : [],
-			requiredConfigKeys: getRequiredConfigKeysForGame(game),
+			target: getTarget(config, game, action),
+			typeArguments: [coinType],
+			requiredInputs,
 			notes
 		}
 	};
 };
-const buildTransactionResult = async ({ mode, config, transaction, context }) => {
-	const bundle = createReadOnlyClientBundle(config);
-	const summary = summarizeTransaction(transaction, context);
-	if (mode === "dry-run") return {
-		mode,
-		network: bundle.config.network,
-		config: inspectResolvedConfig(bundle.config),
-		summary,
-		dryRun: await dryRunTransaction(transaction, bundle.config)
-	};
+const commonOptions = async (input, bundle) => {
 	return {
-		mode,
-		network: bundle.config.network,
-		config: inspectResolvedConfig(bundle.config),
-		summary,
-		transactionBytesBase64: await serializeTransactionToBase64(transaction, bundle.rawClient)
+		owner: await resolveOwnerAddress(requireString(input.owner, "owner"), bundle),
+		coinType: resolveDefaultCoinType(bundle.config, input.coinType),
+		metadata: input.metadata,
+		gasBudget: input.gasBudget,
+		useGasCoin: input.useGasCoin
 	};
 };
-const extractConfigInput = (input) => {
-	const nestedConfig = asRecord(input.config);
+const stakeOptions = async (input, bundle) => {
+	const { decimals } = coinMetadataForAmount(bundle.config, input.coinType);
 	return {
-		...nestedConfig,
-		network: asOptionalString(input.network) ?? asOptionalString(nestedConfig.network),
-		providerUrl: asOptionalString(input.providerUrl) ?? asOptionalString(nestedConfig.providerUrl),
-		graphqlUrl: asOptionalString(input.graphqlUrl) ?? asOptionalString(nestedConfig.graphqlUrl)
-	};
-};
-const extractPartner = (input) => asOptionalString(input.partner) ?? asOptionalString(asRecord(input.config).partner);
-const hasSdkUnsupportedConfigOverrides = (input) => {
-	const mergedInput = {
-		...asRecord(input.config),
-		...input
+		...await commonOptions(input, bundle),
+		stake: toBaseUnits(input.stake, "stake", decimals),
+		...input.cashStake == null ? {} : { cashStake: toBaseUnits(input.cashStake, "cashStake", decimals) },
+		...input.betCount == null ? {} : { betCount: toPositiveInteger(input.betCount, "betCount") }
 	};
-	return SDK_UNSUPPORTED_CONFIG_OVERRIDE_KEYS.some((key) => asOptionalString(mergedInput[key]));
 };
-const buildCommonSdkOptions = (record, coinType) => {
-	const owner = asString(record.owner, "owner");
-	return {
-		owner,
-		playerAddress: owner,
-		coinType,
-		metadata: asRecord(record.metadata),
-		allowGasCoinShortcut: asBoolean(record.allowGasCoinShortcut, true),
-		...record.gasBudget == null ? {} : { gasBudget: asNumber(record.gasBudget, "gasBudget") }
-	};
-};
-const buildStakeSdkOptions = (record, coinType) => ({
-	...buildCommonSdkOptions(record, coinType),
-	stake: asNumber(record.stake, "stake"),
-	...record.cashStake == null ? {} : { cashStake: asNumber(record.cashStake, "cashStake") },
-	...record.betCount == null ? {} : { betCount: asNumber(record.betCount, "betCount") }
-});
-const tryBuildSdkTransaction = ({ record, config, coinType, game, pvpAction }) => {
-	if (asStringArray(record.coinObjectIds).length > 0 || hasSdkUnsupportedConfigOverrides(record)) return null;
-	const resolvedConfig = resolveSuigarConfig(config);
-	if (!SDK_BUILD_NETWORKS.has(resolvedConfig.network)) return null;
-	const partner = extractPartner(record);
-	const client = new SuiGrpcClient({
-		baseUrl: resolvedConfig.providerUrl,
-		network: resolvedConfig.network
-	}).$extend(suigar(partner ? { partner } : void 0));
-	try {
-		switch (game) {
-			case "coinflip": return client.suigar.tx.createBetTransaction("coinflip", {
-				...buildStakeSdkOptions(record, coinType),
-				side: asString(record.side, "side")
-			});
-			case "limbo": return client.suigar.tx.createBetTransaction("limbo", {
-				...buildStakeSdkOptions(record, coinType),
-				targetMultiplier: asNumber(record.targetMultiplier, "targetMultiplier")
-			});
-			case "plinko": return client.suigar.tx.createBetTransaction("plinko", {
-				...buildStakeSdkOptions(record, coinType),
-				configId: asNumber(record.configId, "configId")
-			});
-			case "wheel": return client.suigar.tx.createBetTransaction("wheel", {
-				...buildStakeSdkOptions(record, coinType),
-				configId: asNumber(record.configId, "configId")
-			});
-			case "range": return client.suigar.tx.createBetTransaction("range", {
-				...buildStakeSdkOptions(record, coinType),
-				leftPoint: asNumber(record.leftPoint, "leftPoint"),
-				rightPoint: asNumber(record.rightPoint, "rightPoint"),
-				outOfRange: asBoolean(record.outOfRange)
-			});
-			case "pvp-coinflip":
-				if (pvpAction === "join" || pvpAction === "cancel") return client.suigar.tx.createPvPCoinflipTransaction(pvpAction, {
-					...buildCommonSdkOptions(record, coinType),
-					config: client.suigar.getConfig(),
-					gameId: asString(record.gameId, "gameId")
-				});
-				return client.suigar.tx.createPvPCoinflipTransaction("create", {
-					...buildCommonSdkOptions(record, coinType),
-					config: client.suigar.getConfig(),
-					stake: asNumber(record.stake, "stake"),
-					side: asString(record.creatorSide, "creatorSide"),
-					isPrivate: asBoolean(record.isPrivate)
-				});
-		}
-	} catch {
-		return null;
-	}
-};
-const readConfigTool = async (input = {}) => {
-	return readConfigMetadata(extractConfigInput(asRecord(input)));
-};
-const readGameMetadataTool = async (input = {}) => {
-	const record = asRecord(input);
-	const config = extractConfigInput(record);
-	const game = asOptionalString(record.game);
-	const coinType = asOptionalString(record.coinType);
-	return {
-		config: readConfigMetadata(config),
-		game: game ? getGameMetadata(game, config) : null,
-		currency: coinType ? getCurrencyInfo(coinType, config) : null
-	};
-};
-const buildCoinflipTransactionTool = async (input = {}) => {
-	const record = asRecord(input);
-	const config = extractConfigInput(record);
-	const mode = asMode(record.mode);
-	const coinType = asString(record.coinType, "coinType", resolveSuigarConfig(config).suiCoinType);
-	if (mode === "read-only") return buildReadOnlyPlan({
-		game: "coinflip",
-		config,
-		coinType,
-		targetSuffix: "::coinflip::play",
-		notes: ["Uses the sweethouse shared object, a prepared bet coin, Pyth price info, clock, and random."]
-	});
-	const sdkTransaction = tryBuildSdkTransaction({
-		record,
-		config,
-		coinType,
-		game: "coinflip"
-	});
-	if (sdkTransaction) return buildTransactionResult({
-		mode,
-		config,
-		transaction: sdkTransaction,
-		context: {
-			game: "coinflip",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
-	});
-	const bundle = createReadOnlyClientBundle(config);
-	const transaction = await buildCoinflipTransaction({
-		client: bundle.client,
-		config: bundle.config,
-		owner: asString(record.owner, "owner"),
-		coinType,
-		stake: asNumber(record.stake, "stake"),
-		cashStake: record.cashStake == null ? void 0 : asNumber(record.cashStake, "cashStake"),
-		betCount: record.betCount == null ? void 0 : asNumber(record.betCount, "betCount"),
-		side: asString(record.side, "side"),
-		metadata: asRecord(record.metadata),
-		partner: extractPartner(record),
-		coinSource: asStringArray(record.coinObjectIds).length > 0 ? {
-			kind: "object-ids",
-			objectIds: asStringArray(record.coinObjectIds)
-		} : void 0
-	});
-	return buildTransactionResult({
+const executeTransactionTool = async ({ input, game, action, createTransaction, stake, stakeDisplay, gameInputs }) => {
+	const mode = getMode(input.mode);
+	if (mode === "read-only") throw new Error("read-only mode must be handled before transaction execution.");
+	const bundle = createSuigarClient(getConfigInput(input));
+	const coin = coinMetadataForAmount(bundle.config, input.coinType);
+	const baseStake = stake ?? (stakeDisplay == null ? void 0 : toBaseUnits(stakeDisplay, "stake", coin.decimals));
+	return asTextResponse(await buildTransactionResult({
 		mode,
+		transaction: await createTransaction(bundle),
 		config: bundle.config,
-		transaction,
-		context: {
-			game: "coinflip",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
-	});
-};
-const buildLimboTransactionTool = async (input = {}) => {
-	const record = asRecord(input);
-	const config = extractConfigInput(record);
-	const mode = asMode(record.mode);
-	const coinType = asString(record.coinType, "coinType", resolveSuigarConfig(config).suiCoinType);
-	if (mode === "read-only") return buildReadOnlyPlan({
-		game: "limbo",
-		config,
-		coinType,
-		targetSuffix: "::limbo::play",
-		notes: ["Target multiplier is encoded as a fixed-point numerator and denominator."]
-	});
-	const sdkTransaction = tryBuildSdkTransaction({
-		record,
-		config,
-		coinType,
-		game: "limbo"
-	});
-	if (sdkTransaction) return buildTransactionResult({
-		mode,
-		config,
-		transaction: sdkTransaction,
-		context: {
-			game: "limbo",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
-	});
-	const bundle = createReadOnlyClientBundle(config);
-	const transaction = await buildLimboTransaction({
 		client: bundle.client,
-		config: bundle.config,
-		owner: asString(record.owner, "owner"),
-		coinType,
-		stake: asNumber(record.stake, "stake"),
-		cashStake: record.cashStake == null ? void 0 : asNumber(record.cashStake, "cashStake"),
-		betCount: record.betCount == null ? void 0 : asNumber(record.betCount, "betCount"),
-		targetMultiplier: asNumber(record.targetMultiplier, "targetMultiplier"),
-		metadata: asRecord(record.metadata),
-		partner: extractPartner(record),
-		coinSource: asStringArray(record.coinObjectIds).length > 0 ? {
-			kind: "object-ids",
-			objectIds: asStringArray(record.coinObjectIds)
-		} : void 0
-	});
-	return buildTransactionResult({
-		mode,
-		config: bundle.config,
-		transaction,
 		context: {
-			game: "limbo",
-			coinType,
-			stake: asNumber(record.stake, "stake")
+			game,
+			action,
+			coinType: coin.coinType,
+			stake: baseStake,
+			stakeDisplay,
+			coinDecimals: coin.decimals,
+			gameInputs
 		}
-	});
+	}));
 };
-const buildPlinkoTransactionTool = async (input = {}) => {
-	const record = asRecord(input);
-	const config = extractConfigInput(record);
-	const mode = asMode(record.mode);
-	const coinType = asString(record.coinType, "coinType", resolveSuigarConfig(config).suiCoinType);
-	if (mode === "read-only") return buildReadOnlyPlan({
-		game: "plinko",
-		config,
-		coinType,
-		targetSuffix: "::plinko::play",
-		notes: ["The config id is a u8 that selects the on-chain plinko board setup."]
-	});
-	const sdkTransaction = tryBuildSdkTransaction({
-		record,
+const readConfigTool = async (input = {}) => {
+	const { config } = createSuigarClient(getConfigInput(input));
+	return asTextResponse({
+		network: config.network,
 		config,
-		coinType,
-		game: "plinko"
+		supportedGames: supportedGames()
 	});
-	if (sdkTransaction) return buildTransactionResult({
-		mode,
+};
+const readGameMetadataTool = async (input = {}) => {
+	const { config } = createSuigarClient(getConfigInput(input));
+	const game = input.game ?? null;
+	const coinType = resolveDefaultCoinType(config, input.coinType);
+	return asTextResponse({
+		network: config.network,
 		config,
-		transaction: sdkTransaction,
-		context: {
-			game: "plinko",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
-	});
-	const bundle = createReadOnlyClientBundle(config);
-	const transaction = await buildPlinkoTransaction({
-		client: bundle.client,
-		config: bundle.config,
-		owner: asString(record.owner, "owner"),
-		coinType,
-		stake: asNumber(record.stake, "stake"),
-		cashStake: record.cashStake == null ? void 0 : asNumber(record.cashStake, "cashStake"),
-		betCount: record.betCount == null ? void 0 : asNumber(record.betCount, "betCount"),
-		configId: asNumber(record.configId, "configId"),
-		metadata: asRecord(record.metadata),
-		partner: extractPartner(record),
-		coinSource: asStringArray(record.coinObjectIds).length > 0 ? {
-			kind: "object-ids",
-			objectIds: asStringArray(record.coinObjectIds)
-		} : void 0
-	});
-	return buildTransactionResult({
-		mode,
-		config: bundle.config,
-		transaction,
-		context: {
-			game: "plinko",
+		supportedGames: supportedGames(),
+		game: game ? {
+			id: game,
+			label: GAME_LABELS[game],
+			packageId: getPackageId(config, game),
 			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
+			notes: [game === "pvp-coinflip" ? "PvP coinflip uses dedicated create, join, and cancel transaction builders." : "Standard games use client.suigar.tx.createBetTransaction().", "Transactions are unsigned and are never executed by the MCP server."]
+		} : null
 	});
 };
-const buildWheelTransactionTool = async (input = {}) => {
-	const record = asRecord(input);
-	const config = extractConfigInput(record);
-	const mode = asMode(record.mode);
-	const coinType = asString(record.coinType, "coinType", resolveSuigarConfig(config).suiCoinType);
-	if (mode === "read-only") return buildReadOnlyPlan({
-		game: "wheel",
-		config,
-		coinType,
-		targetSuffix: "::wheel::play",
-		notes: ["The config id is a u8 that selects the on-chain wheel table."]
-	});
-	const sdkTransaction = tryBuildSdkTransaction({
-		record,
-		config,
-		coinType,
-		game: "wheel"
-	});
-	if (sdkTransaction) return buildTransactionResult({
-		mode,
-		config,
-		transaction: sdkTransaction,
-		context: {
-			game: "wheel",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
+const buildCoinflipTransactionTool = async (input = {}) => {
+	if (getMode(input.mode) === "read-only") return asTextResponse(readOnlyPlan({
+		input,
+		game: "coinflip",
+		requiredInputs: [
+			"owner",
+			"stake",
+			"side"
+		],
+		notes: ["Uses the configured SweetHouse object, Pyth price info, clock, and randomness objects."]
+	}));
+	const side = requireString(input.side, "side");
+	return executeTransactionTool({
+		input,
+		game: "coinflip",
+		stakeDisplay: toCurrencyAmountText(input.stake, "stake"),
+		gameInputs: { side },
+		createTransaction: async (bundle) => bundle.client.suigar.tx.createBetTransaction("coinflip", {
+			...await stakeOptions(input, bundle),
+			side
+		})
 	});
-	const bundle = createReadOnlyClientBundle(config);
-	const transaction = await buildWheelTransaction({
-		client: bundle.client,
-		config: bundle.config,
-		owner: asString(record.owner, "owner"),
-		coinType,
-		stake: asNumber(record.stake, "stake"),
-		cashStake: record.cashStake == null ? void 0 : asNumber(record.cashStake, "cashStake"),
-		betCount: record.betCount == null ? void 0 : asNumber(record.betCount, "betCount"),
-		configId: asNumber(record.configId, "configId"),
-		metadata: asRecord(record.metadata),
-		partner: extractPartner(record),
-		coinSource: asStringArray(record.coinObjectIds).length > 0 ? {
-			kind: "object-ids",
-			objectIds: asStringArray(record.coinObjectIds)
-		} : void 0
+};
+const buildLimboTransactionTool = async (input = {}) => {
+	if (getMode(input.mode) === "read-only") return asTextResponse(readOnlyPlan({
+		input,
+		game: "limbo",
+		requiredInputs: [
+			"owner",
+			"stake",
+			"targetMultiplier"
+		],
+		notes: ["Target multiplier is encoded by @suigar/sdk using the public fixed-point utility defaults."]
+	}));
+	const targetMultiplier = requireNumber(input.targetMultiplier, "targetMultiplier");
+	return executeTransactionTool({
+		input,
+		game: "limbo",
+		stakeDisplay: toCurrencyAmountText(input.stake, "stake"),
+		gameInputs: { targetMultiplier },
+		createTransaction: async (bundle) => bundle.client.suigar.tx.createBetTransaction("limbo", {
+			...await stakeOptions(input, bundle),
+			targetMultiplier
+		})
 	});
-	return buildTransactionResult({
-		mode,
-		config: bundle.config,
-		transaction,
-		context: {
-			game: "wheel",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
+};
+const buildConfigIdTransactionTool = async (input, game) => {
+	if (getMode(input.mode) === "read-only") return asTextResponse(readOnlyPlan({
+		input,
+		game,
+		requiredInputs: [
+			"owner",
+			"stake",
+			"configId"
+		],
+		notes: ["Config id selects the on-chain game configuration."]
+	}));
+	const configId = requireNumber(input.configId, "configId");
+	return executeTransactionTool({
+		input,
+		game,
+		stakeDisplay: toCurrencyAmountText(input.stake, "stake"),
+		gameInputs: { configId },
+		createTransaction: async (bundle) => bundle.client.suigar.tx.createBetTransaction(game, {
+			...await stakeOptions(input, bundle),
+			configId
+		})
 	});
 };
+const buildPlinkoTransactionTool = (input = {}) => buildConfigIdTransactionTool(input, "plinko");
+const buildWheelTransactionTool = (input = {}) => buildConfigIdTransactionTool(input, "wheel");
 const buildRangeTransactionTool = async (input = {}) => {
-	const record = asRecord(input);
-	const config = extractConfigInput(record);
-	const mode = asMode(record.mode);
-	const coinType = asString(record.coinType, "coinType", resolveSuigarConfig(config).suiCoinType);
-	if (mode === "read-only") return buildReadOnlyPlan({
+	if (getMode(input.mode) === "read-only") return asTextResponse(readOnlyPlan({
+		input,
 		game: "range",
-		config,
-		coinType,
-		targetSuffix: "::range::play",
-		notes: ["Range points are encoded as fixed-point integers with a 1e6 scale by default."]
-	});
-	const sdkTransaction = tryBuildSdkTransaction({
-		record,
-		config,
-		coinType,
-		game: "range"
-	});
-	if (sdkTransaction) return buildTransactionResult({
-		mode,
-		config,
-		transaction: sdkTransaction,
-		context: {
-			game: "range",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
-	});
-	const bundle = createReadOnlyClientBundle(config);
-	const transaction = await buildRangeTransaction({
-		client: bundle.client,
-		config: bundle.config,
-		owner: asString(record.owner, "owner"),
-		coinType,
-		stake: asNumber(record.stake, "stake"),
-		cashStake: record.cashStake == null ? void 0 : asNumber(record.cashStake, "cashStake"),
-		betCount: record.betCount == null ? void 0 : asNumber(record.betCount, "betCount"),
-		leftPoint: asNumber(record.leftPoint, "leftPoint"),
-		rightPoint: asNumber(record.rightPoint, "rightPoint"),
-		outOfRange: asBoolean(record.outOfRange),
-		metadata: asRecord(record.metadata),
-		partner: extractPartner(record),
-		coinSource: asStringArray(record.coinObjectIds).length > 0 ? {
-			kind: "object-ids",
-			objectIds: asStringArray(record.coinObjectIds)
-		} : void 0
-	});
-	return buildTransactionResult({
-		mode,
-		config: bundle.config,
-		transaction,
-		context: {
-			game: "range",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
+		requiredInputs: [
+			"owner",
+			"stake",
+			"leftPoint",
+			"rightPoint"
+		],
+		notes: ["Range points are normalized by @suigar/sdk before Move call construction."]
+	}));
+	const leftPoint = requireNumber(input.leftPoint, "leftPoint");
+	const rightPoint = requireNumber(input.rightPoint, "rightPoint");
+	const outOfRange = Boolean(input.outOfRange);
+	return executeTransactionTool({
+		input,
+		game: "range",
+		stakeDisplay: toCurrencyAmountText(input.stake, "stake"),
+		gameInputs: {
+			leftPoint,
+			rightPoint,
+			outOfRange
+		},
+		createTransaction: async (bundle) => bundle.client.suigar.tx.createBetTransaction("range", {
+			...await stakeOptions(input, bundle),
+			leftPoint,
+			rightPoint,
+			outOfRange
+		})
 	});
 };
 const buildPvpCoinflipCreateTransactionTool = async (input = {}) => {
-	const record = asRecord(input);
-	const config = extractConfigInput(record);
-	const mode = asMode(record.mode);
-	const coinType = asString(record.coinType, "coinType", resolveSuigarConfig(config).suiCoinType);
-	if (mode === "read-only") return buildReadOnlyPlan({
+	if (getMode(input.mode) === "read-only") return asTextResponse(readOnlyPlan({
+		input,
 		game: "pvp-coinflip",
-		config,
-		coinType,
-		targetSuffix: "::pvp_coinflip::create_game",
-		notes: ["Creates a public or private PvP lobby without needing a private key."]
-	});
-	const sdkTransaction = tryBuildSdkTransaction({
-		record,
-		config,
-		coinType,
+		action: "create",
+		requiredInputs: [
+			"owner",
+			"stake",
+			"creatorSide"
+		],
+		notes: ["Creates an unresolved PvP coinflip lobby without signing or executing the transaction."]
+	}));
+	const creatorSide = requireString(input.creatorSide, "creatorSide");
+	return executeTransactionTool({
+		input,
 		game: "pvp-coinflip",
-		pvpAction: "create"
-	});
-	if (sdkTransaction) return buildTransactionResult({
-		mode,
-		config,
-		transaction: sdkTransaction,
-		context: {
-			game: "pvp-coinflip",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
-	});
-	const bundle = createReadOnlyClientBundle(config);
-	const transaction = await buildPvpCoinflipCreateTransaction({
-		client: bundle.client,
-		config: bundle.config,
-		owner: asString(record.owner, "owner"),
-		coinType,
-		stake: asNumber(record.stake, "stake"),
-		creatorSide: asString(record.creatorSide, "creatorSide"),
-		isPrivate: asBoolean(record.isPrivate),
-		metadata: asRecord(record.metadata),
-		partner: extractPartner(record),
-		coinSource: asStringArray(record.coinObjectIds).length > 0 ? {
-			kind: "object-ids",
-			objectIds: asStringArray(record.coinObjectIds)
-		} : void 0
-	});
-	return buildTransactionResult({
-		mode,
-		config: bundle.config,
-		transaction,
-		context: {
-			game: "pvp-coinflip",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
+		action: "create",
+		stakeDisplay: toCurrencyAmountText(input.stake, "stake"),
+		gameInputs: {
+			creatorSide,
+			...input.isPrivate == null ? {} : { isPrivate: input.isPrivate }
+		},
+		createTransaction: async (bundle) => bundle.client.suigar.tx.createPvPCoinflipTransaction("create", {
+			...await commonOptions(input, bundle),
+			stake: toBaseUnits(input.stake, "stake", coinMetadataForAmount(bundle.config, input.coinType).decimals),
+			side: creatorSide,
+			isPrivate: input.isPrivate
+		})
 	});
 };
 const buildPvpCoinflipJoinTransactionTool = async (input = {}) => {
-	const record = asRecord(input);
-	const config = extractConfigInput(record);
-	const mode = asMode(record.mode);
-	const coinType = asString(record.coinType, "coinType", resolveSuigarConfig(config).suiCoinType);
-	if (mode === "read-only") return buildReadOnlyPlan({
+	if (getMode(input.mode) === "read-only") return asTextResponse(readOnlyPlan({
+		input,
 		game: "pvp-coinflip",
-		config,
-		coinType,
-		targetSuffix: "::pvp_coinflip::join_game",
-		notes: ["Joining requires the game id, stake amount, and a price info object for the selected coin."]
-	});
-	const sdkTransaction = tryBuildSdkTransaction({
-		record,
-		config,
-		coinType,
+		action: "join",
+		requiredInputs: ["owner", "gameId"],
+		notes: ["Join resolves the live game object during transaction build so the SDK can source the matching stake."]
+	}));
+	const gameId = requireString(input.gameId, "gameId");
+	return executeTransactionTool({
+		input,
 		game: "pvp-coinflip",
-		pvpAction: "join"
-	});
-	if (sdkTransaction) return buildTransactionResult({
-		mode,
-		config,
-		transaction: sdkTransaction,
-		context: {
-			game: "pvp-coinflip",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
-	});
-	const bundle = createReadOnlyClientBundle(config);
-	const transaction = await buildPvpCoinflipJoinTransaction({
-		client: bundle.client,
-		config: bundle.config,
-		owner: asString(record.owner, "owner"),
-		gameId: asString(record.gameId, "gameId"),
-		coinType,
-		stake: asNumber(record.stake, "stake"),
-		metadata: asRecord(record.metadata),
-		partner: extractPartner(record),
-		coinSource: asStringArray(record.coinObjectIds).length > 0 ? {
-			kind: "object-ids",
-			objectIds: asStringArray(record.coinObjectIds)
-		} : void 0
-	});
-	return buildTransactionResult({
-		mode,
-		config: bundle.config,
-		transaction,
-		context: {
-			game: "pvp-coinflip",
-			coinType,
-			stake: asNumber(record.stake, "stake")
-		}
+		action: "join",
+		gameInputs: { gameId },
+		createTransaction: async (bundle) => bundle.client.suigar.tx.createPvPCoinflipTransaction("join", {
+			...await commonOptions(input, bundle),
+			gameId
+		})
 	});
 };
 const buildPvpCoinflipCancelTransactionTool = async (input = {}) => {
-	const record = asRecord(input);
-	const config = extractConfigInput(record);
-	const mode = asMode(record.mode);
-	const coinType = asString(record.coinType, "coinType", resolveSuigarConfig(config).suiCoinType);
-	if (mode === "read-only") return buildReadOnlyPlan({
+	if (getMode(input.mode) === "read-only") return asTextResponse(readOnlyPlan({
+		input,
 		game: "pvp-coinflip",
-		config,
-		coinType,
-		targetSuffix: "::pvp_coinflip::cancel_game",
-		notes: ["Cancel only needs the game id, sweethouse object, and coin type argument."]
-	});
-	const sdkTransaction = tryBuildSdkTransaction({
-		record,
-		config,
-		coinType,
+		action: "cancel",
+		requiredInputs: ["owner", "gameId"],
+		notes: ["Cancel only prepares the unsigned cancellation transaction for the game creator."]
+	}));
+	const gameId = requireString(input.gameId, "gameId");
+	return executeTransactionTool({
+		input,
 		game: "pvp-coinflip",
-		pvpAction: "cancel"
-	});
-	if (sdkTransaction) return buildTransactionResult({
-		mode,
-		config,
-		transaction: sdkTransaction,
-		context: {
-			game: "pvp-coinflip",
-			coinType
-		}
-	});
-	return buildTransactionResult({
-		mode,
-		config,
-		transaction: buildPvpCoinflipCancelTransaction({
-			config,
-			owner: asString(record.owner, "owner"),
-			gameId: asString(record.gameId, "gameId"),
-			coinType
-		}),
-		context: {
-			game: "pvp-coinflip",
-			coinType
-		}
+		action: "cancel",
+		gameInputs: { gameId },
+		createTransaction: async (bundle) => bundle.client.suigar.tx.createPvPCoinflipTransaction("cancel", {
+			...await commonOptions(input, bundle),
+			gameId
+		})
 	});
 };
 //#endregion
 export { buildCoinflipTransactionTool, buildLimboTransactionTool, buildPlinkoTransactionTool, buildPvpCoinflipCancelTransactionTool, buildPvpCoinflipCreateTransactionTool, buildPvpCoinflipJoinTransactionTool, buildRangeTransactionTool, buildWheelTransactionTool, readConfigTool, readGameMetadataTool };
+
+//# sourceMappingURL=tools.mjs.map