@conquest-eth/tools 0.0.0

package/src/tools/verify_exit_status.ts

@@ -0,0 +1,43 @@
+import {z} from 'zod';
+import {createTool} from '../types.js';
+
+export const verify_exit_status = createTool({
+	description:
+		"Check and update the status of a planet's exit operation. Verifies if the exit has completed or been interrupted.",
+	schema: z.object({
+		planetId: z
+			.union([z.string(), z.number()])
+			.describe('Planet location ID to verify (as hex string or number)'),
+	}),
+	execute: async (env, {planetId}) => {
+		try {
+			const result = await env.planetManager.verifyExitStatus(
+				typeof planetId === 'string' ? BigInt(planetId) : BigInt(planetId),
+			);
+
+			// Calculate status based on exit state
+			const currentTime = Math.floor(Date.now() / 1000);
+			const completed = currentTime >= result.exit.exitCompleteTime;
+			const status = result.interrupted ? 'interrupted' : completed ? 'completed' : 'in_progress';
+			const owner = result.newOwner || result.exit.player;
+
+			return {
+				success: true,
+				result: {
+					planetId: result.exit.planetId,
+					status,
+					completed,
+					interrupted: result.interrupted,
+					owner,
+					exitStartTime: result.exit.exitStartTime,
+					exitCompleteTime: result.exit.exitCompleteTime,
+				},
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : String(error),
+			};
+		}
+	},
+});

package/src/types.ts

