@conquest-eth/tools 0.0.0 → 0.0.2

package/src/tools/withdraw.ts

@@ -0,0 +1,100 @@
+import {z} from 'zod';
+import {createTool} from '../tool-handling/types.js';
+import type {ConquestEnv} from '../types.js';
+
+const schema = z.object({
+	coordinates: z
+		.array(
+			z.object({
+				x: z.number().describe('X coordinate of the planet'),
+				y: z.number().describe('Y coordinate of the planet'),
+			}),
+		)
+		.optional()
+		.describe(
+			'Optional array of planet coordinates to withdraw tokens from. If not provided, automatically withdraws from all planets that have completed exits and are ready for withdrawal.',
+		),
+});
+
+export const withdraw = createTool<typeof schema, ConquestEnv>({
+	description:
+		'Withdraw staked tokens from planets that have completed their exit process. If coordinates are provided, withdraws from those specific planets. If no coordinates are provided, automatically finds and withdraws from all planets with completed exits that have not been withdrawn yet.',
+	schema,
+	execute: async (env, {coordinates}) => {
+		try {
+			// If coordinates are provided, withdraw from specific planets
+			if (coordinates && coordinates.length > 0) {
+				// Convert x,y coordinates to planet IDs
+				const planetIdsBigInt: bigint[] = [];
+				for (const coord of coordinates) {
+					const planetId = env.planetManager.getPlanetIdByCoordinates(coord.x, coord.y);
+					if (planetId === undefined) {
+						throw new Error(`No planet found at coordinates (${coord.x}, ${coord.y})`);
+					}
+					planetIdsBigInt.push(planetId);
+				}
+
+				// Call withdraw method
+				const result = await env.planetManager.withdraw(planetIdsBigInt);
+
+				return {
+					success: true,
+					result: {
+						transactionHash: result.hash,
+						coordinates: coordinates,
+						planetsWithdrawn: result.planetsWithdrawn.map((id) => id.toString()),
+					},
+				};
+			}
+
+			// No coordinates provided - automatically find and withdraw all ready exits
+			const withdrawableExits = await env.planetManager.getWithdrawableExits();
+
+			if (withdrawableExits.length === 0) {
+				return {
+					success: true,
+					result: {
+						message: 'No planets with completed exits ready for withdrawal',
+						planetsWithdrawn: [],
+					},
+				};
+			}
+
+			// Get coordinates for the withdrawable planets (for return value)
+			const withdrawableCoordinates = withdrawableExits
+				.map((exit) => {
+					const planet = env.planetManager.getPlanetInfo(exit.planetId);
+					return planet ? {x: planet.location.x, y: planet.location.y} : null;
+				})
+				.filter((c): c is {x: number; y: number} => c !== null);
+
+			// Withdraw all
+			const result = await env.planetManager.withdrawAll();
+
+			if (!result) {
+				return {
+					success: true,
+					result: {
+						message: 'No planets with completed exits ready for withdrawal',
+						planetsWithdrawn: [],
+					},
+				};
+			}
+
+			return {
+				success: true,
+				result: {
+					transactionHash: result.hash,
+					coordinates: withdrawableCoordinates,
+					planetsWithdrawn: result.planetsWithdrawn.map((id) => id.toString()),
+					message: `Successfully withdrew tokens from ${result.planetsWithdrawn.length} planet(s)`,
+				},
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : String(error),
+			};
+		}
+	},
+});

package/src/types.ts

@@ -1,11 +1,36 @@
 import type {Address, PublicClient, WalletClient} from 'viem';
-import type {PlanetInfo} from 'conquest-eth-v0-contracts';
+import type {PlanetInfo, SpaceInfo} from 'conquest-eth-v0-contracts';
 import type {Abi_IOuterSpace} from 'conquest-eth-v0-contracts/abis/IOuterSpace.js';
-import type {CallToolResult} from '@modelcontextprotocol/sdk/types.js';
-import {z} from 'zod';
 import type {FleetManager} from './fleet/manager.js';
 import type {PlanetManager} from './planet/manager.js';
 
