@conquest-eth/tools 0.0.0 → 0.0.2

package/src/mcp.ts

@@ -0,0 +1,46 @@
+import {McpServer} from '@modelcontextprotocol/sdk/server/mcp.js';
+import pkg from '../package.json' with {type: 'json'};
+import {ConquestEnv} from './types.js';
+import * as tools from './tools/index.js';
+import {createEthereumEnv, createEthereumMPCServer} from 'tools-ethereum';
+import {ServerOptions} from '@modelcontextprotocol/sdk/server';
+import {Implementation} from '@modelcontextprotocol/sdk/types.js';
+import {getChain} from 'tools-ethereum/helpers';
+import {registerAllMCPTools} from './tool-handling/mcp.js';
+
+/**
+ * Create and configure an MCP server for Conquest.eth game interactions
+ *
+ */
+export async function createServer(
+	env: ConquestEnv,
+	options?: {
+		ethereum?: boolean;
+		serverInfo?: Implementation;
+		serverOptions?: ServerOptions;
+	},
+) {
+	let server: McpServer;
+	const name = `mcp-conquest-eth-v0`;
+
+	if (options?.ethereum) {
+		const ethereumEnv = await createEthereumEnv(env.options);
+
+		server = createEthereumMPCServer(ethereumEnv, {
+			serverInfo: {name, version: pkg.version, ...options?.serverInfo},
+			serverOptions: options?.serverOptions,
+		});
+	} else {
+		server = new McpServer(
+			options?.serverInfo || {
+				name,
+				version: pkg.version,
+			},
+			options?.serverOptions || {capabilities: {logging: {}}},
+		);
+	}
+
+	registerAllMCPTools({server, tools, env});
+
+	return server;
+}

package/src/planet/acquire.ts

@@ -6,8 +6,9 @@ import {Clients, GameContract} from '../types.js';
  * @param clients - Viem clients (publicClient and walletClient)
  * @param gameContract - The game contract instance with address and ABI
  * @param planetIds - Array of planet location IDs to acquire
- * @param amountToMint - Amount of native token to spend
+ * @param amountToMint - Amount of play tokens to mint
  * @param tokenAmount - Amount of staking token to spend
