@conquest-eth/tools 0.0.0 → 0.0.2

package/package.json

@@ -1,78 +1,81 @@
 {
-	"name": "@conquest-eth/tools",
-	"version": "0.0.0",
-	"description": "Tools for Conquest.eth, including mcp server",
-	"author": "Ronan Sandford",
-	"license": "MIT",
-	"keywords": [
-		"mcp",
-		"ethereum",
-		"tools",
-		"cli",
-		"conquest.eth"
-	],
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/wighawag/tools-conquest-eth-v0.git"
-	},
-	"homepage": "https://github.com/wighawag/tools-conquest-eth-v0#readme",
-	"bugs": {
-		"url": "https://github.com/wighawag/tools-conquest-eth-v0/issues"
-	},
-	"publishConfig": {
-		"access": "public"
-	},
-	"type": "module",
-	"main": "./dist/index.js",
-	"module": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js"
-		}
-	},
-	"bin": {
-		"conquest": "dist/cli.js"
-	},
-	"files": [
-		"dist",
-		"src"
-	],
-	"sideEffects": false,
-	"dependencies": {
-		"@modelcontextprotocol/sdk": "^1.25.3",
-		"commander": "^14.0.3",
-		"conquest-eth-v0-contracts": "workspace:*",
-		"eip-1193": "^0.6.5",
-		"ldenv": "^0.3.16",
-		"remote-procedure-call": "^0.1.1",
-		"tools-ethereum": "^0.0.1",
-		"viem": "^2.45.1",
-		"zod": "^4.3.6"
-	},
-	"devDependencies": {
-		"@changesets/cli": "^2.29.8",
-		"@modelcontextprotocol/inspector": "^0.19.0",
-		"@types/node": "^25.2.0",
-		"as-soon": "^0.1.5",
-		"prettier": "^3.8.0",
-		"reloaderoo": "^1.1.5",
-		"tsx": "^4.21.0",
-		"typescript": "^5.3.3",
-		"vitest": "^4.0.18"
-	},
-	"scripts": {
-		"prepublishOnly": "pnpm format:check && pnpm build",
-		"release": "pnpm prepublishOnly && git push --all && pnpm changeset publish && git push --tags",
-		"format": "prettier --write .",
-		"format:check": "prettier --check .",
-		"build": "tsc",
-		"dev": "as-soon -w src pnpm build",
-		"test": "vitest run",
-		"test:watch": "vitest",
-		"mcp:inspector": "mcp-inspector",
-		"reloaderoo": "reloaderoo",
-		"start": "reloaderoo proxy --log-level debug -- node ./dist/cli.js --rpc-url http://localhost:8545 --game-contract 0x322813fd9a801c5507c9de605d63cea4f2ce6c44 mcp --ethereum"
-	}
-}
+  "name": "@conquest-eth/tools",
+  "version": "0.0.2",
+  "description": "Tools for Conquest.eth, including mcp server",
+  "author": "Ronan Sandford",
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "ethereum",
+    "tools",
+    "cli",
+    "conquest.eth"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wighawag/tools-conquest-eth-v0.git"
+  },
+  "homepage": "https://github.com/wighawag/tools-conquest-eth-v0#readme",
+  "bugs": {
+    "url": "https://github.com/wighawag/tools-conquest-eth-v0/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "conquest": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@ethersproject/signing-key": "5.7.0",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "@noble/hashes": "^1.6.1",
+    "@noble/secp256k1": "^2.1.0",
+    "commander": "^14.0.3",
+    "eip-1193": "^0.6.5",
+    "ldenv": "^0.3.16",
+    "remote-procedure-call": "^0.1.1",
+    "tools-ethereum": "^0.0.7",
+    "viem": "^2.45.1",
+    "zod": "^4.3.6",
+    "conquest-eth-v0-contracts": "0.0.1"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/inspector": "^0.19.0",
+    "@rocketh/node": "^0.18.2",
+    "@types/node": "^25.2.0",
+    "as-soon": "^0.1.5",
+    "prettier": "^3.8.0",
+    "prool": "^0.2.2",
+    "reloaderoo": "^1.1.5",
+    "tsx": "^4.21.0",
+    "typescript": "^5.3.3",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "release": "pnpm prepublishOnly && git push --all && pnpm changeset publish && git push --tags",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "build": "tsc",
+    "dev": "as-soon -w src pnpm build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "mcp:inspector": "mcp-inspector",
+    "reloaderoo": "reloaderoo",
+    "start": "reloaderoo proxy --log-level debug -- node ./dist/cli.js --rpc-url http://localhost:8545 --game-contract 0x322813fd9a801c5507c9de605d63cea4f2ce6c44 mcp --ethereum"
+  }
+}

