@ecadlabs/tezosx-mcp 1.0.3 → 1.0.4

package/dist/api.js

@@ -50,6 +50,7 @@ export function createApiRouter(liveConfig) {
             configured: liveConfig.configured,
             spenderAddress: liveConfig.spendingAddress || undefined,
             contractAddress: liveConfig.spendingContract || undefined,
+            network: liveConfig.networkName,
         });
     });
     // Generate keypair server-side, persist as *pending* key, return only public info.

package/dist/live-config.d.ts

@@ -4,6 +4,7 @@ export interface LiveConfig {
     spendingContract: string;
     spendingAddress: string;
     tzktApi: string;
+    networkName: NetworkName;
     configured: boolean;
 }
 /**

package/dist/live-config.js

@@ -34,6 +34,7 @@ export function createLiveConfig(networkName) {
         spendingContract: '',
         spendingAddress: '',
         tzktApi: network.tzktApi,
+        networkName,
         configured: false,
     };
 }
@@ -46,6 +47,7 @@ export async function configureLiveConfig(config, privateKey, spendingContract,
         const network = NETWORKS[networkName];
         config.Tezos = new TezosToolkit(network.rpcUrl);
         config.tzktApi = network.tzktApi;
+        config.networkName = networkName;
     }
     const signer = await InMemorySigner.fromSecretKey(privateKey);
     config.Tezos.setSignerProvider(signer);
@@ -62,6 +64,7 @@ export function resetLiveConfig(config, networkName) {
     config.Tezos = new TezosToolkit(rpcUrl);
     if (networkName) {
         config.tzktApi = NETWORKS[networkName].tzktApi;
+        config.networkName = networkName;
     }
     config.spendingContract = '';
     config.spendingAddress = '';

package/dist/tools/index.d.ts

@@ -88,6 +88,27 @@ export declare const createTools: (liveConfig: LiveConfig, http: boolean) => ({
             text: string;
         }[];
     }>;
+} | {
+    name: string;
+    config: {
+        title: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            destination: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+    };
+    handler: (params: any) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
 } | {
     name: string;
     config: {

package/dist/tools/index.js

@@ -6,6 +6,7 @@ import { createGetLimitsTool } from "./get_limits.js";
 import { createGetOperationHistoryTool } from "./get_operation_history.js";
 import { createParseX402RequirementsTool } from "./parse_x402_requirements.js";
 import { createRevealAccountTool } from "./reveal_account.js";
+import { createRecoverSpenderFundsTool } from "./recover_spender_funds.js";
 import { createSendXtzTool } from "./send_xtz.js";
 import { createGetDashboardTool } from "./get_dashboard.js";
 const getNotConfiguredMessage = () => `Wallet not configured.
@@ -39,6 +40,7 @@ export const createTools = (liveConfig, http) => {
         createGetLimitsTool(liveConfig),
         createGetOperationHistoryTool(liveConfig),
         createParseX402RequirementsTool(),
+        createRecoverSpenderFundsTool(liveConfig),
         createRevealAccountTool(liveConfig),
         createSendXtzTool(liveConfig),
     ];

package/dist/tools/recover_spender_funds.d.ts

@@ -0,0 +1,24 @@
+import z from "zod";
+import type { LiveConfig } from "../live-config.js";
+export declare const createRecoverSpenderFundsTool: (config: LiveConfig) => {
+    name: string;
+    config: {
+        title: string;
+        description: string;
+        inputSchema: z.ZodObject<{
+            destination: z.ZodOptional<z.ZodString>;
+        }, z.z.core.$strip>;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+    };
+    handler: (params: any) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};

package/dist/tools/recover_spender_funds.js

@@ -0,0 +1,113 @@
+import z from "zod";
+import { ensureRevealed } from "./reveal_account.js";
+const CONFIRMATIONS_TO_WAIT = 3;
+const inputSchema = z.object({
+    destination: z.string().optional().describe("Address to send recovered funds to. Defaults to the contract owner's address."),
+});
+export const createRecoverSpenderFundsTool = (config) => ({
+    name: "tezos_recover_spender_funds",
+    config: {
+        title: "Recover Spender Gas Funds",
+        description: "Transfers the spender address's XTZ balance (used for gas fees) to the contract owner or a specified address. " +
+            "Useful for recovering funds when decommissioning a spender or rebalancing. " +
+            "Always fetches the live on-chain balance — call this tool every time the user asks, even if a previous call returned zero.",
+        inputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    },
+    handler: async (params) => {
+        params = params;
+        const { Tezos, spendingContract, spendingAddress, tzktApi } = config;
+        // Resolve destination: explicit param > contract owner > spending contract
+        let destination = params.destination;
+        if (!destination) {
+            if (spendingContract) {
+                const contract = await Tezos.contract.at(spendingContract);
+                const storage = await contract.storage();
+                destination = storage.owner;
+            }
+        }
+        if (!destination) {
+            throw new Error("No destination provided and no spending contract configured.");
+        }
+        const balance = await Tezos.tz.getBalance(spendingAddress);
+        const balanceMutez = balance.toNumber();
+        if (balanceMutez === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Spender address (${spendingAddress}) has zero balance. Nothing to recover.`,
+                    }],
+            };
+        }
+        await ensureRevealed(Tezos);
+        // Drain account pattern (Taquito docs):
+        // For KT1 destinations, call the default entrypoint explicitly.
+        // For implicit accounts, use a simple transfer.
+        const isContract = destination.startsWith("KT1");
+        if (isContract) {
+            const contract = await Tezos.contract.at(destination);
+            const depositCall = contract.methodsObject.default_(null);
+            const estimate = await Tezos.estimate.contractCall(depositCall);
+            const maxAmount = balanceMutez - estimate.suggestedFeeMutez;
+            if (maxAmount <= 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Spender balance (${balanceMutez} mutez) is too low to cover transfer fees (${estimate.suggestedFeeMutez} mutez). Nothing to recover.`,
+                        }],
+                };
+            }
+            const operation = await contract.methodsObject.default_(null).send({
+                amount: maxAmount,
+                mutez: true,
+                fee: estimate.suggestedFeeMutez,
+                gasLimit: estimate.gasLimit,
+                storageLimit: 0,
+            });
+            await operation.confirmation(CONFIRMATIONS_TO_WAIT);
+            const tzktBase = tzktApi.replace("api.", "");
+            return {
+                content: [{
+                        type: "text",
+                        text: `Recovered ${(maxAmount / 1_000_000).toFixed(6)} XTZ from spender (${spendingAddress}) to ${destination}.\n${tzktBase}/${operation.hash}`,
+                    }],
+            };
+        }
+        // Implicit account (tz1/tz2/tz3)
+        const estimate = await Tezos.estimate.transfer({
+            to: destination,
+            amount: balanceMutez,
+            mutez: true,
+        });
+        const maxAmount = balanceMutez - estimate.suggestedFeeMutez;
+        if (maxAmount <= 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Spender balance (${balanceMutez} mutez) is too low to cover transfer fees (${estimate.suggestedFeeMutez} mutez). Nothing to recover.`,
+                    }],
+            };
+        }
+        const operation = await Tezos.contract.transfer({
+            to: destination,
+            amount: maxAmount,
+            mutez: true,
+            fee: estimate.suggestedFeeMutez,
+            gasLimit: estimate.gasLimit,
+            storageLimit: 0,
+        });
+        await operation.confirmation(CONFIRMATIONS_TO_WAIT);
+        const tzktBase = tzktApi.replace("api.", "");
+        return {
+            content: [{
+                    type: "text",
+                    text: `Recovered ${(maxAmount / 1_000_000).toFixed(6)} XTZ from spender (${spendingAddress}) to ${destination}.\n${tzktBase}/${operation.hash}`,
+                }],
+        };
+    },
+});

package/dist/webserver.js

@@ -14,28 +14,38 @@ export const startWebServer = (port, apiRouter) => {
     const distPath = join(__dirname, "../frontend/dist");
     app.use(sirv(distPath, { single: true }));
     let retries = 0;
-    const maxRetries = 3;
+    const maxRetries = 5;
+    const retryDelay = 1000;
+    let activeServer = null;
     const tryListen = () => {
         const server = app.listen(port);
         server.on("error", (err) => {
             if (err.code === "EADDRINUSE" && retries < maxRetries) {
                 retries++;
                 console.error(`[tezosx-mcp] Port ${port} in use, retrying (${retries}/${maxRetries})...`);
-                setTimeout(tryListen, 500);
+                setTimeout(tryListen, retryDelay);
             }
             else if (err.code === "EADDRINUSE") {
-                console.error(`[tezosx-mcp] Port ${port} in use, frontend dashboard unavailable`);
+                console.error(`[tezosx-mcp] Port ${port} still in use after ${maxRetries} retries, frontend dashboard unavailable`);
             }
             else {
                 console.error(`[tezosx-mcp] Web server error:`, err.message);
             }
         });
         server.on("listening", () => {
-            const shutdown = () => server.close();
-            process.on("SIGTERM", shutdown);
-            process.on("SIGINT", shutdown);
-            process.on("exit", shutdown);
+            activeServer = server;
+            console.error(`[tezosx-mcp] Dashboard running on http://localhost:${port}`);
         });
     };
+    // Ensure the server is fully closed before the process exits
+    const shutdown = () => {
+        if (activeServer) {
+            activeServer.closeAllConnections();
+            activeServer.close();
+            activeServer = null;
+        }
+    };
+    process.on("SIGTERM", () => { shutdown(); process.exit(0); });
+    process.on("SIGINT", () => { shutdown(); process.exit(0); });
     tryListen();
 };