+ * @param numTokensPerNativeToken - How many play tokens (at 18 decimals) you get per 1 native token (fetched from PlayToken contract)
  * @returns Transaction hash and list of planets acquired
  */
 export async function acquirePlanets(
@@ -16,14 +17,13 @@ export async function acquirePlanets(
 	planetIds: bigint[],
 	amountToMint: bigint,
 	tokenAmount: bigint,
+	numTokensPerNativeToken: bigint,
 ): Promise<{hash: `0x${string}`; planetsAcquired: bigint[]}> {
 	const sender = clients.walletClient.account!.address;
 
-	const nativeTokenAmount = (amountToMint * 1000000000000000000n) / 1000000000000000000000n; // TODO BigInt((PlayToken.linkedData as any).numTokensPerNativeTokenAt18Decimals);
-
-	console.log(
-		`Acquiring ${planetIds.length} planets with ${amountToMint} native tokens and ${tokenAmount} staking tokens using ${nativeTokenAmount} native tokens`,
-	);
+	// Calculate how much native token is needed to mint `amountToMint` play tokens
+	// nativeTokenAmount = amountToMint * 1e18 / numTokensPerNativeToken
+	const nativeTokenAmount = (amountToMint * 1000000000000000000n) / numTokensPerNativeToken;
 
 	// Get the contract acquireMultipleViaNativeTokenAndStakingToken function signature
 	const simulation = await clients.publicClient.simulateContract({

package/src/planet/exit.ts

@@ -49,6 +49,7 @@ export async function exitPlanets(
 				completed: false,
 				interrupted: false,
 				lastCheckedAt: currentTime,
+				withdrawn: false,
 			};
 
 			await storage.savePendingExit(exit);

package/src/planet/manager.ts

@@ -3,6 +3,7 @@ import type {SpaceInfo} from 'conquest-eth-v0-contracts';
 import type {PlanetInfo, PlanetState} from 'conquest-eth-v0-contracts';
 import {acquirePlanets} from './acquire.js';
 import {exitPlanets} from './exit.js';
+import {withdrawFromPlanets} from './withdraw.js';
 import type {FleetStorage} from '../storage/interface.js';
 import type {
 	Clients,
@@ -13,6 +14,17 @@ import type {
 	PendingExit,
 } from '../types.js';
 
+// ERC20 balanceOf ABI for checking play token balance
+const erc20BalanceOfAbi = [
+	{
+		name: 'balanceOf',
+		type: 'function',
+		stateMutability: 'view',
+		inputs: [{name: 'account', type: 'address'}],
+		outputs: [{name: '', type: 'uint256'}],
+	},
+] as const;
+
 /**
  * PlanetManager manages planet-related operations in the Conquest game
  * including acquiring new planets and initiating exit processes
@@ -52,6 +64,7 @@ export class PlanetManager {
 			planetIds,
 			amountToMint,
 			tokenAmount,
+			this.contractConfig.numTokensPerNativeToken,
 		);
 	}
 
@@ -70,10 +83,37 @@ export class PlanetManager {
 			planetIds,
 			costs.amountToMint,
 			costs.tokenAmount,
+			this.contractConfig.numTokensPerNativeToken,
 		);
 		return {...result, costs};
 	}
 
+	/**
+	 * Get the play token (staking token) balance for an address
+	 *
+	 * @param address - Address to check balance for. Defaults to current wallet address.
+	 * @returns The balance in raw units (18 decimals)
+	 */
+	async getPlayTokenBalance(address?: `0x${string}`): Promise<bigint> {
+		let targetAddress: `0x${string}`;
+
+		if (address) {
+			targetAddress = address;
+		} else {
+			const clients = this.requireWalletClient();
+			targetAddress = clients.walletClient.account!.address;
+		}
+
+		const balanceRaw = await this.clients.publicClient.readContract({
+			address: this.contractConfig.stakingToken,
+			abi: erc20BalanceOfAbi,
+			functionName: 'balanceOf',
+			args: [targetAddress],
+		});
+
+		return balanceRaw;
+	}
+
 	/**
 	 * Calculate acquisition costs for planets based on their stats
 	 *
@@ -99,6 +139,59 @@ export class PlanetManager {
 		return {amountToMint, tokenAmount: 0n};
 	}
 
+	/**
+	 * Acquire (stake) multiple planets using maximum available play token balance first,
+	 * then minting the remainder with native tokens.
+	 *
+	 * This simplifies planet acquisition by automatically:
+	 * 1. Calculating required token amount based on planet stats
+	 * 2. Using ALL available play token balance first
+	 * 3. Minting any remaining amount needed using native tokens
+	 *
+	 * @param planetIds - Array of planet location IDs to acquire
+	 * @returns Transaction hash, planets acquired, and cost breakdown
+	 */
+	async acquireWithMaxPlayToken(planetIds: bigint[]): Promise<{
+		hash: `0x${string}`;
+		planetsAcquired: bigint[];
+		costs: {
+			totalRequired: bigint;
+			playTokenUsed: bigint;
+			amountMinted: bigint;
+		};
+	}> {
+		// Calculate total required token amount
+		const {amountToMint: totalRequired} = this.calculateAcquisitionCosts(planetIds);
+
+		// Get current play token balance
+		const playTokenBalance = await this.getPlayTokenBalance();
+
+		// Determine how much play token to use (all of it, up to what's needed)
+		const playTokenUsed = playTokenBalance > totalRequired ? totalRequired : playTokenBalance;
+
+		// Calculate remaining amount to mint with native tokens
+		const amountToMint = totalRequired > playTokenUsed ? totalRequired - playTokenUsed : 0n;
+
+		// Acquire the planets
+		const result = await acquirePlanets(
+			this.requireWalletClient(),
+			this.gameContract,
+			planetIds,
+			amountToMint,
+			playTokenUsed,
+			this.contractConfig.numTokensPerNativeToken,
+		);
+
+		return {
+			...result,
+			costs: {
+				totalRequired,
+				playTokenUsed,
+				amountMinted: amountToMint,
+			},
+		};
+	}
+
 	/**
 	 * Exit (unstake) multiple planets
 	 */
@@ -112,6 +205,76 @@ export class PlanetManager {
 		);
 	}
 
+	/**
+	 * Withdraw tokens from planets that have completed their exit process
+	 *
+	 * @param planetIds - Array of planet location IDs to withdraw from
+	 * @returns Transaction hash and list of planet IDs for which withdrawals were processed
+	 */
+	async withdraw(planetIds: bigint[]): Promise<{hash: `0x${string}`; planetsWithdrawn: bigint[]}> {
+		const result = await withdrawFromPlanets(
+			this.requireWalletClient(),
+			this.gameContract,
+			planetIds,
+		);
+
+		// Mark the exits as withdrawn in storage
+		const currentTime = Math.floor(Date.now() / 1000);
+		for (const planetId of result.planetsWithdrawn) {
+			await this.storage.markExitWithdrawn(planetId, currentTime);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Get exits that are ready to be withdrawn
+	 *
+	 * Returns all pending exits that:
+	 * - Have completed (exit time has passed)
+	 * - Were not interrupted
+	 * - Have not been withdrawn yet
+	 *
+	 * @returns Array of pending exits ready for withdrawal
+	 */
+	async getWithdrawableExits(): Promise<PendingExit[]> {
+		const sender = this.requireWalletClient().walletClient.account!.address;
+		const allExits = await this.storage.getPendingExitsByPlayer(sender);
+		const currentTime = Math.floor(Date.now() / 1000);
+
+		return allExits.filter((exit) => {
+			// Must be past exit complete time
+			const isPastExitTime = currentTime >= exit.exitCompleteTime;
+			// Must not be interrupted
+			const notInterrupted = !exit.interrupted;
+			// Must not already be withdrawn
+			const notWithdrawn = !exit.withdrawn;
+
+			return isPastExitTime && notInterrupted && notWithdrawn;
+		});
+	}
+
+	/**
+	 * Withdraw all tokens from planets that have completed their exit process
+	 *
+	 * This method automatically finds all pending exits that are:
+	 * - Past their completion time
+	 * - Not interrupted
+	 * - Not already withdrawn
+	 *
+	 * @returns Transaction hash and list of planet IDs for which withdrawals were processed, or null if no withdrawable exits found
+	 */
+	async withdrawAll(): Promise<{hash: `0x${string}`; planetsWithdrawn: bigint[]} | null> {
+		const withdrawableExits = await this.getWithdrawableExits();
+
+		if (withdrawableExits.length === 0) {
+			return null;
+		}
+
+		const planetIds = withdrawableExits.map((exit) => exit.planetId);
+		return this.withdraw(planetIds);
+	}
+
 	/**
 	 * Get planet info by location ID
 	 */

package/src/planet/withdraw.ts

@@ -0,0 +1,33 @@
+import type {Clients, GameContract} from '../types.js';
+
+/**
+ * Withdraw tokens from planets that have completed their exit process
+ *
+ * Uses the fetchAndWithdrawFor contract function which fetches any completed
+ * exits and withdraws the staked tokens to the owner's wallet.
+ *
+ * @param clients - Viem clients (publicClient and walletClient)
+ * @param gameContract - The game contract instance with address and ABI
+ * @param planetIds - Array of planet location IDs to withdraw from
+ * @returns Transaction hash and list of planet IDs for which withdrawals were processed
+ */
+export async function withdrawFromPlanets(
+	clients: Clients,
+	gameContract: GameContract,
+	planetIds: bigint[],
+): Promise<{hash: `0x${string}`; planetsWithdrawn: bigint[]}> {
+	const sender = clients.walletClient.account!.address;
+
+	// Simulate the fetchAndWithdrawFor transaction
+	const simulation = await clients.publicClient.simulateContract({
+		...gameContract,
+		functionName: 'fetchAndWithdrawFor',
+		args: [sender, planetIds],
+		account: sender,
+	});
+
+	// Send the transaction
+	const hash = await clients.walletClient.writeContract(simulation.request);
+
+	return {hash, planetsWithdrawn: planetIds};
+}

package/src/storage/interface.ts

@@ -97,6 +97,13 @@ export interface FleetStorage {
 	 */
 	markExitInterrupted(planetId: bigint, interruptedAt: number, newOwner: Address): Promise<void>;
 
+	/**
+	 * Mark an exit as withdrawn (tokens claimed)
+	 * @param planetId - The planet location ID
+	 * @param withdrawnAt - The timestamp when the tokens were withdrawn
+	 */
+	markExitWithdrawn(planetId: bigint, withdrawnAt: number): Promise<void>;
+
 	/**
 	 * Clean up old completed exits from storage
 	 * @param olderThan - Unix timestamp; exits completed before this time will be removed

package/src/storage/json-storage.ts

@@ -3,7 +3,7 @@ import path from 'path';
 import type {Address} from 'viem';
 import type {FleetStorage} from './interface.js';
 import {PendingExit, PendingFleet} from '../types.js';
-import {stringifyWithBigInt} from '../helpers/index.js';
+import {stringifyWithBigInt} from '../tool-handling/index.js';
 
 interface StorageData {
 	fleets: Record<string, PendingFleet>;
@@ -165,6 +165,16 @@ export class JsonFleetStorage implements FleetStorage {
 		}
 	}
 
+	async markExitWithdrawn(planetId: bigint, withdrawnAt: number): Promise<void> {
+		await this.ensureInitialized();
+		const exit = this.data.exits[planetId.toString()];
+		if (exit) {
+			exit.withdrawn = true;
+			exit.withdrawnAt = withdrawnAt;
+			await this.save();
+		}
+	}
+
 	async cleanupOldCompletedExits(olderThan: number): Promise<void> {
 		await this.ensureInitialized();
 		const now = Math.floor(Date.now() / 1000);