package/src/cli.ts

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import {StdioServerTransport} from '@modelcontextprotocol/sdk/server/stdio.js';
-import {createServer} from './index.js';
 import {Command} from 'commander';
 import pkg from '../package.json' with {type: 'json'};
-import {getChain} from 'tools-ethereum/helpers';
 import {loadEnv} from 'ldenv';
 import * as tools from './tools/index.js';
-import {registerAllToolCommands} from './cli-tool-generator.js';
+import {type EnvFactory, registerAllToolCommands} from './tool-handling/cli.js';
+import type {ConquestEnv} from './types.js';
+import {createServer} from './mcp.js';
+import {createConquestEnv} from './index.js';
 
 loadEnv();
 
@@ -15,6 +16,9 @@ const program = new Command();
 // Get the binary name from package.json
 const binName = Object.keys(pkg.bin || {})[0];
 
+// ----------------------------------------------------------------------------
+// GLOBAL OPTIONS
+// ----------------------------------------------------------------------------
 program
 	.name(binName)
 	.description(pkg.description || 'Conquest.eth CLI - MCP server and direct tool execution')
@@ -32,16 +36,65 @@ program
 		'Path to storage directory',
 		process.env.STORAGE_PATH || './data',
 	)
-	.option(
-		'--private-key <key>',
-		'Private key for sending transactions',
-		process.env.PRIVATE_KEY || '',
-	)
 	.action(() => {
 		program.help();
 	});
 
+function gatherGlobalOptions(program: Command) {
+	const globalOptions = program.opts();
+	const rpcUrl = globalOptions.rpcUrl;
+	const gameContract = globalOptions.gameContract;
+
+	const storage = globalOptions.storage;
+	const storagePath = globalOptions.storagePath;
+
+	// 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);
+	}
+
+	const privateKey = process.env.PRIVATE_KEY as `0x${string}`;
+	// Warn if private key is not provided for write operations
+	if (!privateKey) {
+		console.warn('Warning: PRIVATE_KEY environment variable is required for sending transactions');
+	} else if (!privateKey.startsWith('0x')) {
+		console.error('Error: PRIVATE_KEY must start with 0x');
+		process.exit(1);
+	}
+
+	return {rpcUrl, gameContract, privateKey, storage, storagePath};
+}
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+// FACTORY THAT GENERATE THE Conquest Environment Used By Tools
+// ----------------------------------------------------------------------------
+/**
+ * Factory function to create the ConquestEnv from CLI options
+ */
+const envFactory: EnvFactory<ConquestEnv> = async () => {
+	const {rpcUrl, gameContract, privateKey, storage, storagePath} = gatherGlobalOptions(program);
+
+	return createConquestEnv({
+		rpcUrl,
+		gameContract,
+		privateKey,
+		storagePath,
+	});
+};
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
 // MCP subcommand - starts the MCP server
+// ----------------------------------------------------------------------------
 program
 	.command('mcp')
 	.description('Start the MCP server')
@@ -50,60 +103,36 @@ program
 		'Whether to also provide tools-ethereum tools',
 		process.env.ETHEREUM_TOOLS === 'true',
 	)
