@conquest-eth/tools 0.0.0 → 0.0.2

package/src/tools/missiv_get_user.ts

@@ -0,0 +1,68 @@
+import {z} from 'zod';
+import {createTool} from '../tool-handling/types.js';
+import type {ConquestEnv} from '../types.js';
+
+const schema = z.object({
+	address: z.string().describe('address'),
+});
+
+export const missiv_get_user = createTool<typeof schema, ConquestEnv>({
+	description: 'get User details from address',
+	schema,
+	execute: async (env, {address}) => {
+		try {
+			const body = JSON.stringify({
+				type: 'getUser',
+				domain: 'conquest.eth',
+				address: address.toLowerCase(),
+			});
+
+			const headers = {
+				'content-type': 'application/json',
+			};
+
+			const url = `https://api-conquest-2025-1.missiv.xyz/api/user/getCompleteUser`;
+
+			const resp = await fetch(url, {
+				method: 'POST',
+				body,
+				headers,
+			});
+			if (resp.status !== 200 && resp.status !== 201) {
+				const text = await resp.text();
+				console.error(`failed`, text);
+				throw new Error(text);
+			}
+			if (resp) {
+				const json = await resp.json();
+				return {
+					success: true,
+					result: json as {
+						completeUser: {
+							user: `0x${string}`;
+							domain: string;
+							domainUsername?: string;
+							domainDescription?: string;
+							publicKey: `0x${string}`;
+							signature: `0x${string}`;
+							added: number;
+							lastPresence: number;
+							address: `0x${string}`;
+							name?: string;
+							description?: string;
+							created: number;
+						};
+					},
+				};
+			} else {
+				console.error(`failed with no response`);
+				throw new Error(`no response`);
+			}
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : String(error),
+			};
+		}
+	},
+});

package/src/tools/missiv_register.ts

@@ -0,0 +1,122 @@
+import {z} from 'zod';
+import {createTool} from '../tool-handling/types.js';
+import type {ConquestEnv} from '../types.js';
+import {signAsync} from '@noble/secp256k1';
+import {keccak_256} from '@noble/hashes/sha3';
+import {computePublicKey} from '@ethersproject/signing-key';
+
+const chainNames: {[chainId: string]: string} = {
+	'1': 'mainnet',
+	'3': 'ropsten',
+	'4': 'rinkeby',
+	'5': 'goerli',
+	'42': 'kovan',
+	'100': 'Gnosis Chain',
+	'1337': 'localhost chain',
+	'31337': 'localhost chain',
+	'7001': 'ZetaChain Testnet',
+	'7000': 'ZetaChain',
+	'42220': 'celo',
+	'11142220': 'celo-sepolia',
+	'143': 'monad',
+	'10143': 'monad-testnet',
+};
+function nameForChainId(chainId: string): string {
+	const name = chainNames[chainId];
+	if (name) {
+		return name;
+	}
+	return `chain with id ${chainId}`;
+}
+
+const schema = z.object({
+	bio: z
+		.string()
+		.describe(
+			'Describe who you are very briefly and how you can be reached (moltbook account, etc..)',
+		),
+});
+
+function publicKeyAuthorizationMessage({
+	address,
+	publicKey,
+}: {
+	address: string;
+	publicKey: string;
+}): string {
+	return `I authorize the following Public Key to represent me:\n ${publicKey}\n\n  Others can use this key to write me messages`;
+}
+
+export const missiv_register = createTool<typeof schema, ConquestEnv>({
+	description:
+		'Register on Missiv so other can identify you. You can advertise your moltbook account here so other can send messages to you',
+	schema,
+	execute: async (env, {bio}) => {
+		if (!env.clients.walletClient || env.clients.walletClient.account === undefined) {
+			throw new Error(
+				'Wallet client is required for this operation. Please provide a PRIVATE_KEY environment variable.',
+			);
+		}
+
+		const chainId = await env.clients.publicClient.getChainId();
+		const chainName = nameForChainId(chainId.toString());
+		const message = `Only sign this message on "conquest.eth" or other trusted frontend.\nThis is for ${chainName}`;
+		const accountAddress = env.clients.walletClient.account.address.toLowerCase() as `0x${string}`;
+		const signatureToCreateDelegate = await env.clients.walletClient.signMessage({
+			account: accountAddress,
+			message,
+		});
+		const missivPrivateKey = signatureToCreateDelegate.slice(0, 66) as `0x${string}`;
+
+		const publicKey = computePublicKey(missivPrivateKey, true);
+		const signatureToAssociatePublicKeyToAccount = await env.clients.walletClient.signMessage({
+			account: accountAddress,
+			message: publicKeyAuthorizationMessage({address: accountAddress, publicKey}),
+		});
+		const action = {
+			type: 'register',
+			address: accountAddress,
+			domain: 'conquest.eth',
+			signature: signatureToAssociatePublicKeyToAccount,
+			domainDescription: bio,
+		};
+
+		try {
+			const body = JSON.stringify(action);
+			const requestSignature = await signAsync(keccak_256(body), missivPrivateKey.slice(2)); // Sync methods below
+
+			const headers = {
+				'content-type': 'application/json',
+				SIGNATURE: `${requestSignature.toCompactHex()}:${requestSignature.recovery}`,
+			};
+
+			const url = `https://api-conquest-2025-1.missiv.xyz/api/user/register`;
+
+			const resp = await fetch(url, {
+				method: 'POST',
+				body,
+				headers,
+			});
+			if (resp.status !== 200 && resp.status !== 201) {
+				const text = await resp.text();
+				console.error(`failed`, text);
+				throw new Error(text);
+			}
+			if (resp) {
+				const json = await resp.json();
+				return {
+					success: true,
+					result: json as any, // TODO,
+				};
+			} else {
+				console.error(`failed with no response`);
+				throw new Error(`no response`);
+			}
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : String(error),
+			};
+		}
+	},
+});

