@ecadlabs/tezosx-mcp 1.0.6 → 1.0.8

package/dist/index.js

@@ -31,27 +31,26 @@ function isValidPrivateKey(key) {
 const log = (msg) => console.error(`[tezosx-mcp] ${msg}`);
 const init = async () => {
     log('Starting server...');
-    // Determine network
-    const networkName = (process.env.TEZOS_NETWORK || 'mainnet');
+    // Try to load config: env vars first, then persistent store
+    const stored = loadConfig();
+    const privateKey = process.env.SPENDING_PRIVATE_KEY?.trim() || stored.spendingPrivateKey?.trim();
+    const spendingContract = process.env.SPENDING_CONTRACT?.trim() || stored.spendingContract?.trim();
+    const storedNetwork = stored.network && stored.network in NETWORKS ? stored.network : undefined;
+    // Determine network: env var > stored config > mainnet
+    const networkName = (process.env.TEZOS_NETWORK || storedNetwork || 'mainnet');
     if (!(networkName in NETWORKS)) {
         throw new ReferenceError(`Invalid network: ${networkName}. Valid options: ${Object.keys(NETWORKS).join(', ')}`);
     }
     log(`Network: ${networkName}`);
     // Create shared mutable config
     const liveConfig = createLiveConfig(networkName);
-    // Try to load config: env vars first, then persistent store
-    const stored = loadConfig();
-    const privateKey = process.env.SPENDING_PRIVATE_KEY?.trim() || stored.spendingPrivateKey?.trim();
-    const spendingContract = process.env.SPENDING_CONTRACT?.trim() || stored.spendingContract?.trim();
-    const storedNetwork = stored.network && stored.network in NETWORKS ? stored.network : undefined;
-    const configNetwork = networkName || storedNetwork;
     if (privateKey && spendingContract) {
         if (!isValidPrivateKey(privateKey)) {
             log('Warning: Invalid private key format. Must start with edsk, spsk, or p2sk. Wallet not configured.');
         }
         else {
             try {
-                const spendingAddress = await configureLiveConfig(liveConfig, privateKey, spendingContract, configNetwork);
+                const spendingAddress = await configureLiveConfig(liveConfig, privateKey, spendingContract, networkName);
                 log(`Wallet configured: ${spendingAddress}`);
                 if (stored.spendingPrivateKey) {
                     log('Config loaded from persistent store');

package/dist/tools/bridge_execute_withdrawal.d.ts

@@ -0,0 +1,27 @@
+import z from "zod";
+import type { LiveConfig } from "../live-config.js";
+export declare const createBridgeExecuteWithdrawalTool: (config: LiveConfig) => {
+    name: string;
+    config: {
+        title: string;
+        description: string;
+        inputSchema: z.ZodObject<{
+            outboxLevel: z.ZodOptional<z.ZodNumber>;
+            messageIndex: z.ZodOptional<z.ZodNumber>;
+            cementedCommitment: z.ZodOptional<z.ZodString>;
+            outputProof: 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/bridge_execute_withdrawal.js

@@ -0,0 +1,125 @@
+import axios from "axios";
+import z from "zod";
+import { ensureRevealed } from "./reveal_account.js";
+const CONFIRMATIONS_TO_WAIT = 3;
+const BRIDGE_CONFIG = {
+    mainnet: {
+        smartRollupAddress: "sr1Ghq66tYK9y3r8CC1Tf8i8m5nxh8nTvZEf",
+    },
+    shadownet: {
+        smartRollupAddress: "sr19fMYrr5C4qqvQqQrDSjtP31GcrWjodzvg",
+    },
+};
+// Default rollup node URLs (can be overridden via env)
+const ROLLUP_NODE_URLS = {
+    mainnet: process.env.ETHERLINK_ROLLUP_NODE_MAINNET,
+    shadownet: process.env.ETHERLINK_ROLLUP_NODE_SHADOWNET,
+};
+const inputSchema = z.object({
+    // Option 1: provide outbox level + message index (requires rollup node access)
+    outboxLevel: z.number().optional().describe("The Tezos L1 block level of the outbox containing the withdrawal message. " +
+        "Used with messageIndex to auto-fetch the proof from the rollup node."),
+    messageIndex: z.number().optional().describe("The index of the message within the outbox level. Defaults to 0."),
+    // Option 2: provide pre-computed proof directly
+    cementedCommitment: z.string().optional().describe("The cemented commitment hash (src1...). Required if outputProof is provided directly."),
+    outputProof: z.string().optional().describe("The hex-encoded output proof. If provided along with cementedCommitment, skips rollup node query."),
+});
+async function fetchProofFromRollupNode(rollupNodeUrl, outboxLevel, messageIndex) {
+    const url = `${rollupNodeUrl}/global/block/head/helpers/proofs/outbox/${outboxLevel}/messages?index=${messageIndex}`;
+    try {
+        const { data } = await axios.get(url, { timeout: 30_000 });
+        return {
+            commitment: data.commitment,
+            proof: data.proof,
+        };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to fetch outbox proof from rollup node at ${rollupNodeUrl}: ${msg}\n` +
+            `Ensure ETHERLINK_ROLLUP_NODE_MAINNET or ETHERLINK_ROLLUP_NODE_SHADOWNET env var is set to a valid rollup node URL.`);
+    }
+}
+async function getCementedCommitment(tezosRpcUrl, rollupAddress) {
+    const url = `${tezosRpcUrl}/chains/main/blocks/head/context/smart_rollups/smart_rollup/${rollupAddress}/last_cemented_commitment_hash_with_level`;
+    try {
+        const { data } = await axios.get(url, { timeout: 15_000 });
+        return { hash: data.hash, level: data.level };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to get cemented commitment: ${msg}`);
+    }
+}
+export const createBridgeExecuteWithdrawalTool = (config) => ({
+    name: "tezos_bridge_execute_withdrawal",
+    config: {
+        title: "Execute Bridge Withdrawal",
+        description: "Executes a cemented outbox message on Tezos L1 to finalize a standard bridge withdrawal (Etherlink → Tezos). " +
+            "This can only be done after the commitment containing the withdrawal has been cemented (~15 days after initiation). " +
+            "Provide either outboxLevel + messageIndex (auto-fetches proof from rollup node) or cementedCommitment + outputProof directly. " +
+            "Requires ETHERLINK_ROLLUP_NODE_MAINNET or ETHERLINK_ROLLUP_NODE_SHADOWNET env var for auto-fetch mode.",
+        inputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    handler: async (params) => {
+        params = params;
+        const { Tezos, networkName, spendingAddress } = config;
+        const bridgeConfig = BRIDGE_CONFIG[networkName];
+        if (!bridgeConfig) {
+            throw new Error(`Bridge not supported on network: ${networkName}`);
+        }
+        let commitment;
+        let proof;
+        if (params.outputProof && params.cementedCommitment) {
+            // Direct mode: use provided proof
+            commitment = params.cementedCommitment;
+            proof = params.outputProof;
+        }
+        else if (params.outboxLevel !== undefined) {
+            // Auto-fetch mode: query rollup node for proof
+            const rollupNodeUrl = ROLLUP_NODE_URLS[networkName];
+            if (!rollupNodeUrl) {
+                throw new Error(`No rollup node URL configured for ${networkName}. ` +
+                    `Set ETHERLINK_ROLLUP_NODE_${networkName.toUpperCase()} environment variable, ` +
+                    `or provide cementedCommitment and outputProof directly.`);
+            }
+            const messageIndex = params.messageIndex ?? 0;
+            const proofResult = await fetchProofFromRollupNode(rollupNodeUrl, params.outboxLevel, messageIndex);
+            commitment = proofResult.commitment;
+            proof = proofResult.proof;
+        }
+        else {
+            throw new Error("Provide either: (1) outboxLevel + messageIndex to auto-fetch proof from rollup node, " +
+                "or (2) cementedCommitment + outputProof directly.");
+        }
+        // Check spender has enough for fees
+        const spenderBalance = await Tezos.tz.getBalance(spendingAddress);
+        if (spenderBalance.isZero()) {
+            throw new Error("Spending account balance is 0. Please fund the spending address to cover transaction fees.");
+        }
+        await ensureRevealed(Tezos);
+        // Execute the outbox message
+        const op = await Tezos.contract.smartRollupExecuteOutboxMessage({
+            rollup: bridgeConfig.smartRollupAddress,
+            cementedCommitment: commitment,
+            outputProof: proof,
+        });
+        await op.confirmation(CONFIRMATIONS_TO_WAIT);
+        const tzktBase = config.tzktApi.replace('api.', '').replace('/v1', '');
+        const tzktUrl = `${tzktBase}/${op.hash}`;
+        return {
+            content: [{
+                    type: "text",
+                    text: `Outbox message executed successfully.\n` +
+                        `Commitment: ${commitment}\n` +
+                        `Operation: ${tzktUrl}\n` +
+                        `The withdrawal funds have been released to the recipient on Tezos L1.`,
+                }],
+        };
+    },
+});

package/dist/tools/bridge_status.d.ts

@@ -0,0 +1,25 @@
+import z from "zod";
+import type { LiveConfig } from "../live-config.js";
+export declare const createBridgeStatusTool: (config: LiveConfig) => {
+    name: string;
+    config: {
+        title: string;
+        description: string;
+        inputSchema: z.ZodObject<{
+            address: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, 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/bridge_status.js

@@ -0,0 +1,155 @@
+import axios from "axios";
+import z from "zod";
+const BRIDGE_CONFIG = {
+    mainnet: {
+        bridgeContract: "KT1Wj8SUGmnEPFqyahHAcjcNQwe6YGhEXJb5",
+        exchangerContract: "KT1CeFqjJRJPNVvhvznQrWfHad2jCiDZ6Lyj",
+        fastWithdrawalContract: "KT1BGwyCrnJ6HuEYP7X8Q2UooTdxmEYHiK6j",
+        smartRollupAddress: "sr1Ghq66tYK9y3r8CC1Tf8i8m5nxh8nTvZEf",
+    },
+    shadownet: {
+        bridgeContract: "KT19aBsSWvWtvEkbiqReJnD8UzQMWcD8SHUD",
+        exchangerContract: "KT1JYZsawXmeArts18nn4uT79tUJc4AGTYgc",
+        fastWithdrawalContract: "KT1E1f7ze8FcjbFu4UwnBqNo4kbbS6Zo5Y9W",
+        smartRollupAddress: "sr19fMYrr5C4qqvQqQrDSjtP31GcrWjodzvg",
+    },
+};
+const MUTEZ_PER_TEZ = 1_000_000;
+const inputSchema = z.object({
+    address: z.string().optional().describe("Tezos (tz1/tz2/KT1) or Etherlink (0x) address to check bridge transfers for. Defaults to the spending contract address."),
+    limit: z.number().optional().describe("Max results per category. Default: 5"),
+});
+function formatMutez(mutez) {
+    return `${(mutez / MUTEZ_PER_TEZ).toFixed(6)} XTZ`;
+}
+function formatEtherlinkAddress(hex) {
+    return `0x${hex}`;
+}
+export const createBridgeStatusTool = (config) => ({
+    name: "tezos_bridge_status",
+    config: {
+        title: "Bridge Transfer Status",
+        description: "Checks the status of Tezos <-> Etherlink bridge transfers for a given address. " +
+            "Shows deposits (Tezos -> Etherlink), standard withdrawals (Etherlink -> Tezos), " +
+            "and fast withdrawals. Accepts either a Tezos or Etherlink address.",
+        inputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    handler: async (params) => {
+        params = params;
+        const { networkName, spendingContract, tzktApi } = config;
+        const bridgeConfig = BRIDGE_CONFIG[networkName];
+        if (!bridgeConfig) {
+            throw new Error(`Bridge not supported on network: ${networkName}`);
+        }
+        const limit = params.limit ?? 5;
+        const address = params.address ?? spendingContract;
+        const isTezosAddress = /^(tz[123]|KT1)[a-zA-Z0-9]{33}$/.test(address);
+        const isEtherlinkAddress = /^0x[0-9a-fA-F]{40}$/.test(address);
+        if (!isTezosAddress && !isEtherlinkAddress) {
+            throw new Error("Invalid address format. Provide a Tezos (tz1/tz2/KT1) or Etherlink (0x) address.");
+        }
+        const results = [];
+        const tzktBase = tzktApi;
+        // Query deposits
+        try {
+            let depositUrl;
+            if (isTezosAddress) {
+                depositUrl = `${tzktBase}/v1/operations/transactions?target=${bridgeConfig.bridgeContract}&entrypoint=deposit&sender=${address}&limit=${limit}&sort.desc=id`;
+            }
+            else {
+                const l2Hex = address.slice(2).toLowerCase();
+                depositUrl = `${tzktBase}/v1/operations/transactions?target=${bridgeConfig.bridgeContract}&entrypoint=deposit&parameter.l2_address=${l2Hex}&limit=${limit}&sort.desc=id`;
+            }
+            const { data: deposits } = await axios.get(depositUrl);
+            if (deposits.length > 0) {
+                results.push(`## Deposits (Tezos → Etherlink): ${deposits.length} found\n`);
+                for (const dep of deposits) {
+                    const amount = formatMutez(dep.amount);
+                    const l2 = dep.parameter?.value?.l2_address
+                        ? formatEtherlinkAddress(dep.parameter.value.l2_address)
+                        : "unknown";
+                    const from = dep.sender?.address ?? "unknown";
+                    results.push(`- **${amount}** → ${l2}\n` +
+                        `  From: ${from} | ${dep.status} | ${dep.timestamp}\n` +
+                        `  Hash: ${dep.hash}`);
+                }
+            }
+            else {
+                results.push("## Deposits (Tezos → Etherlink): none found");
+            }
+        }
+        catch {
+            results.push("## Deposits: query failed");
+        }
+        // Query standard withdrawals (exchanger burn) — only for Tezos addresses
+        if (isTezosAddress) {
+            try {
+                const burnUrl = `${tzktBase}/v1/operations/transactions?target=${bridgeConfig.exchangerContract}&entrypoint=burn&parameter.address=${address}&limit=${limit}&sort.desc=id`;
+                const { data: burns } = await axios.get(burnUrl);
+                if (burns.length > 0) {
+                    results.push(`\n## Standard Withdrawals (Etherlink → Tezos): ${burns.length} found\n`);
+                    for (const burn of burns) {
+                        const ticketAmount = burn.parameter?.value?.ticket?.amount ?? "?";
+                        const amount = formatMutez(Number(ticketAmount));
+                        results.push(`- **${amount}** → ${address}\n` +
+                            `  ${burn.status} | ${burn.timestamp}\n` +
+                            `  Hash: ${burn.hash}`);
+                    }
+                }
+                else {
+                    results.push("\n## Standard Withdrawals (Etherlink → Tezos): none found");
+                }
+            }
+            catch {
+                results.push("\n## Standard Withdrawals: query failed");
+            }
+        }
+        // Query fast withdrawals
+        try {
+            let fastUrl;
+            if (isTezosAddress) {
+                fastUrl = `${tzktBase}/v1/operations/transactions?target=${bridgeConfig.fastWithdrawalContract}&entrypoint=payout_withdrawal&parameter.withdrawal.base_withdrawer=${address}&limit=${limit}&sort.desc=id`;
+            }
+            else {
+                const l2Hex = address.slice(2).toLowerCase();
+                fastUrl = `${tzktBase}/v1/operations/transactions?target=${bridgeConfig.fastWithdrawalContract}&entrypoint=payout_withdrawal&parameter.withdrawal.l2_caller=${l2Hex}&limit=${limit}&sort.desc=id`;
+            }
+            const { data: fastOps } = await axios.get(fastUrl);
+            if (fastOps.length > 0) {
+                results.push(`\n## Fast Withdrawals: ${fastOps.length} found\n`);
+                for (const fw of fastOps) {
+                    const w = fw.parameter?.value?.withdrawal;
+                    const fullAmount = w?.full_amount ? formatMutez(Number(w.full_amount)) : "?";
+                    const paidAmount = formatMutez(fw.amount);
+                    const recipient = w?.base_withdrawer ?? "unknown";
+                    const l2Caller = w?.l2_caller ? formatEtherlinkAddress(w.l2_caller) : "unknown";
+                    const fee = w?.full_amount
+                        ? formatMutez(Number(w.full_amount) - fw.amount)
+                        : "?";
+                    results.push(`- **${fullAmount}** (paid: ${paidAmount}, fee: ${fee})\n` +
+                        `  To: ${recipient} | From L2: ${l2Caller}\n` +
+                        `  ID: ${w?.withdrawal_id ?? "?"} | ${fw.status} | ${fw.timestamp}\n` +
+                        `  Hash: ${fw.hash}`);
+                }
+            }
+            else {
+                results.push("\n## Fast Withdrawals: none found");
+            }
+        }
+        catch {
+            results.push("\n## Fast Withdrawals: query failed");
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `# Bridge Status for ${address}\nNetwork: ${networkName}\n\n${results.join("\n")}`,
+                }],
+        };
+    },
+});

package/dist/tools/bridge_to_etherlink.d.ts

@@ -0,0 +1,25 @@
+import z from "zod";
+import { type LiveConfig } from "../live-config.js";
+export declare const createBridgeToEtherlinkTool: (config: LiveConfig) => {
+    name: string;
+    config: {
+        title: string;
+        description: string;
+        inputSchema: z.ZodObject<{
+            amount: z.ZodNumber;
+            etherlinkAddress: 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/bridge_to_etherlink.js

@@ -0,0 +1,116 @@
+import z from "zod";
+import { ensureRevealed } from "./reveal_account.js";
+import { calculateFeeRebate } from "../live-config.js";
+// Constants
+const MUTEZ_PER_TEZ = 1_000_000;
+const CONFIRMATIONS_TO_WAIT = 3;
+// Bridge configuration per network
+// bridge contract = the evm_bridge.mligo contract that handles deposits
+// exchanger = the exchanger.mligo contract (not called directly by users)
+// smartRollupAddress = passed as evm_address param to the bridge deposit entrypoint
+const BRIDGE_CONFIG = {
+    mainnet: {
+        smartRollupAddress: "sr1Ghq66tYK9y3r8CC1Tf8i8m5nxh8nTvZEf",
+        bridgeContractAddress: "KT1Wj8SUGmnEPFqyahHAcjcNQwe6YGhEXJb5",
+    },
+    shadownet: {
+        smartRollupAddress: "sr19fMYrr5C4qqvQqQrDSjtP31GcrWjodzvg",
+        bridgeContractAddress: "KT19aBsSWvWtvEkbiqReJnD8UzQMWcD8SHUD",
+    },
+};
+const inputSchema = z.object({
+    amount: z.number().describe("The amount of XTZ to bridge to Etherlink."),
+    etherlinkAddress: z.string().describe("The Etherlink (0x) address to receive the bridged XTZ."),
+});
+// Cache the last-verified spender so we only hit the chain when config changes
+let verifiedSpender = null;
+export const createBridgeToEtherlinkTool = (config) => ({
+    name: "tezos_bridge_to_etherlink",
+    config: {
+        title: "Bridge XTZ to Etherlink",
+        description: "Bridges XTZ from Tezos to Etherlink via the native bridge. " +
+            "Sends XTZ from the spending contract through the Tezos-Etherlink bridge to the specified Etherlink address. " +
+            "The bridged XTZ will appear as native tokens on Etherlink after the rollup processes the deposit.",
+        inputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    },
+    handler: async (params) => {
+        params = params;
+        const { Tezos, spendingContract, spendingAddress, networkName } = config;
+        const bridgeConfig = BRIDGE_CONFIG[networkName];
+        if (!bridgeConfig) {
+            throw new Error(`Bridge not supported on network: ${networkName}`);
+        }
+        // Validate Etherlink address format
+        if (!/^0x[0-9a-fA-F]{40}$/.test(params.etherlinkAddress)) {
+            throw new Error("Invalid Etherlink address. Must be a 0x-prefixed, 40 hex character address.");
+        }
+        const amountMutez = Math.floor(params.amount * MUTEZ_PER_TEZ);
+        if (amountMutez <= 0) {
+            throw new Error("Amount must be greater than 0.");
+        }
+        // Verify the server's signer matches the on-chain spender (only when config changes)
+        const needsVerify = !verifiedSpender
+            || verifiedSpender.address !== spendingAddress
+            || verifiedSpender.contract !== spendingContract;
+        if (needsVerify) {
+            const c = await Tezos.contract.at(spendingContract);
+            const storage = await c.storage();
+            if (storage.spender !== spendingAddress) {
+                throw new Error(`Spender mismatch: the server's signing key (${spendingAddress}) does not match ` +
+                    `the contract's spender (${storage.spender}). ` +
+                    `Please regenerate the spender key from the dashboard.`);
+            }
+            verifiedSpender = { address: spendingAddress, contract: spendingContract };
+        }
+        // Check spending contract has enough for the bridge amount
+        const contractBalance = await Tezos.tz.getBalance(spendingContract);
+        if (contractBalance.toNumber() < amountMutez) {
+            throw new Error(`Insufficient spending contract balance. ` +
+                `Requested: ${amountMutez} mutez, Available: ${contractBalance.toNumber()} mutez`);
+        }
+        // Ensure account is revealed before estimating
+        await ensureRevealed(Tezos);
+        // Step 1: Fund the spender from the spending contract
+        // The spender needs the bridge amount + fees to execute the bridge deposit
+        const spenderBalance = await Tezos.tz.getBalance(spendingAddress);
+        const spenderMutez = spenderBalance.toNumber();
+        const feeRebate = calculateFeeRebate(spenderMutez);
+        const spendingContractInstance = await Tezos.contract.at(spendingContract);
+        const fundCall = spendingContractInstance.methodsObject.spend({
+            recipient: spendingAddress,
+            amount: amountMutez,
+            fee_rebate: feeRebate,
+        });
+        const fundOp = await fundCall.send();
+        await fundOp.confirmation(CONFIRMATIONS_TO_WAIT);
+        // Step 2: Call the bridge contract's deposit entrypoint directly
+        // The deposit entrypoint takes:
+        //   evm_address: the smart rollup address (sr1...)
+        //   l2_address: the Etherlink receiver as hex bytes (without 0x prefix)
+        // XTZ is sent along with the call as the amount to bridge
+        const bridgeContract = await Tezos.contract.at(bridgeConfig.bridgeContractAddress);
+        const l2AddressBytes = params.etherlinkAddress.slice(2).toLowerCase();
+        const depositCall = bridgeContract.methodsObject.deposit({
+            evm_address: bridgeConfig.smartRollupAddress,
+            l2_address: l2AddressBytes,
+        });
+        const depositOp = await depositCall.send({ amount: amountMutez, mutez: true });
+        await depositOp.confirmation(CONFIRMATIONS_TO_WAIT);
+        const tzktBase = config.tzktApi.replace('api.', '').replace('/v1', '');
+        const tzktUrl = `${tzktBase}/${depositOp.hash}`;
+        return {
+            content: [{
+                    type: "text",
+                    text: `Bridged ${params.amount} XTZ to Etherlink address ${params.etherlinkAddress}\n` +
+                        `Tezos operation: ${tzktUrl}\n` +
+                        `The deposit will appear on Etherlink after the rollup processes it (typically a few minutes).`,
+                }],
+        };
+    },
+});

package/dist/tools/index.d.ts

@@ -131,4 +131,72 @@ export declare const createTools: (liveConfig: LiveConfig, http: boolean) => ({
             text: string;
         }[];
     }>;
+} | {
+    name: string;
+    config: {
+        title: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            amount: import("zod").ZodNumber;
+            etherlinkAddress: 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: {
+        title: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            address: import("zod").ZodOptional<import("zod").ZodString>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, 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: {
+        title: string;
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            outboxLevel: import("zod").ZodOptional<import("zod").ZodNumber>;
+            messageIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
+            cementedCommitment: import("zod").ZodOptional<import("zod").ZodString>;
+            outputProof: 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;
+        }[];
+    }>;
 })[];

package/dist/tools/index.js

@@ -8,6 +8,9 @@ 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 { createBridgeToEtherlinkTool } from "./bridge_to_etherlink.js";
+import { createBridgeStatusTool } from "./bridge_status.js";
+import { createBridgeExecuteWithdrawalTool } from "./bridge_execute_withdrawal.js";
 import { createGetDashboardTool } from "./get_dashboard.js";
 const getNotConfiguredMessage = () => `Wallet not configured.
 
@@ -43,6 +46,9 @@ export const createTools = (liveConfig, http) => {
         createRecoverSpenderFundsTool(liveConfig),
         createRevealAccountTool(liveConfig),
         createSendXtzTool(liveConfig),
+        createBridgeToEtherlinkTool(liveConfig),
+        createBridgeStatusTool(liveConfig),
+        createBridgeExecuteWithdrawalTool(liveConfig),
     ];
     if (!http) {
         tools.push(createGetDashboardTool(liveConfig));

package/dist/tools/recover_spender_funds.js

@@ -51,7 +51,7 @@ export const createRecoverSpenderFundsTool = (config) => ({
         const isContract = destination.startsWith("KT1");
         if (isContract) {
             const contract = await Tezos.contract.at(destination);
-            const depositCall = contract.methodsObject.default_(null);
+            const depositCall = contract.methodsObject["default"](null);
             const estimate = await Tezos.estimate.contractCall(depositCall);
             const maxAmount = balanceMutez - estimate.suggestedFeeMutez;
             if (maxAmount <= 0) {
@@ -62,7 +62,7 @@ export const createRecoverSpenderFundsTool = (config) => ({
                         }],
                 };
             }
-            const operation = await contract.methodsObject.default_(null).send({
+            const operation = await contract.methodsObject["default"](null).send({
                 amount: maxAmount,
                 mutez: true,
                 fee: estimate.suggestedFeeMutez,