-	.action(async () => {
-		const options = program.opts();
-		const mcpOptions = program.commands.find((cmd) => cmd.name() === 'mcp')?.opts() || {};
-
-		const rpcUrl = options.rpcUrl;
-		const gameContract = options.gameContract;
-		const ethereum = mcpOptions.ethereum ?? process.env.ETHEREUM_TOOLS === 'true';
-		const privateKey = options.privateKey;
-		const storage = options.storage;
-		const storagePath = options.storagePath;
-
-		// 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);
-		}
-
-		// Warn if private key is not provided for write operations
-		if (!privateKey) {
-			console.warn(
-				'Warning: PRIVATE_KEY environment variable is required for sending transactions',
-			);
-		} else if (!privateKey.startsWith('0x')) {
-			console.error('Error: PRIVATE_KEY must start with 0x');
-			process.exit(1);
-		}
-
-		const chain = await getChain(rpcUrl);
+	.action(async (options) => {
+		const env = await envFactory();
+
+		const ethereum = options.ethereum ?? process.env.ETHEREUM_TOOLS === 'true';
+
 		const transport = new StdioServerTransport();
-		const server = createServer(
-			{
-				chain,
-				privateKey: privateKey as `0x${string}`,
-				gameContract: gameContract as `0x${string}`,
-			},
-			{
-				ethereum,
-				storageConfig: {
-					type: storage as 'json' | 'sqlite',
-					dataDir: storagePath,
-				},
-			},
-		);
+		const server = await createServer(env, {ethereum});
 		await server.connect(transport);
 	});
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+// Register all tool commands dynamically with the CLI config
+registerAllToolCommands(program, tools, envFactory);
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+// HANDLE unknown command
+// ----------------------------------------------------------------------------
+const args = process.argv.slice(2);
+const registeredCommands = program.commands.map((cmd) => cmd.name());
+
+// Check if the first argument is a known command or a global flag
+const isKnown = registeredCommands.includes(args[0]) || args[0]?.startsWith('-');
 
-// Register all tool commands dynamically
-registerAllToolCommands(program, tools);
+if (args.length > 0 && !isKnown) {
+	console.error(`error: unknown command: ${args[0]}`);
+	program.outputHelp();
+	process.exit(1);
+}
+// ----------------------------------------------------------------------------
 
 program.parse(process.argv);

package/src/contracts/space-info.ts

@@ -1,6 +1,17 @@
 import {SpaceInfo} from 'conquest-eth-v0-contracts';
 import type {ClientsWithOptionalWallet, ContractConfig, GameContract} from '../types.js';
 
+// Minimal ABI for reading numTokensPerNativeTokenAt18Decimals from PlayToken
+const PlayTokenAbi = [
+	{
+		name: 'numTokensPerNativeTokenAt18Decimals',
+		type: 'function',
+		stateMutability: 'view',
+		inputs: [],
+		outputs: [{type: 'uint256'}],
+	},
+] as const;
+
 export async function createSpaceInfo(
 	clients: ClientsWithOptionalWallet,
 	gameContract: GameContract,
@@ -11,19 +22,31 @@ export async function createSpaceInfo(
 		functionName: 'getConfig',
 	});
 
+	// Extract stakingToken address and fetch numTokensPerNativeToken from PlayToken contract
+	const stakingToken = config.stakingToken as `0x${string}`;
+	const numTokensPerNativeToken = await clients.publicClient.readContract({
+		address: stakingToken,
+		abi: PlayTokenAbi,
+		functionName: 'numTokensPerNativeTokenAt18Decimals',
+	});
+
 	const contractConfig: ContractConfig = {
 		genesis: BigInt(config.genesis),
 		resolveWindow: BigInt(config.resolveWindow),
 		timePerDistance: BigInt(config.timePerDistance),
 		exitDuration: BigInt(config.exitDuration),
 		acquireNumSpaceships: Number(config.acquireNumSpaceships),
+		stakingToken,
+		numTokensPerNativeToken: BigInt(numTokensPerNativeToken),
 	};
 
 	// Create SpaceInfo instance with config
+	// Note: The contract's getConfig() returns timePerDistance already divided by 4 (see OuterSpaceFacetBase constructor).
+	// SpaceInfo also divides by 4 internally, so we need to multiply by 4 here to compensate.
 	const spaceInfo = new SpaceInfo({
 		genesis: config.genesis as `0x${string}`,
 		resolveWindow: Number(config.resolveWindow),
-		timePerDistance: Number(config.timePerDistance),
+		timePerDistance: Number(config.timePerDistance) * 4,
 		exitDuration: Number(config.exitDuration),
 		acquireNumSpaceships: Number(config.acquireNumSpaceships),
 		productionSpeedUp: Number(config.productionSpeedUp),

package/src/fleet/resolve.ts

@@ -166,7 +166,7 @@ export async function resolveFleetWithSpaceInfo(
 }
 
 /**
- * Get fleets that can be resolved (not yet resolved and past resolve window)
+ * Get fleets that can be resolved (arrived and still within resolve window)
  *
  * @param storage - Storage instance for tracking pending fleets
  * @param resolveWindow - The resolve window duration in seconds from contract config
@@ -180,8 +180,9 @@ export async function getResolvableFleets(
 	const fleets = await storage.getResolvableFleets();
 
 	return fleets.filter((fleet) => {
-		// Check if fleet is past the resolve window
-		const resolveWindowOpen = fleet.estimatedArrivalTime + Number(resolveWindow);
-		return !fleet.resolved && currentTime >= resolveWindowOpen;
+		// Fleet can be resolved after arrival but before resolve window closes
+		const arrivalTime = fleet.estimatedArrivalTime;
+		const resolveWindowEnd = arrivalTime + Number(resolveWindow);
+		return !fleet.resolved && currentTime >= arrivalTime && currentTime < resolveWindowEnd;
 	});
 }

package/src/fleet/send.ts

@@ -3,7 +3,6 @@ import type {SpaceInfo} from 'conquest-eth-v0-contracts';
 import type {FleetStorage} from '../storage/interface.js';
 import type {Clients, ContractConfig, GameContract, PendingFleet} from '../types.js';
 import {computeFleetId, computeToHash, generateSecret} from '../util/hashing.js';
-import {calculateEstimatedArrivalTime, getCurrentTimestamp} from '../util/time.js';
 
 /**
  * Send a fleet to a destination planet
@@ -56,12 +55,14 @@ export async function sendFleet(
 	// Generate secret if not provided
 	const secret = options?.secret || generateSecret();
 
-	// Calculate estimated arrival time using contract config
-	const estimatedArrivalTime = calculateEstimatedArrivalTime({
-		startTime: BigInt(getCurrentTimestamp()),
-		distance: BigInt(distance),
-		timePerDistance: contractConfig.timePerDistance,
-	});
+	// Get current blockchain timestamp (not local time) for accurate arrival calculation
+	const block = await clients.publicClient.getBlock();
+	const blockTimestamp = Number(block.timestamp);
+
+	// Calculate estimated arrival time using SpaceInfo which accounts for planet speed
+	// The travel time formula is: distance * (timePerDistance * 10000) / speed
+	const travelTime = spaceInfo.timeToArrive(fromPlanet, toPlanet);
+	const estimatedArrivalTime = blockTimestamp + travelTime;
 
 	const parameters = {
 		gift: options?.gift ?? false,
@@ -94,7 +95,7 @@ export async function sendFleet(
 		arrivalTimeWanted: parameters.arrivalTimeWanted,
 		fleetSender,
 		operator,
-		committedAt: getCurrentTimestamp(),
+		committedAt: blockTimestamp,
 		estimatedArrivalTime,
 		resolved: false,
 	};

package/src/index.ts

@@ -1,181 +1,47 @@
-import {McpServer} from '@modelcontextprotocol/sdk/server/mcp.js';
-import pkg from '../package.json' with {type: 'json'};
-import {Implementation} from '@modelcontextprotocol/sdk/types.js';
-import {Chain} from 'viem';
-import {ServerOptions} from '@modelcontextprotocol/sdk/server';
-import {createServer as createMCPEthereumServer} from 'tools-ethereum';
-import {getClients} from 'tools-ethereum/helpers';
+import {getClients, 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 type {
+	ClientsWithOptionalWallet,
+	ConquestEnv,
+	EnvFactoryOptions,
+	GameContract,
+} from './types.js';
 
-// Import refactored tools
-import * as tools from './tools/index.js';
-import {registerTool, stringifyWithBigInt} from './helpers/index.js';
 import {Abi_IOuterSpace} from 'conquest-eth-v0-contracts/abis/IOuterSpace.js';
 
 /**
- * Create and configure an MCP server for Conquest.eth game interactions
+ * Factory function to create the ConquestEnv
+ * This is shared between CLI and MCP server
  *
- * @param params - Configuration parameters for the server
- * @param params.chain - The blockchain chain to connect to
- * @param params.privateKey - Optional private key for signing transactions (wallet operations)
- * @param params.gameContract - The game contract address
- * @param options - Optional server configuration
- * @param options.ethereum - Whether to include Ethereum MCP tools (default: false)
- * @param options.rpcURL - Optional custom RPC URL
- * @param options.serverOptions - Optional MCP server options
- * @param options.serverInfo - Optional server metadata to override defaults
- * @param options.storageConfig - Storage configuration for fleets and exits
- * @param options.storageConfig.type - Storage type ('json' or 'sqlite')
- * @param options.storageConfig.dataDir - Optional data directory path
- * @returns Configured MCP server instance with Conquest game tools registered
+ * @param options - Configuration options for creating the environment
+ * @returns ConquestEnv with fleetManager and planetManager
  */
-export function createServer(
-	params: {chain: Chain; privateKey?: `0x${string}`; gameContract: `0x${string}`},
-	options?: {
-		ethereum?: boolean;
-		rpcURL?: string;
-		serverOptions?: ServerOptions;
-		serverInfo?: Implementation;
-		storageConfig?: {type: 'json' | 'sqlite'; dataDir?: string};
-	},
-) {
-	const {gameContract: gameContractAddress, ...mcpEthereumParams} = params;
-	const clients = getClients(params, options) as ClientsWithOptionalWallet;
+export async function createConquestEnv(options: EnvFactoryOptions): Promise<ConquestEnv> {
+	const {rpcUrl, gameContract: gameContractAddress, privateKey, storagePath = './data'} = options;
+
+	const chain = await getChain(rpcUrl);
+	const clients = getClients({
+		chain,
+		privateKey,
+	}) as ClientsWithOptionalWallet;
 
 	const gameContract: GameContract = {
 		address: gameContractAddress,
 		abi: Abi_IOuterSpace,
 	};
 
-	const name = `mcp-conquest-eth-v0`;
-	const server = options?.ethereum
-		? createMCPEthereumServer(mcpEthereumParams, {
-				...options,
-				serverInfo: {name, version: pkg.version, ...options?.serverInfo},
-			})
-		: new McpServer(
-				options?.serverInfo || {
-					name,
-					version: pkg.version,
-				},
-				options?.serverOptions || {capabilities: {logging: {}}},
-			);
-
-	// Initialize SpaceInfo and contractConfig
-	let spaceInfo: SpaceInfo | null = null;
-	let contractConfig: ContractConfig | null = null;
+	const {spaceInfo, contractConfig} = await createSpaceInfo(clients, gameContract);
+	const storage = new JsonFleetStorage(storagePath);
 
-	const initSpaceInfo = async () => {
-		if (!spaceInfo || !contractConfig) {
-			const result = await createSpaceInfo(clients, gameContract);
-			spaceInfo = result.spaceInfo;
-			contractConfig = result.contractConfig;
-		}
-		return {spaceInfo, contractConfig};
+	return {
+		fleetManager: new FleetManager(clients, gameContract, spaceInfo, contractConfig, storage),
+		planetManager: new PlanetManager(clients, gameContract, spaceInfo, contractConfig, storage),
+		spaceInfo,
+		contractConfig,
+		clients,
+		options,
 	};
-
-	// Initialize storage
-	const storageConfig = options?.storageConfig || {type: 'json', dataDir: './data'};
-	const storage = new JsonFleetStorage(storageConfig.dataDir || './data');
-
-	// Initialize managers (will be initialized after spaceInfo is ready)
-	let fleetManager: FleetManager | null = null;
-	let planetManager: PlanetManager | null = null;
-
-	// Helper to ensure managers are initialized
-	const ensureManagersInitialized = async () => {
-		const {spaceInfo: si, contractConfig: cc} = await initSpaceInfo();
-
-		// Initialize fleetManager even without walletClient for read-only operations
-		if (!fleetManager && si && cc) {
-			fleetManager = new FleetManager(clients, gameContract, si, cc, storage);
-		}
-
-		// Initialize planetManager even without walletClient for read-only operations
-		if (!planetManager && si && cc) {
-			planetManager = new PlanetManager(clients, gameContract, si, cc, storage);
-		}
-
-		if (!fleetManager) {
-			throw new Error('Fleet manager not initialized');
-		}
-		if (!planetManager) {
-			throw new Error('Planet manager not initialized');
-		}
-
-		return {fleetManager, planetManager};
-	};
-
-	// Auto-register all tools
-	for (const [name, tool] of Object.entries(tools)) {
-		// Skip the file that's not a tool
-		if (name === 'default') continue;
-
-		server.registerTool(
-			name,
-			{
-				description: tool.description,
-				inputSchema: tool.schema,
-			},
-			async (args: unknown) => {
-				try {
-					const {fleetManager, planetManager} = await ensureManagersInitialized();
-
-					const env = {
-						sendStatus: async (_message: string) => {
-							// TODO: Implement progress notifications when sessionId is available
-						},
-						fleetManager,
-						planetManager,
-					};
-
-					const result = await tool.execute(env, args as any);
-
-					// Convert ToolResult to CallToolResult
-					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),
-							},
-						],
-					};
-				} catch (error) {
-					return {
-						content: [
-							{
-								type: 'text' as const,
-								text: stringifyWithBigInt({
-									error: error instanceof Error ? error.message : String(error),
-								}),
-							},
-						],
-						isError: true,
-					};
-				}
-			},
-		);
-	}
-
-	return server;
 }