package/src/tools/resolve_fleet.ts

@@ -1,12 +1,15 @@
 import {z} from 'zod';
-import {createTool} from '../types.js';
+import {createTool} from '../tool-handling/types.js';
+import type {ConquestEnv} from '../types.js';
 
-export const resolve_fleet = createTool({
+const schema = z.object({
+	fleetId: z.string().describe('Fleet ID to resolve'),
+});
+
+export const resolve_fleet = createTool<typeof schema, ConquestEnv>({
 	description:
 		'Resolve a previously sent fleet. This must be called after the fleet arrival time + resolve window to reveal the destination and secret.',
-	schema: z.object({
-		fleetId: z.string().describe('Fleet ID to resolve'),
-	}),
+	schema,
 	execute: async (env, {fleetId}) => {
 		try {
 			const result = await env.fleetManager.resolve(fleetId);

package/src/tools/send_fleet.ts

@@ -1,26 +1,29 @@
 import {z} from 'zod';
-import {createTool} from '../types.js';
+import {createTool} from '../tool-handling/types.js';
 import {zeroAddress} from 'viem';
+import type {ConquestEnv} from '../types.js';
 
-export const send_fleet = createTool({
+const schema = z.object({
+	from: z.object({x: z.number(), y: z.number()}).describe('Source planet coordinates {x, y}'),
+	to: z.object({x: z.number(), y: z.number()}).describe('Destination planet coordinates {x, y}'),
+	quantity: z.number().describe('Number of spaceships to send'),
+	arrivalTimeWanted: z
+		.number()
+		.optional()
+		.describe(
+			'Desired arrival time (timestamp in seconds). If not specified, will be calculated based on distance.',
+		),
+	gift: z
+		.boolean()
+		.optional()
+		.describe('Whether the fleet is a gift (sent without requiring arrival)'),
+	specific: z.string().optional().describe('Additional specific data for the fleet'),
+});
+
+export const send_fleet = createTool<typeof schema, ConquestEnv>({
 	description:
 		'Send a fleet from one planet to another in the Conquest game. The fleet will travel through space and can be resolved after arrival.',
-	schema: z.object({
-		from: z.object({x: z.number(), y: z.number()}).describe('Source planet coordinates {x, y}'),
-		to: z.object({x: z.number(), y: z.number()}).describe('Destination planet coordinates {x, y}'),
-		quantity: z.number().describe('Number of spaceships to send'),
-		arrivalTimeWanted: z
-			.number()
-			.optional()
-			.describe(
-				'Desired arrival time (timestamp in seconds). If not specified, will be calculated based on distance.',
-			),
-		gift: z
-			.boolean()
-			.optional()
-			.describe('Whether the fleet is a gift (sent without requiring arrival)'),
-		specific: z.string().optional().describe('Additional specific data for the fleet'),
-	}),
+	schema,
 	execute: async (env, {from, to, quantity, arrivalTimeWanted, gift, specific}) => {
 		try {
 			// Convert coordinates to planet IDs

package/src/tools/simulate.ts

@@ -0,0 +1,141 @@
+import {z} from 'zod';
+import {createTool} from '../tool-handling/types.js';
+import type {ConquestEnv} from '../types.js';
+import type {PlanetState} from 'conquest-eth-v0-contracts';
+
+const coordinatesSchema = z.object({
+	x: z.number().describe('X coordinate'),
+	y: z.number().describe('Y coordinate'),
+});
+
+const schema = z.object({
+	from: coordinatesSchema.describe('Source planet coordinates {x, y}'),
+	to: coordinatesSchema.describe('Target planet coordinates {x, y}'),
+	quantity: z.number().positive().describe('Number of spaceships to send'),
+});
+
+export const simulate = createTool<typeof schema, ConquestEnv>({
+	description:
+		'Simulate the outcome of a fleet attack. Returns min/max outcomes including whether capture is successful, number of spaceships left, time until attack fails, and combat losses.',
+	schema,
+	execute: async (env, {from, to, quantity}) => {
+		try {
+			// Get planet info for source
+			const fromPlanetId = env.planetManager.getPlanetIdByCoordinates(from.x, from.y);
+			if (!fromPlanetId) {
+				return {
+					success: false,
+					error: `No planet found at source coordinates (${from.x}, ${from.y})`,
+				};
+			}
+			const fromPlanet = env.planetManager.getPlanetInfo(fromPlanetId);
+			if (!fromPlanet) {
+				return {
+					success: false,
+					error: `Could not get planet info for source planet at (${from.x}, ${from.y})`,
+				};
+			}
+
+			// Get planet info for target
+			const toPlanetId = env.planetManager.getPlanetIdByCoordinates(to.x, to.y);
+			if (!toPlanetId) {
+				return {
+					success: false,
+					error: `No planet found at target coordinates (${to.x}, ${to.y})`,
+				};
+			}
+			const toPlanet = env.planetManager.getPlanetInfo(toPlanetId);
+			if (!toPlanet) {
+				return {
+					success: false,
+					error: `Could not get planet info for target planet at (${to.x}, ${to.y})`,
+				};
+			}
+
+			// Fetch current state of target planet
+			const planetsWithState = await env.planetManager.getPlanetsAround(to.x, to.y, 0);
+			if (planetsWithState.length === 0) {
+				return {
+					success: false,
+					error: `Could not fetch state for target planet at (${to.x}, ${to.y})`,
+				};
+			}
+
+			const toPlanetState = planetsWithState[0].state as PlanetState;
+
+			// Calculate travel time
+			const travelTime = env.spaceInfo.timeToArrive(fromPlanet, toPlanet);
+
+			// Calculate distance
+			const distance = env.spaceInfo.distance(fromPlanet, toPlanet);
+
+			// Use outcome() to simulate the attack
+			// Note: We pass undefined for player-related params since we're doing a simple simulation
+			const outcome = env.spaceInfo.outcome(
+				fromPlanet,
+				toPlanet,
+				toPlanetState,
+				quantity,
+				travelTime,
+				undefined, // senderPlayer
+				undefined, // fromPlayer
+				undefined, // toPlayer
+				false, // gift
+				undefined, // specific
+			);
+
+			return {
+				success: true,
+				result: {
+					from: {x: from.x, y: from.y},
+					to: {x: to.x, y: to.y},
+					quantity,
+					travelTime,
+					distance,
+					outcome: {
+						min: {
+							captured: outcome.min.captured,
+							numSpaceshipsLeft: outcome.min.numSpaceshipsLeft,
+						},
+						max: {
+							captured: outcome.max.captured,
+							numSpaceshipsLeft: outcome.max.numSpaceshipsLeft,
+						},
+						timeUntilFails: outcome.timeUntilFails,
+						nativeResist: outcome.nativeResist,
+						gift: outcome.gift,
+						allies: outcome.allies,
+						combat: outcome.combat
+							? {
+									defenderLoss: outcome.combat.defenderLoss,
+									attackerLoss: outcome.combat.attackerLoss,
+								}
+							: undefined,
+						tax: outcome.tax
+							? {
+									taxRate: outcome.tax.taxRate,
+									loss: outcome.tax.loss,
+								}
+							: undefined,
+					},
+					targetPlanet: {
+						owner: toPlanetState.owner ?? null,
+						numSpaceships: toPlanetState.numSpaceships,
+						natives: toPlanetState.natives,
+						active: toPlanetState.active,
+						exiting: toPlanetState.exiting,
+					},
+					sourcePlanet: {
+						attack: fromPlanet.stats.attack,
+						speed: fromPlanet.stats.speed,
+					},
+				},
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : String(error),
+			};
+		}
+	},
+});

package/src/tools/simulate_multiple.ts

@@ -0,0 +1,197 @@
+import {z} from 'zod';
+import {createTool} from '../tool-handling/types.js';
+import type {ConquestEnv} from '../types.js';
+import type {PlanetState, FleetInput} from 'conquest-eth-v0-contracts';
+
+const coordinatesSchema = z.object({
+	x: z.number().describe('X coordinate'),
+	y: z.number().describe('Y coordinate'),
+});
+
+// Schema for multiple fleets simulation
+const schema = z.object({
+	fleets: z
+		.array(
+			z.object({
+				from: coordinatesSchema.describe('Source planet coordinates {x, y}'),
+				quantity: z.number().positive().describe('Number of spaceships to send'),
+			}),
+		)
+		.min(1)
+		.describe('Array of fleets to send to the target'),
+	to: coordinatesSchema.describe('Target planet coordinates {x, y}'),
+	arrivalTime: z
+		.number()
+		.optional()
+		.describe(
+			'Specific arrival time in seconds. If not provided, uses the maximum travel time from all fleets.',
+		),
+});
+
+export const simulate_multiple = createTool<typeof schema, ConquestEnv>({
+	description:
+		'Simulate the outcome of multiple fleets attacking the same target planet. Fleets are processed sequentially, with the planet state updated after each combat. Returns individual fleet outcomes and the final combined result.',
+	schema,
+	execute: async (env, {fleets, to, arrivalTime}) => {
+		try {
+			// Get planet info for target
+			const toPlanetId = env.planetManager.getPlanetIdByCoordinates(to.x, to.y);
+			if (!toPlanetId) {
+				return {
+					success: false,
+					error: `No planet found at target coordinates (${to.x}, ${to.y})`,
+				};
+			}
+			const toPlanet = env.planetManager.getPlanetInfo(toPlanetId);
+			if (!toPlanet) {
+				return {
+					success: false,
+					error: `Could not get planet info for target planet at (${to.x}, ${to.y})`,
+				};
+			}
+
+			// Fetch current state of target planet
+			const planetsWithState = await env.planetManager.getPlanetsAround(to.x, to.y, 0);
+			if (planetsWithState.length === 0) {
+				return {
+					success: false,
+					error: `Could not fetch state for target planet at (${to.x}, ${to.y})`,
+				};
+			}
+
+			const toPlanetState = planetsWithState[0].state as PlanetState;
+
+			// Build fleet inputs with planet info
+			const fleetInputs: FleetInput[] = [];
+			const fleetDetails: Array<{
+				from: {x: number; y: number};
+				quantity: number;
+				travelTime: number;
+				distance: number;
+				attack: number;
+				speed: number;
+			}> = [];
+
+			for (const fleet of fleets) {
+				// Get planet info for source
+				const fromPlanetId = env.planetManager.getPlanetIdByCoordinates(fleet.from.x, fleet.from.y);
+				if (!fromPlanetId) {
+					return {
+						success: false,
+						error: `No planet found at source coordinates (${fleet.from.x}, ${fleet.from.y})`,
+					};
+				}
+				const fromPlanet = env.planetManager.getPlanetInfo(fromPlanetId);
+				if (!fromPlanet) {
+					return {
+						success: false,
+						error: `Could not get planet info for source planet at (${fleet.from.x}, ${fleet.from.y})`,
+					};
+				}
+
+				const travelTime = env.spaceInfo.timeToArrive(fromPlanet, toPlanet);
+				const distance = env.spaceInfo.distance(fromPlanet, toPlanet);
+
+				fleetInputs.push({
+					fromPlanet,
+					fleetAmount: fleet.quantity,
+					// We pass undefined for player-related params since we're doing a simple simulation
+					senderPlayer: undefined,
+					fromPlayer: undefined,
+					gift: false,
+					specific: undefined,
+					extra: undefined,
+				});
+
+				fleetDetails.push({
+					from: {x: fleet.from.x, y: fleet.from.y},
+					quantity: fleet.quantity,
+					travelTime,
+					distance,
+					attack: fromPlanet.stats.attack,
+					speed: fromPlanet.stats.speed,
+				});
+			}
+
+			// Use outcomeMultipleFleets() to simulate the combined attack
+			const multipleOutcome = env.spaceInfo.outcomeMultipleFleets(
+				fleetInputs,
+				toPlanet,
+				toPlanetState,
+				arrivalTime,
+				undefined, // toPlayer
+			);
+
+			// Format the fleet outcomes
+			const formattedFleetOutcomes = multipleOutcome.fleets.map((fleetOutcome, index) => ({
+				from: fleetDetails[index].from,
+				quantity: fleetDetails[index].quantity,
+				travelTime: fleetDetails[index].travelTime,
+				distance: fleetDetails[index].distance,
+				sourcePlanet: {
+					attack: fleetDetails[index].attack,
+					speed: fleetDetails[index].speed,
+				},
+				outcome: {
+					min: {
+						captured: fleetOutcome.outcome.min.captured,
+						numSpaceshipsLeft: fleetOutcome.outcome.min.numSpaceshipsLeft,
+					},
+					max: {
+						captured: fleetOutcome.outcome.max.captured,
+						numSpaceshipsLeft: fleetOutcome.outcome.max.numSpaceshipsLeft,
+					},
+					timeUntilFails: fleetOutcome.outcome.timeUntilFails,
+					nativeResist: fleetOutcome.outcome.nativeResist,
+					gift: fleetOutcome.outcome.gift,
+					allies: fleetOutcome.outcome.allies,
+					combat: fleetOutcome.outcome.combat
+						? {
+								defenderLoss: fleetOutcome.outcome.combat.defenderLoss,
+								attackerLoss: fleetOutcome.outcome.combat.attackerLoss,
+							}
+						: undefined,
+					tax: fleetOutcome.outcome.tax
+						? {
+								taxRate: fleetOutcome.outcome.tax.taxRate,
+								loss: fleetOutcome.outcome.tax.loss,
+							}
+						: undefined,
+				},
+			}));
+
+			return {
+				success: true,
+				result: {
+					to: {x: to.x, y: to.y},
+					arrivalTime: multipleOutcome.arrivalTime,
+					fleets: formattedFleetOutcomes,
+					finalOutcome: {
+						min: {
+							captured: multipleOutcome.finalOutcome.min.captured,
+							numSpaceshipsLeft: multipleOutcome.finalOutcome.min.numSpaceshipsLeft,
+							owner: multipleOutcome.finalOutcome.min.owner ?? null,
+						},
+						max: {
+							captured: multipleOutcome.finalOutcome.max.captured,
+							numSpaceshipsLeft: multipleOutcome.finalOutcome.max.numSpaceshipsLeft,
+							owner: multipleOutcome.finalOutcome.max.owner ?? null,
+						},
+					},
+					targetPlanet: {
+						owner: toPlanetState.owner ?? null,
+						numSpaceships: toPlanetState.numSpaceships,
+						natives: toPlanetState.natives,
+						active: toPlanetState.active,
+						exiting: toPlanetState.exiting,
+					},
+				},
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : String(error),
+			};
+		}
+	},
+});

package/src/tools/verify_exit_status.ts

@@ -1,19 +1,23 @@
 import {z} from 'zod';
-import {createTool} from '../types.js';
+import {createTool} from '../tool-handling/types.js';
+import type {ConquestEnv} from '../types.js';
 
-export const verify_exit_status = createTool({
+const schema = z.object({
+	x: z.number().describe('X coordinate of the planet'),
+	y: z.number().describe('Y coordinate of the planet'),
+});
+
+export const verify_exit_status = createTool<typeof schema, ConquestEnv>({
 	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}) => {
+	schema,
+	execute: async (env, {x, y}) => {
 		try {
-			const result = await env.planetManager.verifyExitStatus(
-				typeof planetId === 'string' ? BigInt(planetId) : BigInt(planetId),
-			);
+			const planetId = env.planetManager.getPlanetIdByCoordinates(x, y);
+			if (planetId === undefined) {
+				throw new Error(`No planet found at coordinates (${x}, ${y})`);
+			}
+			const result = await env.planetManager.verifyExitStatus(planetId);
 
 			// Calculate status based on exit state
 			const currentTime = Math.floor(Date.now() / 1000);