@@ -0,0 +1,178 @@
+import type {Address, PublicClient, WalletClient} from 'viem';
+import type {PlanetInfo} 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';
+
+export interface StorageConfig {
+	type: 'json' | 'sqlite';
+	dataDir?: string; // Default: `${cwd}/data`
+}
+
+export type GameContract = {
+	address: Address;
+	abi: Abi_IOuterSpace;
+};
+
+export type ClientsWithOptionalWallet = {
+	walletClient?: WalletClient;
+	publicClient: PublicClient;
+};
+
+export type Clients = {
+	walletClient: WalletClient;
+	publicClient: PublicClient;
+};
+
+export interface ContractConfig {
+	genesis: bigint;
+	resolveWindow: bigint;
+	timePerDistance: bigint;
+	exitDuration: bigint;
+	acquireNumSpaceships: number;
+	[key: string]: bigint | number;
+}
+
+export interface ExternalPlanet {
+	owner?: `0x${string}`;
+	ownerYakuzaSubscriptionEndTime: number;
+	lastUpdatedSaved: number;
+	startExitTime: number;
+	numSpaceships: number;
+	flagTime: number;
+	travelingUpkeep: number;
+	overflow: number;
+	active: boolean;
+	exiting: boolean;
+	exitTimeLeft: number;
+	natives: boolean;
+	capturing: boolean;
+	inReach: boolean;
+	rewardGiver: `0x${string}`;
+	requireClaimAcknowledgement?: string;
+	metadata: Record<string, string | number | boolean>;
+}
+
+export interface PendingExit {
+	planetId: bigint; // Planet location ID
+	player: string; // Player who initiated the exit
+	exitStartTime: number; // Timestamp when exit was initiated
+	exitDuration: number; // Duration of exit process (typically 7 days)
+	exitCompleteTime: number; // When exit will complete
+	numSpaceships: number; // Spaceships on planet at exit start
+	owner: string; // Current owner (may change due to attacks)
+	completed: boolean; // Whether exit has completed
+	interrupted: boolean; // Whether exit was interrupted by attack
+	lastCheckedAt: number; // Last time status was verified against contract
+}
+
+export interface PlanetWithDistance {
+	info: PlanetInfo;
+	state?: ExternalPlanet;
+	distance: number;
+	hasPendingExit?: boolean;
+	exitInfo?: {
+		exitStartTime: number;
+		exitCompleteTime: number;
+		timeUntilComplete: number;
+	};
+}
+
+export interface PendingFleet {
+	hash?: `0x${string}`; // Hash of the fleet (toHash)
+	fleetId: string; // Computed from toHash, from, fleetSender, operator
+	fromPlanetId: bigint; // Source planet location
+	toPlanetId: bigint; // Destination planet location (hidden during commit)
+	quantity: number; // Number of spaceships
+	secret: `0x${string}`; // Random secret for hash commitment
+	gift: boolean; // Whether this is a gift (no combat)
+	specific: `0x${string}`; // Specific target address (advanced feature)
+	arrivalTimeWanted: bigint; // Preferred arrival time (advanced feature)
+	fleetSender: `0x${string}`; // Address that sent the fleet
+	operator: `0x${string}`; // Address that committed the transaction
+	committedAt: number; // Timestamp of commit transaction
+	estimatedArrivalTime: number; // Estimated arrival time
+	resolved: boolean; // Whether fleet has been revealed/resolved
+	resolvedAt?: number; // Timestamp of resolution
+}
+
+export interface FleetResolution {
+	from: bigint; // Source planet location
+	to: bigint; // Destination planet location
+	distance: bigint; // Distance between planets
+	arrivalTimeWanted: bigint; // Preferred arrival time
+	gift: boolean; // Whether this is a gift
+	specific: `0x${string}`; // Specific target address
+	secret: `0x${string}`; // The secret used to generate the hash
+	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/hashing.ts

@@ -0,0 +1,60 @@
+import type {Address} from 'viem';
+import {encodeAbiParameters, encodePacked, keccak256, zeroAddress} from 'viem';
+
+/**
+ * Compute the toHash used in fleet commit phase
+ * This hashes the destination planet and secret together
+ *
+ * @param toPlanetId - The destination planet location ID
+ * @param secret - The secret value to commit to
+ * @returns The hash commitment (keccak256 hash)
+ */
+export function computeToHash(
+	toPlanetId: bigint,
+	secret: `0x${string}`,
+	options: {gift: boolean; specific: Address; arrivalTimeWanted: bigint},
+): `0x${string}` {
+	const toHash = keccak256(
+		encodePacked(
+			['bytes32', 'uint256', 'bool', 'address', 'uint256'],
+			[secret, toPlanetId, options.gift, options.specific, options.arrivalTimeWanted],
+		),
+	);
+	return toHash;
+}
+
+/**
+ * Compute the fleet ID from send transaction parameters
+ * The fleet ID is computed from: toHash, from, fleetSender, operator
+ * This matches what the contract emits in the FleetSent event
+ *
+ * @param toHash - The hash commitment to destination and secret
+ * @param fromPlanetId - The source planet location ID
+ * @param fleetSender - The address that owns the fleet
+ * @param operator - The address that committed the transaction
+ * @returns The fleet ID (keccak256 hash)
+ */
+export function computeFleetId(
+	toHash: `0x${string}`,
+	fromPlanetId: bigint,
+	fleetSender: Address,
+	operator: Address,
+): `0x${string}` {
+	return keccak256(
+		encodePacked(
+			['bytes32', 'uint256', 'address', 'address'],
+			[toHash, BigInt(fromPlanetId), fleetSender, operator],
+		),
+	);
+}
+
+/**
+ * Generate a random secret for fleet commitment
+ *
+ * @returns A cryptographically random 32-byte hex string
+ */
+export function generateSecret(): `0x${string}` {
+	const randomBytes = new Uint8Array(32);
+	crypto.getRandomValues(randomBytes);
+	return `0x${Buffer.from(randomBytes).toString('hex')}`;
+}

package/src/util/time.ts

@@ -0,0 +1,66 @@
+/**
+ * Get current timestamp in seconds
+ */
+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
+ */
+export function formatTimestamp(timestamp: number): string {
+	return new Date(timestamp * 1000).toISOString();
+}
+
+/**
+ * Parse ISO string to timestamp
+ */
+export function parseTimestamp(isoString: string): number {
+	return Math.floor(new Date(isoString).getTime() / 1000);
+}