@ecadlabs/tezosx-mcp 1.0.0 → 1.0.1

package/README.md

@@ -2,44 +2,10 @@
 
 A Model Context Protocol server for Tezos with x402 payment support.
 
-> **Warning:** This MCP is in alpha. Most things should work, but please be prepared for troubleshooting. Please report any problems on our [issues page](https://github.com/ecadlabs/TezosX-mcp/issues).
+> **Warning:** This MCP is in beta. Most things should work, but please be prepared for troubleshooting. Please report any problems on our [issues page](https://github.com/ecadlabs/TezosX-mcp/issues).
 >
 > As always, verify the output of your LLM before approving any transactions. Set reasonable limits. Trust but verify.
 
-## Quick Deploy
-
-[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/tezosx-mcp?referralCode=SVg46H&utm_medium=integration&utm_source=template&utm_campaign=generic)
-<details>
-<summary>Railway deployment steps</summary>
-
-1. Deploy the template (set `TEZOS_NETWORK` to `shadownet` before clicking deploy if desired)
-2. Click the deployed item and go to "Settings"
-3. Scroll down to "Public Networking"
-4. Your domain will be something like `tezosx-mcp-production-a12b.up.railway.app`
-5. Navigate to your domain to open the frontend config, and set up your spending key and contract address
-6. Back on Railway, navigate to the "Variables" tab and set `SPENDING_PRIVATE_KEY` and `SPENDING_CONTRACT` to the values you received
-7. Optional: Enable the 'serverless' setting to reduce resource usage
-8. Restart the deployment
-9. Set up your AI Platform to use `[your domain]/mcp` as the URL
-
-</details>
-
-[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/ecadlabs/TezosX-mcp)
-<details>
-<summary>Render deployment steps</summary>
-
-1. Click the button above to deploy the template
-2. Once deployed, under "Sync" click "View details"
-3. Click the hyperlink to "tezosx-mcp"
-4. Navigate to your onrender.com custom URL and set up your spending key and contract address
-5. Back on Render, navigate to the "Environment" tab and set `SPENDING_PRIVATE_KEY` and `SPENDING_CONTRACT` environment variables
-6. Click "Manual deploy" at the top right and select "Restart service"
-7. Set up your AI Platform to use `[your domain]/mcp` as the URL
-
-Note: Render spins down free plan services during inactivity. The next request can take up to a minute while the instance spins back up. Upgrade to a paid plan to avoid this.
-
-</details>
-
 ## Components
 
 | Component | Description | Deployment |
@@ -55,37 +21,95 @@ Note: Render spins down free plan services during inactivity. The next request c
 
 ### Installation
 
-```bash
-npm install @ecadlabs/tezosx-mcp
-```
+<details>
+<summary><strong>Local (npx)</strong> — fastest</summary>
 
-Or run directly:
+The quickest path. Run the MCP locally alongside Claude Desktop — a built-in dashboard handles all configuration automatically.
 
-```bash
-npx tezosx-mcp
-```
+1. **Add to your Claude Desktop config** (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
 
-### Claude Desktop Configuration
+   ```json
+   {
+     "mcpServers": {
+       "tezos": {
+         "command": "npx",
+         "args": ["-y", "@ecadlabs/tezosx-mcp"]
+       }
+     }
+   }
+   ```
 
-Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+2. **Restart Claude Desktop.** Open your dashboard at `localhost:13205`, or ask Claude for the link.
 
-```json
-{
-  "mcpServers": {
-    "tezos": {
-      "command": "npx",
-      "args": ["-y", "tezosx-mcp"],
-      "env": {
-        "TEZOS_NETWORK": "mainnet",
-        "SPENDING_CONTRACT": "KT1...",
-        "SPENDING_PRIVATE_KEY": "edsk..."
-      }
-    }
-  }
-}
-```
+3. **Deploy your spending contract.** Connect your wallet, deploy the spending contract, and set your spending limits. Everything else is handled for you.
+
+</details>
 
-Or run from source:
+<details>
+<summary><strong>Self-Hosted</strong> — always on</summary>
+
+Deploy on Railway or Render for a remote MCP that's still entirely under your control and accessible from multiple clients. Requires some manual configuration.
+
+1. **One-click deploy:**
+
+   [![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/tezosx-mcp?referralCode=SVg46H&utm_medium=integration&utm_source=template&utm_campaign=generic)
+
+   [![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/ecadlabs/TezosX-mcp)
+
+2. **Open dashboard & deploy contract.** Visit your deployment URL, connect your wallet, deploy the spending contract, and set your spending limits. Copy the provided spending key and contract address.
+
+3. **Set environment variables on your server:**
+
+   ```
+   SPENDING_PRIVATE_KEY=edsk...
+   SPENDING_CONTRACT=KT1...
+   ```
+
+4. **Point Claude at your MCP:**
+
+   ```json
+   {
+     "mcpServers": {
+       "tezos": {
+         "type": "streamable-http",
+         "url": "https://your-mcp-url.example.com"
+       }
+     }
+   }
+   ```
+
+</details>
+
+<details>
+<summary><strong>Hosted Dashboard</strong> — flexible</summary>
+
+Use our hosted dashboard to deploy your contract and generate keys, but run the MCP server locally. Keys never leave your browser.
+
+1. **Open the [hosted dashboard](https://7687adbb.tezosx-dashboard.pages.dev/).**
+
+2. **Deploy contract & copy credentials.** Connect your wallet, deploy the spending contract, and set your spending limits. Copy the provided spending key and contract address.
+
+3. **Add your copied variables to your Claude config:**
+
+   ```json
+   {
+     "mcpServers": {
+       "tezos": {
+         "command": "npx",
+         "args": ["-y", "@ecadlabs/tezosx-mcp"],
+         "env": {
+           "CONTRACT_ADDRESS": "KT1...",
+           "SPENDING_PRIVATE_KEY": "edsk...",
+         }
+       }
+     }
+   }
+   ```
+
+</details>
+
+<details>
+<summary><strong>From source</strong></summary>
 
 1. Clone the TezosX-mcp repository
 2. In the `/TezosX-mcp/mcp` folder run `npm i && npm run build`
@@ -95,17 +119,14 @@ Or run from source:
   "mcpServers": {
     "tezosx": {
       "command": "node",
-      "args": ["/path/to/TezosX-mcp/mcp/dist/index.js"],
-      "env": {
-        "TEZOS_NETWORK": "mainnet",
-        "SPENDING_CONTRACT": "KT1...",
-        "SPENDING_PRIVATE_KEY": "edsk..."
-      }
+      "args": ["/path/to/TezosX-mcp/mcp/dist/index.js"]
     }
   }
 }
 ```
 
+</details>
+
 ### Environment Variables
 
 | Variable | Required | Description |

package/dist/api.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import { LiveConfig } from './live-config.js';
+export declare function createApiRouter(liveConfig: LiveConfig): Router;

package/dist/api.js

@@ -0,0 +1,155 @@
+import { Router } from 'express';
+import { InMemorySigner } from '@taquito/signer';
+import { b58cencode, prefix } from '@taquito/utils';
+import { randomBytes } from 'crypto';
+import { configureLiveConfig, resetLiveConfig, NETWORKS } from './live-config.js';
+import { savePendingKey, loadPendingKey, activatePendingKey, saveContract, clearConfig, loadConfig } from './config-store.js';
+const log = (msg) => console.error(`[tezosx-mcp] ${msg}`);
+const LOCALHOST_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+/** Reject requests that aren't from localhost (prevents DNS rebinding and CSRF). */
+function localhostGuard(req, res, next) {
+    const host = (req.hostname || '').toLowerCase();
+    if (!LOCALHOST_HOSTS.has(host)) {
+        log(`Blocked request from non-localhost host: ${host}`);
+        res.status(403).json({ error: 'Forbidden: API is localhost-only' });
+        return;
+    }
+    // CSRF check: if an Origin header is present, it must also be localhost
+    const origin = req.headers.origin;
+    if (origin) {
+        try {
+            const originHost = new URL(origin).hostname.toLowerCase();
+            if (!LOCALHOST_HOSTS.has(originHost)) {
+                log(`Blocked request with non-localhost origin: ${origin}`);
+                res.status(403).json({ error: 'Forbidden: cross-origin requests not allowed' });
+                return;
+            }
+        }
+        catch {
+            res.status(403).json({ error: 'Forbidden: malformed Origin header' });
+            return;
+        }
+    }
+    next();
+}
+async function generateKeypair() {
+    const seed = randomBytes(32);
+    const secretKey = b58cencode(seed, prefix.edsk2);
+    const signer = await InMemorySigner.fromSecretKey(secretKey);
+    const publicKey = await signer.publicKey();
+    const address = await signer.publicKeyHash();
+    return { address, publicKey, secretKey };
+}
+export function createApiRouter(liveConfig) {
+    const router = Router();
+    // All API routes are localhost-only
+    router.use('/api', localhostGuard);
+    // Check config status (never exposes private key or filesystem paths)
+    router.get('/api/status', (_req, res) => {
+        res.json({
+            configured: liveConfig.configured,
+            spenderAddress: liveConfig.spendingAddress || undefined,
+            contractAddress: liveConfig.spendingContract || undefined,
+        });
+    });
+    // Generate keypair server-side, persist as *pending* key, return only public info.
+    // Does NOT hot-reload the signer — the old key stays active until /api/activate-key
+    // or /api/save-contract promotes the pending key.
+    // Idempotent: if a pending key already exists, returns its public info instead of
+    // generating a new one (prevents accidental overwrites if the on-chain tx fails).
+    router.post('/api/generate-keypair', async (_req, res) => {
+        try {
+            // Return existing pending key if one hasn't been activated yet
+            const existingPending = loadPendingKey();
+            if (existingPending) {
+                const signer = await InMemorySigner.fromSecretKey(existingPending);
+                const publicKey = await signer.publicKey();
+                const address = await signer.publicKeyHash();
+                log(`Returning existing pending keypair: ${address}`);
+                res.json({ address, publicKey });
+                return;
+            }
+            const keypair = await generateKeypair();
+            // Save to pending slot (active key stays untouched)
+            savePendingKey(keypair.secretKey);
+            log(`Generated and saved new pending keypair: ${keypair.address}`);
+            // Return only public info — private key stays on server
+            res.json({
+                address: keypair.address,
+                publicKey: keypair.publicKey,
+            });
+        }
+        catch (error) {
+            log(`Failed to generate keypair: ${error instanceof Error ? error.message : error}`);
+            res.status(500).json({ error: 'Failed to generate keypair' });
+        }
+    });
+    // Activate the pending key — call this after on-chain setSpender confirms.
+    // Promotes pendingPrivateKey → spendingPrivateKey and hot-reloads the signer.
+    router.post('/api/activate-key', async (_req, res) => {
+        try {
+            const pendingKey = loadPendingKey();
+            if (!pendingKey) {
+                res.status(400).json({ error: 'No pending key found. Generate a keypair first.' });
+                return;
+            }
+            if (!liveConfig.spendingContract) {
+                res.status(400).json({ error: 'No contract configured. Save a contract first.' });
+                return;
+            }
+            // Promote pending → active in the store
+            activatePendingKey();
+            const spenderAddress = await configureLiveConfig(liveConfig, pendingKey, liveConfig.spendingContract);
+            log(`LiveConfig signer activated: ${spenderAddress}`);
+            res.json({ success: true, spenderAddress });
+        }
+        catch (error) {
+            log(`Failed to activate key: ${error instanceof Error ? error.message : error}`);
+            res.status(500).json({ error: 'Failed to activate key' });
+        }
+    });
+    // Save contract address + network, complete configuration
+    router.post('/api/save-contract', async (req, res) => {
+        try {
+            const { contractAddress, network } = req.body;
+            if (!contractAddress || !contractAddress.startsWith('KT1')) {
+                res.status(400).json({ error: 'Invalid contract address. Must start with KT1.' });
+                return;
+            }
+            const networkName = (network || 'mainnet');
+            if (!(networkName in NETWORKS)) {
+                res.status(400).json({ error: `Invalid network: ${networkName}` });
+                return;
+            }
+            // Save to persistent store
+            saveContract(contractAddress, networkName);
+            log(`Saved contract address: ${contractAddress} on ${networkName}`);
+            // Promote pending key → active (initial deploy flow)
+            const pendingKey = loadPendingKey();
+            const stored = loadConfig();
+            const privateKey = pendingKey || stored.spendingPrivateKey;
+            if (!privateKey) {
+                res.status(400).json({ error: 'No spending key found. Generate a keypair first.' });
+                return;
+            }
+            if (pendingKey) {
+                activatePendingKey();
+            }
+            const spenderAddress = await configureLiveConfig(liveConfig, privateKey, contractAddress, networkName);
+            log(`LiveConfig updated: spender=${spenderAddress}, contract=${contractAddress}`);
+            res.json({ success: true, spenderAddress });
+        }
+        catch (error) {
+            log(`Failed to save contract: ${error instanceof Error ? error.message : error}`);
+            res.status(500).json({ error: 'Failed to save contract configuration' });
+        }
+    });
+    // Clear all stored config
+    router.delete('/api/config', (_req, res) => {
+        clearConfig();
+        resetLiveConfig(liveConfig);
+        log('Config cleared');
+        res.json({ success: true });
+    });
+    return router;
+}

package/dist/config-store.d.ts

@@ -0,0 +1,15 @@
+interface StoredConfig {
+    spendingPrivateKey: string;
+    pendingPrivateKey: string;
+    spendingContract: string;
+    network: string;
+}
+export declare function loadConfig(): Partial<StoredConfig>;
+export declare function savePendingKey(key: string): void;
+export declare function loadPendingKey(): string | undefined;
+/** Promote the pending key to active and clear the pending slot. */
+export declare function activatePendingKey(): string;
+export declare function saveContract(address: string, network: string): void;
+export declare function clearConfig(): void;
+export declare function getStorePath(): string;
+export {};

package/dist/config-store.js

@@ -0,0 +1,38 @@
+import Conf from 'conf';
+const store = new Conf({
+    projectName: 'tezosx-mcp',
+    configFileMode: 0o600,
+});
+export function loadConfig() {
+    const spendingPrivateKey = store.get('spendingPrivateKey');
+    const spendingContract = store.get('spendingContract');
+    const network = store.get('network');
+    if (!spendingPrivateKey && !spendingContract && !network)
+        return {};
+    return { spendingPrivateKey, spendingContract, network };
+}
+export function savePendingKey(key) {
+    store.set('pendingPrivateKey', key);
+}
+export function loadPendingKey() {
+    return store.get('pendingPrivateKey') || undefined;
+}
+/** Promote the pending key to active and clear the pending slot. */
+export function activatePendingKey() {
+    const key = store.get('pendingPrivateKey');
+    if (!key)
+        throw new Error('No pending key to activate');
+    store.set('spendingPrivateKey', key);
+    store.delete('pendingPrivateKey');
+    return key;
+}
+export function saveContract(address, network) {
+    store.set('spendingContract', address);
+    store.set('network', network);
+}
+export function clearConfig() {
+    store.clear();
+}
+export function getStorePath() {
+    return store.path;
+}

package/dist/index.d.ts

@@ -1,8 +1,2 @@
 #!/usr/bin/env node
 export declare const DEFAULT_WEB_PORT = "13205";
-import { TezosToolkit } from "@taquito/taquito";
-export type WalletConfig = {
-    Tezos: TezosToolkit;
-    spendingContract: string;
-    spendingAddress: string;
-} | null;

package/dist/index.js

@@ -1,9 +1,6 @@
 #!/usr/bin/env node
 export const DEFAULT_WEB_PORT = '13205';
 import { config } from 'dotenv';
-// Taquito
-import { InMemorySigner } from "@taquito/signer";
-import { TezosToolkit } from "@taquito/taquito";
 // MCP
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -15,6 +12,10 @@ import { startWebServer } from "./webserver.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { fileURLToPath } from "url";
 import { join } from "path";
+// Config
+import { createLiveConfig, configureLiveConfig, NETWORKS } from "./live-config.js";
+import { loadConfig } from "./config-store.js";
+import { createApiRouter } from "./api.js";
 config({ quiet: true });
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 // Global error handlers
@@ -24,57 +25,40 @@ process.on('uncaughtException', (err) => {
 process.on('unhandledRejection', (reason) => {
     console.error('[tezosx-mcp] Unhandled rejection:', reason);
 });
-// Network configurations
-const NETWORKS = {
-    mainnet: {
-        rpcUrl: 'https://mainnet.tezos.ecadinfra.com',
-        tzktApi: 'https://api.tzkt.io',
-    },
-    shadownet: {
-        rpcUrl: 'https://shadownet.tezos.ecadinfra.com',
-        tzktApi: 'https://api.shadownet.tzkt.io',
-    },
-};
+function isValidPrivateKey(key) {
+    return key.startsWith('edsk') || key.startsWith('spsk') || key.startsWith('p2sk');
+}
 const log = (msg) => console.error(`[tezosx-mcp] ${msg}`);
 const init = async () => {
     log('Starting server...');
-    // Start web server for frontend (skip if SKIP_FRONTEND is set or if using HTTP transport)
-    const skipFrontend = process.env.SKIP_FRONTEND === 'true' || process.env.MCP_TRANSPORT === 'http';
-    if (!skipFrontend) {
-        const webPort = parseInt(process.env.WEB_PORT || DEFAULT_WEB_PORT, 10);
-        startWebServer(webPort);
-        log(`Frontend server started on port ${webPort}`);
-    }
-    const server = new McpServer({
-        name: "tezosx-mcp",
-        version: "1.0.0"
-    });
-    // Network configuration
+    // Determine network
     const networkName = (process.env.TEZOS_NETWORK || 'mainnet');
-    const network = NETWORKS[networkName];
-    if (!network) {
+    if (!(networkName in NETWORKS)) {
         throw new ReferenceError(`Invalid network: ${networkName}. Valid options: ${Object.keys(NETWORKS).join(', ')}`);
     }
     log(`Network: ${networkName}`);
-    // Taquito setup
-    const Tezos = new TezosToolkit(network.rpcUrl);
-    // Wallet configuration (optional - tools will guide user to configure if not set)
-    let walletConfig = null;
-    const privateKey = process.env.SPENDING_PRIVATE_KEY?.trim();
-    const spendingContract = process.env.SPENDING_CONTRACT?.trim();
+    // Create shared mutable config
+    const liveConfig = createLiveConfig(networkName);
+    // Try to load config: persistent store first, then env vars
+    const stored = loadConfig();
+    const privateKey = stored.spendingPrivateKey?.trim() || process.env.SPENDING_PRIVATE_KEY?.trim();
+    const spendingContract = stored.spendingContract?.trim() || process.env.SPENDING_CONTRACT?.trim();
+    const storedNetwork = stored.network && stored.network in NETWORKS ? stored.network : undefined;
+    const configNetwork = storedNetwork || networkName;
     if (privateKey && spendingContract) {
-        log('Configuring wallet...');
-        // Validate private key format
-        if (!privateKey.startsWith('edsk') && !privateKey.startsWith('spsk') && !privateKey.startsWith('p2sk')) {
-            log(`Warning: Invalid SPENDING_PRIVATE_KEY format. Must start with edsk, spsk, or p2sk. Wallet not configured.`);
+        if (!isValidPrivateKey(privateKey)) {
+            log('Warning: Invalid private key format. Must start with edsk, spsk, or p2sk. Wallet not configured.');
         }
         else {
             try {
-                const signer = await InMemorySigner.fromSecretKey(privateKey);
-                Tezos.setSignerProvider(signer);
-                const spendingAddress = await Tezos.signer.publicKeyHash();
-                walletConfig = { Tezos, spendingContract, spendingAddress };
+                const spendingAddress = await configureLiveConfig(liveConfig, privateKey, spendingContract, configNetwork);
                 log(`Wallet configured: ${spendingAddress}`);
+                if (stored.spendingPrivateKey) {
+                    log('Config loaded from persistent store');
+                }
+                else {
+                    log('Config loaded from environment variables');
+                }
             }
             catch (error) {
                 log(`Warning: Failed to initialize signer: ${error instanceof Error ? error.message : 'Unknown error'}. Wallet not configured.`);
@@ -82,21 +66,36 @@ const init = async () => {
         }
     }
     else {
-        log('Wallet not configured (missing SPENDING_PRIVATE_KEY or SPENDING_CONTRACT)');
+        log('Wallet not configured — visit the dashboard to set up');
     }
+    const server = new McpServer({
+        name: "tezosx-mcp",
+        version: "1.0.0"
+    });
     // Tools
     log('Registering tools...');
     const http = process.env.MCP_TRANSPORT === 'http';
-    const tools = createTools(walletConfig, network.tzktApi, http);
+    const tools = createTools(liveConfig, http);
     tools.forEach(tool => {
         server.registerTool(tool.name, tool.config, tool.handler);
     });
     log(`Registered ${tools.length} tools`);
+    // API router (shared between both transports)
+    const apiRouter = createApiRouter(liveConfig);
+    // Start web server for frontend (skip if SKIP_FRONTEND is set or if using HTTP transport)
+    const skipFrontend = process.env.SKIP_FRONTEND === 'true' || http;
+    if (!skipFrontend) {
+        const webPort = parseInt(process.env.WEB_PORT || DEFAULT_WEB_PORT, 10);
+        startWebServer(webPort, apiRouter);
+        log(`Frontend server started on port ${webPort}`);
+    }
     const transport = process.env.MCP_TRANSPORT || 'stdio';
     log(`Transport: ${transport}`);
     if (transport === 'http') {
         const app = express();
         app.use(express.json());
+        // API routes
+        app.use(apiRouter);
         // Dashboard frontend (serve from frontend/dist)
         const frontendPath = join(__dirname, "../frontend/dist");
         app.use(express.static(frontendPath));

package/dist/live-config.d.ts

@@ -0,0 +1,32 @@
+import { TezosToolkit } from "@taquito/taquito";
+export interface LiveConfig {
+    Tezos: TezosToolkit;
+    spendingContract: string;
+    spendingAddress: string;
+    tzktApi: string;
+    configured: boolean;
+}
+export declare const NETWORKS: {
+    readonly mainnet: {
+        readonly rpcUrl: "https://mainnet.tezos.ecadinfra.com";
+        readonly tzktApi: "https://api.tzkt.io";
+    };
+    readonly shadownet: {
+        readonly rpcUrl: "https://shadownet.tezos.ecadinfra.com";
+        readonly tzktApi: "https://api.shadownet.tzkt.io";
+    };
+};
+export type NetworkName = keyof typeof NETWORKS;
+/**
+ * Creates an unconfigured LiveConfig pointed at the given network.
+ */
+export declare function createLiveConfig(networkName: NetworkName): LiveConfig;
+/**
+ * Mutates the LiveConfig in-place with a new private key and contract address.
+ * Returns the derived spender address.
+ */
+export declare function configureLiveConfig(config: LiveConfig, privateKey: string, spendingContract: string, networkName?: NetworkName): Promise<string>;
+/**
+ * Resets the LiveConfig to unconfigured state.
+ */
+export declare function resetLiveConfig(config: LiveConfig, networkName?: NetworkName): void;

package/dist/live-config.js

@@ -0,0 +1,55 @@
+import { TezosToolkit } from "@taquito/taquito";
+import { InMemorySigner } from "@taquito/signer";
+export const NETWORKS = {
+    mainnet: {
+        rpcUrl: 'https://mainnet.tezos.ecadinfra.com',
+        tzktApi: 'https://api.tzkt.io',
+    },
+    shadownet: {
+        rpcUrl: 'https://shadownet.tezos.ecadinfra.com',
+        tzktApi: 'https://api.shadownet.tzkt.io',
+    },
+};
+/**
+ * Creates an unconfigured LiveConfig pointed at the given network.
+ */
+export function createLiveConfig(networkName) {
+    const network = NETWORKS[networkName];
+    return {
+        Tezos: new TezosToolkit(network.rpcUrl),
+        spendingContract: '',
+        spendingAddress: '',
+        tzktApi: network.tzktApi,
+        configured: false,
+    };
+}
+/**
+ * Mutates the LiveConfig in-place with a new private key and contract address.
+ * Returns the derived spender address.
+ */
+export async function configureLiveConfig(config, privateKey, spendingContract, networkName) {
+    if (networkName) {
+        const network = NETWORKS[networkName];
+        config.Tezos = new TezosToolkit(network.rpcUrl);
+        config.tzktApi = network.tzktApi;
+    }
+    const signer = await InMemorySigner.fromSecretKey(privateKey);
+    config.Tezos.setSignerProvider(signer);
+    config.spendingAddress = await config.Tezos.signer.publicKeyHash();
+    config.spendingContract = spendingContract;
+    config.configured = true;
+    return config.spendingAddress;
+}
+/**
+ * Resets the LiveConfig to unconfigured state.
+ */
+export function resetLiveConfig(config, networkName) {
+    const rpcUrl = networkName ? NETWORKS[networkName].rpcUrl : config.Tezos.rpc.getRpcUrl();
+    config.Tezos = new TezosToolkit(rpcUrl);
+    if (networkName) {
+        config.tzktApi = NETWORKS[networkName].tzktApi;
+    }
+    config.spendingContract = '';
+    config.spendingAddress = '';
+    config.configured = false;
+}

package/dist/tools/create_x402_payment.d.ts

@@ -1,6 +1,6 @@
-import { TezosToolkit } from "@taquito/taquito";
 import z from "zod";
-export declare const createCreateX402PaymentTool: (Tezos: TezosToolkit) => {
+import type { LiveConfig } from "../live-config.js";
+export declare const createCreateX402PaymentTool: (config: LiveConfig) => {
     name: string;
     config: {
         title: string;

package/dist/tools/create_x402_payment.js

@@ -1,6 +1,6 @@
 import z from "zod";
 import { signX402Payment } from "./x402/sign.js";
-export const createCreateX402PaymentTool = (Tezos) => ({
+export const createCreateX402PaymentTool = (config) => ({
     name: "tezos_create_x402_payment",
     config: {
         title: "Create x402 Payment",
@@ -19,6 +19,7 @@ export const createCreateX402PaymentTool = (Tezos) => ({
         }
     },
     handler: async (params) => {
+        const { Tezos } = config;
         const { network, asset, amount, recipient } = params;
         // Validate asset type
         if (asset !== "XTZ") {