+/**
+ * Configuration options for creating the ConquestEnv
+ */
+export interface EnvFactoryOptions {
+	/** RPC URL for the Ethereum network */
+	rpcUrl: string;
+	/** Contract address of the game */
+	gameContract: `0x${string}`;
+	/** Optional private key for sending transactions */
+	privateKey?: `0x${string}`;
+	/** Path to storage directory (default: './data') */
+	storagePath?: string;
+}
+
+/**
+ * Environment type for Conquest tools
+ * Contains the managers needed for tool execution
+ */
+export interface ConquestEnv {
+	fleetManager: FleetManager;
+	planetManager: PlanetManager;
+	spaceInfo: SpaceInfo;
+	contractConfig: ContractConfig;
+	clients: ClientsWithOptionalWallet;
+	options: EnvFactoryOptions;
+}
+
 export interface StorageConfig {
 	type: 'json' | 'sqlite';
 	dataDir?: string; // Default: `${cwd}/data`
@@ -32,7 +57,9 @@ export interface ContractConfig {
 	timePerDistance: bigint;
 	exitDuration: bigint;
 	acquireNumSpaceships: number;
-	[key: string]: bigint | number;
+	stakingToken: `0x${string}`;
+	numTokensPerNativeToken: bigint;
+	[key: string]: bigint | number | `0x${string}`;
 }
 
 export interface ExternalPlanet {
@@ -66,6 +93,8 @@ export interface PendingExit {
 	completed: boolean; // Whether exit has completed
 	interrupted: boolean; // Whether exit was interrupted by attack
 	lastCheckedAt: number; // Last time status was verified against contract
+	withdrawn: boolean; // Whether tokens have been withdrawn
+	withdrawnAt?: number; // Timestamp when tokens were withdrawn
 }
 
 export interface PlanetWithDistance {
@@ -109,70 +138,3 @@ export interface FleetResolution {
 	fleetSender: `0x${string}`; // Address that sent the fleet
 	operator: `0x${string}`; // Address that committed the transaction
 }
-
-// Tool types for MCP server refactoring
-export type ToolEnvironment = {
-	// Function to send status updates during tool execution (required)
-	sendStatus: (message: string) => Promise<void>;
-	// Fleet manager for fleet operations
-	fleetManager: FleetManager;
-	// Planet manager for planet operations
-	planetManager: PlanetManager;
-};
-
-// Result returned by tool execute functions
-export type ToolResult =
-	| {success: true; result: Record<string, any>}
-	| {success: false; error: string; stack?: string};
-
-// Tool definition with execute, schema, and description
-export type Tool<S extends z.ZodObject<any> = z.ZodObject<any>> = {
-	description: string;
-	schema: S;
-	execute: (env: ToolEnvironment, params: z.infer<S>) => Promise<ToolResult>;
-};
-
-// Helper function to create a tool with automatic type inference
-export function createTool<S extends z.ZodObject<any>>(config: {
-	description: string;
-	schema: S;
-	execute: (env: ToolEnvironment, params: z.infer<S>) => Promise<ToolResult>;
-}): Tool<S> {
-	return config;
-}
-
-// Convert ToolResult to CallToolResult format
-export function convertToCallToolResult(result: ToolResult): CallToolResult {
-	// Import stringifyWithBigInt to handle BigInt serialization
-	const stringifyWithBigInt = (obj: any, space?: number): string => {
-		return JSON.stringify(
-			obj,
-			(_key, value) => (typeof value === 'bigint' ? value.toString() : value),
-			space,
-		);
-	};
-
-	if (result.success === false) {
-		return {
-			content: [
-				{
-					type: 'text' as const,
-					text: stringifyWithBigInt({
-						error: result.error,
-						...(result.stack ? {stack: result.stack} : {}),
-					}),
-				},
-			],
-			isError: true,
-		};
-	}
-
-	return {
-		content: [
-			{
-				type: 'text' as const,
-				text: stringifyWithBigInt(result.result, 2),
-			},
-		],
-	};
-}

package/src/util/time.ts

@@ -5,52 +5,6 @@ export function getCurrentTimestamp(): number {
 	return Math.floor(Date.now() / 1000);
 }
 
-/**
- * Calculate estimated arrival time based on distance and timePerDistance
- *
- * @param distance - The distance between planets
- * @param timePerDistance - Time multiplier from contract config (seconds per distance unit)
- * @param genesis - Genesis timestamp from contract config
- * @returns Estimated arrival time in seconds
- */
-export function calculateEstimatedArrivalTime(params: {
-	startTime: bigint;
-	distance: bigint;
-	timePerDistance: bigint;
-}): number {
-	const {startTime, distance, timePerDistance} = params;
-	const travelTime = Number(distance) * Number(timePerDistance);
-	return Number(startTime) + travelTime;
-}
-
-/**
- * Calculate when the resolve window opens
- * A fleet can be resolved after it arrives and the resolve window has passed
- *
- * @param estimatedArrivalTime - When the fleet is estimated to arrive
- * @param resolveWindow - The resolve window duration in seconds from contract config
- * @returns The timestamp when the fleet can be resolved
- */
-export function calculateResolveWindowOpen(
-	estimatedArrivalTime: number,
-	resolveWindow: bigint,
-): number {
-	return estimatedArrivalTime + Number(resolveWindow);
-}
-
-/**
- * Check if a fleet can be resolved now
- *
- * @param estimatedArrivalTime - When the fleet was estimated to arrive
- * @param resolveWindow - The resolve window duration in seconds
- * @returns True if the fleet can be resolved now
- */
-export function canResolveNow(estimatedArrivalTime: number, resolveWindow: bigint): boolean {
-	const currentTime = getCurrentTimestamp();
-	const resolveWindowOpen = calculateResolveWindowOpen(estimatedArrivalTime, resolveWindow);
-	return currentTime >= resolveWindowOpen;
-}
-
 /**
  * Format timestamp as ISO string
  */

package/src/cli-tool-generator.ts

@@ -1,287 +0,0 @@
-import {Command} from 'commander';
-import {z} from 'zod';
-import type {Tool, ToolEnvironment, StorageConfig} from './types.js';
-import {getClients} from 'tools-ethereum/helpers';
-import {getChain} from 'tools-ethereum/helpers';
-import {createSpaceInfo} from './contracts/space-info.js';
-import {JsonFleetStorage} from './storage/json-storage.js';
-import {FleetManager} from './fleet/manager.js';
-import {PlanetManager} from './planet/manager.js';
-import type {ClientsWithOptionalWallet, ContractConfig, GameContract} from './types.js';
-import {SpaceInfo} from 'conquest-eth-v0-contracts';
-import {Abi_IOuterSpace} from 'conquest-eth-v0-contracts/abis/IOuterSpace.js';
-
-/**
- * CLI configuration parameters
- */
-export interface CliConfig {
-	chain: any;
-	privateKey?: `0x${string}`;
-	gameContract: `0x${string}`;
-	ethereum?: boolean;
-	storageConfig: StorageConfig;
-}
-
-/**
- * Convert Zod schema field to commander.js option definition
- */
-function zodFieldToOption(name: string, field: z.ZodTypeAny): string {
-	if (field instanceof z.ZodBoolean) {
-		return `--${name}`;
-	}
-	return `--${name} <value>`;
-}
-
-/**
- * Parse option value based on Zod type
- */
-function parseOptionValue(field: z.ZodTypeAny, value: any): any {
-	if (field instanceof z.ZodArray) {
-		return typeof value === 'string' ? value.split(',').map((v) => v.trim()) : value;
-	}
-	if (field instanceof z.ZodNumber) {
-		return Number(value);
-	}
-	if (field instanceof z.ZodBoolean) {
-		return value === true || value === 'true';
-	}
-	return value;
-}
-
-/**
- * Extract description from Zod schema field
- */
-function getFieldDescription(field: z.ZodTypeAny): string {
-	return (field as any).description || 'No description available';
-}
-
-/**
- * Check if a Zod field is optional
- */
-function isOptionalField(field: z.ZodTypeAny): boolean {
-	return field instanceof z.ZodOptional || field.isOptional?.();
-}
-
-/**
- * Create a CLI tool environment for executing tools
- */
-async function createCliToolEnvironment(config: CliConfig): Promise<ToolEnvironment> {
-	const {gameContract: gameContractAddress, chain, storageConfig} = config;
-
-	// Get clients
-	const clients = getClients({chain, privateKey: config.privateKey}) as ClientsWithOptionalWallet;
-
-	// Initialize game contract
-	const gameContract: GameContract = {
-		address: gameContractAddress,
-		abi: Abi_IOuterSpace,
-	};
-
-	// Initialize SpaceInfo
-	const {spaceInfo, contractConfig} = await createSpaceInfo(clients, gameContract);
-
-	// Initialize storage
-	const storage = new JsonFleetStorage(storageConfig.dataDir || './data');
-
-	// Initialize managers
-	const fleetManager = new FleetManager(clients, gameContract, spaceInfo, contractConfig, storage);
-	const planetManager = new PlanetManager(
-		clients,
-		gameContract,
-		spaceInfo,
-		contractConfig,
-		storage,
-	);
-
-	return {
-		fleetManager,
-		planetManager,
-		sendStatus: async (message: string) => {
-			console.log(`[Status] ${message}`);
-		},
-	};
-}
-
-/**
- * Parse and validate parameters against Zod schema
- */
-async function parseAndValidateParams(
-	schema: z.ZodObject<any>,
-	options: Record<string, any>,
-): Promise<any> {
-	try {
-		return await schema.parseAsync(options);
-	} catch (error) {
-		if (error instanceof z.ZodError) {
-			console.error('Parameter validation error:');
-			for (const err of error.issues) {
-				console.error(`  - ${err.path.join('.')}: ${err.message}`);
-			}
-		}
-		throw error;
-	}
-}
-
-/**
- * Format tool result for CLI output
- */
-function formatToolResult(result: {
-	success: boolean;
-	result?: any;
-	error?: string;
-	stack?: string;
-}): void {
-	if (result.success) {
-		console.log(JSON.stringify(result.result, null, 2));
-	} else {
-		console.error(
-			JSON.stringify(
-				{error: result.error, ...(result.stack ? {stack: result.stack} : {})},
-				null,
-				2,
-			),
-		);
-		process.exit(1);
-	}
-}
-
-/**
- * Generate a single tool command from tool definition
- */
-export function generateToolCommand(
-	program: Command,
-	toolName: string,
-	tool: Tool<z.ZodObject<any>>,
-): void {
-	const shape = tool.schema.shape;
-	const cmd = program.command(toolName).description(tool.description);
-
-	// Add options for each schema field
-	for (const [fieldName, field] of Object.entries(shape)) {
-		const actualField = isOptionalField(field as z.ZodTypeAny)
-			? (field as z.ZodOptional<any>).unwrap()
-			: field;
-
-		// Handle nested objects by flattening them
-		if (actualField instanceof z.ZodObject) {
-			const nestedShape = actualField.shape;
-			for (const [nestedKey, nestedField] of Object.entries(nestedShape)) {
-				const optionName = `${fieldName}-${nestedKey}`;
-				const optionDef = zodFieldToOption(optionName, nestedField);
-				const description = getFieldDescription(nestedField);
-				cmd.option(optionDef, description);
-			}
-		} else {
-			const optionDef = zodFieldToOption(fieldName, actualField);
-			const description = getFieldDescription(actualField);
-
-			if (isOptionalField(field as z.ZodTypeAny)) {
-				cmd.option(optionDef, description);
-			} else {
-				cmd.requiredOption(optionDef, description);
-			}
-		}
-	}
-
-	cmd.action(async (options: Record<string, any>) => {
-		try {
-			const globalOptions = program.opts();
-
-			// Get global options
-			const rpcUrl = options.rpcUrl || globalOptions.rpcUrl || process.env.RPC_URL;
-			const gameContract =
-				options.gameContract || globalOptions.gameContract || process.env.GAME_CONTRACT;
-			const ethereum =
-				options.ethereum ?? globalOptions.ethereum ?? process.env.ETHEREUM_TOOLS === 'true';
-			const privateKey = options.privateKey || globalOptions.privateKey || process.env.PRIVATE_KEY;
-			const storageType =
-				options.storage || globalOptions.storage || process.env.STORAGE_TYPE || 'json';
-			const storagePath =
-				options.storagePath || globalOptions.storagePath || process.env.STORAGE_PATH || './data';
-
-			// Validate required options
-			if (!rpcUrl) {
-				console.error('Error: --rpc-url option or RPC_URL environment variable is required');
-				process.exit(1);
-			}
-			if (!gameContract) {
-				console.error(
-					'Error: --game-contract option or GAME_CONTRACT environment variable is required',
-				);
-				process.exit(1);
-			}
-
-			// Get chain
-			const chain = await getChain(rpcUrl);
-
-			// Parse and validate parameters
-			const params: Record<string, any> = {};
-			for (const [fieldName, field] of Object.entries(shape)) {
-				const actualField = isOptionalField(field as z.ZodTypeAny)
-					? (field as z.ZodOptional<any>).unwrap()
-					: field;
-
-				if (actualField instanceof z.ZodObject) {
-					// Handle nested object - reconstruct from flattened options
-					const nestedResult: Record<string, any> = {};
-					const nestedShape = actualField.shape;
-					for (const [nestedKey, nestedField] of Object.entries(nestedShape)) {
-						const optionName = `${fieldName}-${nestedKey}`;
-						if (options[optionName] !== undefined) {
-							nestedResult[nestedKey] = parseOptionValue(nestedField, options[optionName]);
-						}
-					}
-					params[fieldName] = nestedResult;
-				} else {
-					const value = options[fieldName];
-					if (value !== undefined) {
-						params[fieldName] = parseOptionValue(actualField, value);
-					}
-				}
-			}
-
-			const validatedParams = await parseAndValidateParams(tool.schema, params);
-
-			// Create environment and execute
-			const env = await createCliToolEnvironment({
-				chain,
-				privateKey: privateKey as `0x${string}`,
-				gameContract: gameContract as `0x${string}`,
-				ethereum,
-				storageConfig: {
-					type: storageType as 'json' | 'sqlite',
-					dataDir: storagePath,
-				},
-			});
-
-			const result = await tool.execute(env, validatedParams);
-			formatToolResult(result);
-		} catch (error) {
-			if (error instanceof Error) {
-				console.error(
-					JSON.stringify(
-						{error: error.message, ...(error.stack ? {stack: error.stack} : {})},
-						null,
-						2,
-					),
-				);
-			} else {
-				console.error(JSON.stringify({error: String(error)}, null, 2));
-			}
-			process.exit(1);
-		}
-	});
-}
-
-/**
- * Register all tool commands from a tools object
- */
-export function registerAllToolCommands(program: Command, tools: Record<string, Tool>): void {
-	for (const [toolName, tool] of Object.entries(tools)) {
-		// Skip the file that's not a tool
-		if (toolName === 'default') continue;
-
-		// Keep snake_case for CLI command names (1:1 mapping with tool names)
-		generateToolCommand(program, toolName, tool);
-	}
-}

package/src/helpers/index.ts

@@ -1,59 +0,0 @@
-import type {Tool, ToolEnvironment} from '../types.js';
-import type {McpServer} from '@modelcontextprotocol/sdk/server/mcp.js';
-import type {FleetManager} from '../fleet/manager.js';
-import type {PlanetManager} from '../planet/manager.js';
-import {convertToCallToolResult} from '../types.js';
-
-// Helper function to handle BigInt serialization in JSON.stringify
-export function stringifyWithBigInt(obj: any, space?: number): string {
-	return JSON.stringify(
-		obj,
-		(_key, value) => (typeof value === 'bigint' ? value.toString() : value),
-		space,
-	);
-}
-
-// Create tool environment with sendStatus
-export function createToolEnvironment(
-	server: McpServer,
-	fleetManager: FleetManager,
-	planetManager: PlanetManager,
-): ToolEnvironment {
-	return {
-		sendStatus: async (_message: string) => {
-			// TODO: Implement progress notifications when sessionId is available
-			// For now, this is a no-op since we don't have sessionId in the current architecture
-		},
-		fleetManager,
-		planetManager,
-	};
-}
-
-// Register tool with MCP server
-export function registerTool({
-	server,
-	name,
-	tool,
-	fleetManager,
-	planetManager,
-}: {
-	server: McpServer;
-	name: string;
-	tool: Tool<any>;
-	fleetManager: FleetManager;
-	planetManager: PlanetManager;
-}): void {
-	server.registerTool(
-		name,
-		{
-			description: tool.description,
-			inputSchema: tool.schema as any,
-		},
-		async (params: unknown) => {
-			const env = createToolEnvironment(server, fleetManager, planetManager);
-
-			const result = await tool.execute(env, params as any);
-			return convertToCallToolResult(result);
-		},
-	);
-}

package/src/tools/get_my_planets.ts

@@ -1,30 +0,0 @@
-import {z} from 'zod';
-import {createTool} from '../types.js';
-
-export const get_my_planets = createTool({
-	description: 'Get all planets owned by the current user address.',
-	schema: z.object({
-		radius: z.number().max(50).describe('Search radius around origin (0,0) to find planets'),
-	}),
-	execute: async (env, {radius}) => {
-		try {
-			const planets = await env.planetManager.getMyPlanets(radius);
-
-			return {
-				success: true,
-				result: {
-					planets: planets.map(({info, state}) => ({
-						planetId: info.location.id.toString(),
-						location: info.location,
-						...state,
-					})),
-				},
-			};
-		} catch (error) {
-			return {
-				success: false,
-				error: error instanceof Error ? error.message : String(error),
-			};
-		}
-	},
-});