@nirholas/bnbchain-mcp 1.0.0

package/build/evm/modules/deployment/tools.js

@@ -0,0 +1,718 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDeploymentTools = registerDeploymentTools;
+const viem_1 = require("viem");
+const zod_1 = require("zod");
+const clients_js_1 = require("@/evm/services/clients.js");
+const helper_js_1 = require("@/utils/helper.js");
+const types_js_1 = require("../common/types.js");
+// Block explorer API endpoints for verification
+const EXPLORER_APIS = {
+    1: { url: "https://api.etherscan.io/api", name: "Etherscan" },
+    56: { url: "https://api.bscscan.com/api", name: "BSCScan" },
+    137: { url: "https://api.polygonscan.com/api", name: "PolygonScan" },
+    42161: { url: "https://api.arbiscan.io/api", name: "Arbiscan" },
+    10: { url: "https://api-optimistic.etherscan.io/api", name: "Optimistic Etherscan" },
+    8453: { url: "https://api.basescan.org/api", name: "BaseScan" },
+    43114: { url: "https://api.snowtrace.io/api", name: "Snowtrace" },
+    250: { url: "https://api.ftmscan.com/api", name: "FTMScan" },
+    11155111: { url: "https://api-sepolia.etherscan.io/api", name: "Etherscan Sepolia" }
+};
+// Proxy ABIs
+const TRANSPARENT_PROXY_ABI = (0, viem_1.parseAbi)([
+    "constructor(address _logic, address admin_, bytes _data)",
+    "function admin() view returns (address)",
+    "function implementation() view returns (address)",
+    "function changeAdmin(address newAdmin) external",
+    "function upgradeTo(address newImplementation) external",
+    "function upgradeToAndCall(address newImplementation, bytes data) payable external"
+]);
+const UUPS_PROXY_ABI = (0, viem_1.parseAbi)([
+    "function upgradeTo(address newImplementation) external",
+    "function upgradeToAndCall(address newImplementation, bytes data) payable external",
+    "function proxiableUUID() view returns (bytes32)"
+]);
+const PROXY_ADMIN_ABI = (0, viem_1.parseAbi)([
+    "function getProxyAdmin(address proxy) view returns (address)",
+    "function getProxyImplementation(address proxy) view returns (address)",
+    "function upgrade(address proxy, address implementation) external",
+    "function upgradeAndCall(address proxy, address implementation, bytes data) payable external",
+    "function changeProxyAdmin(address proxy, address newAdmin) external"
+]);
+// Well-known proxy factory addresses
+const CREATE2_FACTORY = {
+    1: "0x4e59b44847b379578588920cA78FbF26c0B4956C", // Deterministic Deployment Proxy
+    56: "0x4e59b44847b379578588920cA78FbF26c0B4956C",
+    137: "0x4e59b44847b379578588920cA78FbF26c0B4956C",
+    42161: "0x4e59b44847b379578588920cA78FbF26c0B4956C",
+    10: "0x4e59b44847b379578588920cA78FbF26c0B4956C",
+    8453: "0x4e59b44847b379578588920cA78FbF26c0B4956C"
+};
+// EIP-1967 storage slots
+const IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+const ADMIN_SLOT = "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103";
+function registerDeploymentTools(server) {
+    // Deploy contract from bytecode
+    server.tool("deploy_contract", "Deploy a smart contract from bytecode and constructor arguments", {
+        network: types_js_1.defaultNetworkParam,
+        bytecode: zod_1.z.string().describe("Contract bytecode (hex string starting with 0x)"),
+        abi: zod_1.z.array(zod_1.z.any()).optional().describe("Contract ABI (required if constructor has arguments)"),
+        constructorArgs: zod_1.z.array(zod_1.z.any()).optional().describe("Constructor arguments"),
+        value: zod_1.z.string().optional().describe("ETH value to send with deployment (in wei)"),
+        privateKey: zod_1.z.string().describe("Private key for deployment").default(process.env.PRIVATE_KEY),
+        gasLimit: zod_1.z.string().optional().describe("Gas limit for deployment")
+    }, async ({ network, bytecode, abi, constructorArgs = [], value, privateKey, gasLimit }) => {
+        try {
+            const publicClient = (0, clients_js_1.getPublicClient)(network);
+            const walletClient = (0, clients_js_1.getWalletClient)(privateKey, network);
+            const deployer = walletClient.account.address;
+            // Validate bytecode
+            if (!bytecode.startsWith("0x")) {
+                bytecode = `0x${bytecode}`;
+            }
+            // Prepare deployment data
+            let deployData;
+            if (abi && constructorArgs.length > 0) {
+                deployData = (0, viem_1.encodeDeployData)({
+                    abi,
+                    bytecode: bytecode,
+                    args: constructorArgs
+                });
+            }
+            else {
+                deployData = bytecode;
+            }
+            // Get current nonce for address prediction
+            const nonce = await publicClient.getTransactionCount({ address: deployer });
+            const predictedAddress = (0, viem_1.getContractAddress)({
+                from: deployer,
+                nonce: BigInt(nonce)
+            });
+            // Estimate gas if not provided
+            let gas;
+            if (gasLimit) {
+                gas = BigInt(gasLimit);
+            }
+            else {
+                try {
+                    gas = await publicClient.estimateGas({
+                        account: deployer,
+                        data: deployData,
+                        value: value ? BigInt(value) : 0n
+                    });
+                    // Add 20% buffer for safety
+                    gas = (gas * 120n) / 100n;
+                }
+                catch (estimateError) {
+                    return helper_js_1.mcpToolRes.error(new Error(`Gas estimation failed: ${estimateError.message}`), "deploying contract");
+                }
+            }
+            // Deploy the contract
+            const hash = await walletClient.sendTransaction({
+                data: deployData,
+                value: value ? BigInt(value) : 0n,
+                gas
+            });
+            // Wait for receipt
+            const receipt = await publicClient.waitForTransactionReceipt({ hash });
+            if (receipt.status === "reverted") {
+                return helper_js_1.mcpToolRes.error(new Error("Contract deployment reverted"), "deploying contract");
+            }
+            return helper_js_1.mcpToolRes.success({
+                network,
+                deployment: {
+                    transactionHash: hash,
+                    contractAddress: receipt.contractAddress,
+                    predictedAddress,
+                    deployer,
+                    gasUsed: receipt.gasUsed.toString(),
+                    effectiveGasPrice: receipt.effectiveGasPrice?.toString(),
+                    blockNumber: receipt.blockNumber.toString()
+                },
+                status: "success",
+                note: "Contract deployed successfully. Consider verifying the source code."
+            });
+        }
+        catch (error) {
+            return helper_js_1.mcpToolRes.error(error, "deploying contract");
+        }
+    });
+    // Deploy with CREATE2
+    server.tool("deploy_create2", "Deploy a contract using CREATE2 for deterministic addresses across chains", {
+        network: types_js_1.defaultNetworkParam,
+        bytecode: zod_1.z.string().describe("Contract bytecode (hex string)"),
+        salt: zod_1.z.string().describe("Salt for deterministic address (32 bytes hex or string to hash)"),
+        abi: zod_1.z.array(zod_1.z.any()).optional().describe("Contract ABI (required if constructor has arguments)"),
+        constructorArgs: zod_1.z.array(zod_1.z.any()).optional().describe("Constructor arguments"),
+        factoryAddress: zod_1.z.string().optional().describe("CREATE2 factory address (uses default if not provided)"),
+        privateKey: zod_1.z.string().describe("Private key for deployment").default(process.env.PRIVATE_KEY)
+    }, async ({ network, bytecode, salt, abi, constructorArgs = [], factoryAddress, privateKey }) => {
+        try {
+            const publicClient = (0, clients_js_1.getPublicClient)(network);
+            const walletClient = (0, clients_js_1.getWalletClient)(privateKey, network);
+            const chainId = await publicClient.getChainId();
+            const deployer = walletClient.account.address;
+            // Validate bytecode
+            if (!bytecode.startsWith("0x")) {
+                bytecode = `0x${bytecode}`;
+            }
+            // Prepare salt (hash if not 32 bytes hex)
+            let saltBytes;
+            if (salt.startsWith("0x") && salt.length === 66) {
+                saltBytes = salt;
+            }
+            else {
+                saltBytes = (0, viem_1.keccak256)((0, viem_1.toBytes)(salt));
+            }
+            // Get factory address
+            const factory = factoryAddress
+                ? factoryAddress
+                : CREATE2_FACTORY[chainId];
+            if (!factory) {
+                return helper_js_1.mcpToolRes.error(new Error(`No CREATE2 factory configured for chain ${chainId}. Please provide factoryAddress.`), "deploying with CREATE2");
+            }
+            // Prepare init code with constructor args
+            let initCode;
+            if (abi && constructorArgs.length > 0) {
+                initCode = (0, viem_1.encodeDeployData)({
+                    abi,
+                    bytecode: bytecode,
+                    args: constructorArgs
+                });
+            }
+            else {
+                initCode = bytecode;
+            }
+            // Calculate deterministic address
+            const initCodeHash = (0, viem_1.keccak256)(initCode);
+            const predictedAddress = (0, viem_1.getCreate2Address)({
+                from: factory,
+                salt: saltBytes,
+                bytecodeHash: initCodeHash
+            });
+            // Check if already deployed
+            const existingCode = await publicClient.getCode({ address: predictedAddress });
+            if (existingCode && existingCode !== "0x") {
+                return helper_js_1.mcpToolRes.success({
+                    network,
+                    alreadyDeployed: true,
+                    contractAddress: predictedAddress,
+                    salt: saltBytes,
+                    factory,
+                    note: "Contract already exists at this address"
+                });
+            }
+            // Prepare deployment transaction to factory
+            // Standard CREATE2 factory takes salt + init code
+            const deploymentData = (0, viem_1.concat)([saltBytes, initCode]);
+            // Estimate gas
+            const gas = await publicClient.estimateGas({
+                account: deployer,
+                to: factory,
+                data: deploymentData
+            });
+            // Send deployment transaction
+            const hash = await walletClient.sendTransaction({
+                to: factory,
+                data: deploymentData,
+                gas: (gas * 120n) / 100n
+            });
+            // Wait for receipt
+            const receipt = await publicClient.waitForTransactionReceipt({ hash });
+            // Verify deployment
+            const deployedCode = await publicClient.getCode({ address: predictedAddress });
+            const deployed = deployedCode && deployedCode !== "0x";
+            return helper_js_1.mcpToolRes.success({
+                network,
+                deployment: {
+                    transactionHash: hash,
+                    contractAddress: predictedAddress,
+                    salt: saltBytes,
+                    factory,
+                    initCodeHash,
+                    gasUsed: receipt.gasUsed.toString(),
+                    blockNumber: receipt.blockNumber.toString()
+                },
+                status: deployed ? "success" : "failed",
+                note: deployed
+                    ? "Contract deployed via CREATE2. Same salt + bytecode = same address on other chains."
+                    : "Deployment transaction succeeded but contract not found at predicted address"
+            });
+        }
+        catch (error) {
+            return helper_js_1.mcpToolRes.error(error, "deploying with CREATE2");
+        }
+    });
+    // Deploy proxy contract
+    server.tool("deploy_proxy", "Deploy a proxy contract (UUPS or TransparentUpgradeableProxy) pointing to an implementation", {
+        network: types_js_1.defaultNetworkParam,
+        implementationAddress: zod_1.z.string().describe("Address of the implementation contract"),
+        proxyType: zod_1.z.enum(["transparent", "uups"]).describe("Type of proxy to deploy"),
+        adminAddress: zod_1.z.string().optional().describe("Admin address (for transparent proxy)"),
+        initData: zod_1.z.string().optional().describe("Initialization calldata (hex) to call on implementation"),
+        abi: zod_1.z.array(zod_1.z.any()).optional().describe("Implementation ABI (required for init function encoding)"),
+        initFunction: zod_1.z.string().optional().describe("Name of initialization function"),
+        initArgs: zod_1.z.array(zod_1.z.any()).optional().describe("Arguments for initialization function"),
+        privateKey: zod_1.z.string().describe("Private key for deployment").default(process.env.PRIVATE_KEY)
+    }, async ({ network, implementationAddress, proxyType, adminAddress, initData, abi, initFunction, initArgs = [], privateKey }) => {
+        try {
+            const publicClient = (0, clients_js_1.getPublicClient)(network);
+            const walletClient = (0, clients_js_1.getWalletClient)(privateKey, network);
+            const deployer = walletClient.account.address;
+            // Validate implementation exists
+            const implCode = await publicClient.getCode({ address: implementationAddress });
+            if (!implCode || implCode === "0x") {
+                return helper_js_1.mcpToolRes.error(new Error("Implementation address has no contract code"), "deploying proxy");
+            }
+            // Prepare initialization data
+            let initCalldata = "0x";
+            if (initData) {
+                initCalldata = initData;
+            }
+            else if (abi && initFunction) {
+                initCalldata = (0, viem_1.encodeFunctionData)({
+                    abi,
+                    functionName: initFunction,
+                    args: initArgs
+                });
+            }
+            // Admin address defaults to deployer
+            const admin = adminAddress || deployer;
+            // OpenZeppelin Transparent Proxy bytecode (simplified - in production use actual bytecode)
+            // This is the ERC1967Proxy constructor structure
+            const ERC1967_PROXY_BYTECODE = "0x608060405260405161086d38038061086d83398181016040528101906100259190610537565b61005160017f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbd6100b860201b60201c565b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b61008460001b60201c565b6100ac82826100b060201b60201c565b50505050565b9055565b600082511115610101578173ffffffffffffffffffffffffffffffffffffffff16826040516100e29190610636565b600060405180830381855af49150503d806000811461011d576040519150601f19603f3d011682016040523d82523d6000602084013e610122565b606091505b50505b505056fea26469706673582212209b";
+            // For transparent proxy, we need to deploy ProxyAdmin first or use existing
+            let proxyAdminAddress = null;
+            let proxyAddress = null;
+            let deploymentTx;
+            if (proxyType === "transparent") {
+                // Deploy TransparentUpgradeableProxy
+                // In production, this would use the actual OpenZeppelin bytecode
+                const deployData = (0, viem_1.encodeDeployData)({
+                    abi: [
+                        {
+                            type: "constructor",
+                            inputs: [
+                                { name: "_logic", type: "address" },
+                                { name: "_admin", type: "address" },
+                                { name: "_data", type: "bytes" }
+                            ]
+                        }
+                    ],
+                    // Note: In production, use actual TransparentUpgradeableProxy bytecode
+                    bytecode: ERC1967_PROXY_BYTECODE,
+                    args: [implementationAddress, admin, initCalldata]
+                });
+                const gas = await publicClient.estimateGas({
+                    account: deployer,
+                    data: deployData
+                }).catch(() => 500000n);
+                deploymentTx = await walletClient.sendTransaction({
+                    data: deployData,
+                    gas: (gas * 120n) / 100n
+                });
+                const receipt = await publicClient.waitForTransactionReceipt({ hash: deploymentTx });
+                proxyAddress = receipt.contractAddress;
+                proxyAdminAddress = admin;
+            }
+            else {
+                // UUPS Proxy (simpler - just ERC1967Proxy)
+                const deployData = (0, viem_1.encodeDeployData)({
+                    abi: [
+                        {
+                            type: "constructor",
+                            inputs: [
+                                { name: "_logic", type: "address" },
+                                { name: "_data", type: "bytes" }
+                            ]
+                        }
+                    ],
+                    bytecode: ERC1967_PROXY_BYTECODE,
+                    args: [implementationAddress, initCalldata]
+                });
+                const gas = await publicClient.estimateGas({
+                    account: deployer,
+                    data: deployData
+                }).catch(() => 500000n);
+                deploymentTx = await walletClient.sendTransaction({
+                    data: deployData,
+                    gas: (gas * 120n) / 100n
+                });
+                const receipt = await publicClient.waitForTransactionReceipt({ hash: deploymentTx });
+                proxyAddress = receipt.contractAddress;
+            }
+            // Verify deployment by reading storage slots
+            let verifiedImplementation = null;
+            let verifiedAdmin = null;
+            if (proxyAddress) {
+                try {
+                    const implSlotData = await publicClient.getStorageAt({
+                        address: proxyAddress,
+                        slot: IMPLEMENTATION_SLOT
+                    });
+                    if (implSlotData) {
+                        verifiedImplementation = `0x${implSlotData.slice(-40)}`;
+                    }
+                }
+                catch { }
+                if (proxyType === "transparent") {
+                    try {
+                        const adminSlotData = await publicClient.getStorageAt({
+                            address: proxyAddress,
+                            slot: ADMIN_SLOT
+                        });
+                        if (adminSlotData) {
+                            verifiedAdmin = `0x${adminSlotData.slice(-40)}`;
+                        }
+                    }
+                    catch { }
+                }
+            }
+            return helper_js_1.mcpToolRes.success({
+                network,
+                deployment: {
+                    proxyType,
+                    transactionHash: deploymentTx,
+                    proxyAddress,
+                    implementationAddress,
+                    proxyAdminAddress: proxyType === "transparent" ? proxyAdminAddress : null,
+                    initializationData: initCalldata !== "0x" ? initCalldata : null
+                },
+                verification: {
+                    implementationMatches: verifiedImplementation?.toLowerCase() === implementationAddress.toLowerCase(),
+                    verifiedImplementation,
+                    verifiedAdmin
+                },
+                status: "success",
+                note: proxyType === "transparent"
+                    ? "TransparentUpgradeableProxy deployed. Upgrades must go through the admin."
+                    : "UUPS Proxy deployed. Upgrades are handled by the implementation contract."
+            });
+        }
+        catch (error) {
+            return helper_js_1.mcpToolRes.error(error, "deploying proxy");
+        }
+    });
+    // Upgrade proxy implementation
+    server.tool("upgrade_proxy", "Upgrade a proxy contract to a new implementation address", {
+        network: types_js_1.defaultNetworkParam,
+        proxyAddress: zod_1.z.string().describe("Address of the proxy contract"),
+        newImplementationAddress: zod_1.z.string().describe("Address of the new implementation"),
+        proxyType: zod_1.z.enum(["transparent", "uups"]).describe("Type of proxy"),
+        proxyAdminAddress: zod_1.z.string().optional().describe("ProxyAdmin address (for transparent proxies)"),
+        callAfterUpgrade: zod_1.z.boolean().optional().describe("Whether to call a function after upgrade"),
+        upgradeCalldata: zod_1.z.string().optional().describe("Calldata for post-upgrade call"),
+        privateKey: zod_1.z.string().describe("Private key for upgrade").default(process.env.PRIVATE_KEY)
+    }, async ({ network, proxyAddress, newImplementationAddress, proxyType, proxyAdminAddress, callAfterUpgrade = false, upgradeCalldata, privateKey }) => {
+        try {
+            const publicClient = (0, clients_js_1.getPublicClient)(network);
+            const walletClient = (0, clients_js_1.getWalletClient)(privateKey, network);
+            // Validate new implementation exists
+            const newImplCode = await publicClient.getCode({ address: newImplementationAddress });
+            if (!newImplCode || newImplCode === "0x") {
+                return helper_js_1.mcpToolRes.error(new Error("New implementation address has no contract code"), "upgrading proxy");
+            }
+            // Get current implementation for comparison
+            let currentImplementation = null;
+            try {
+                const implSlotData = await publicClient.getStorageAt({
+                    address: proxyAddress,
+                    slot: IMPLEMENTATION_SLOT
+                });
+                if (implSlotData) {
+                    currentImplementation = `0x${implSlotData.slice(-40)}`;
+                }
+            }
+            catch { }
+            let upgradeTx;
+            if (proxyType === "transparent") {
+                // Transparent proxy - upgrade through ProxyAdmin
+                if (!proxyAdminAddress) {
+                    // Try to read admin from storage
+                    const adminSlotData = await publicClient.getStorageAt({
+                        address: proxyAddress,
+                        slot: ADMIN_SLOT
+                    });
+                    if (adminSlotData) {
+                        proxyAdminAddress = `0x${adminSlotData.slice(-40)}`;
+                    }
+                    else {
+                        return helper_js_1.mcpToolRes.error(new Error("Could not determine proxy admin address. Please provide proxyAdminAddress."), "upgrading proxy");
+                    }
+                }
+                // Call upgrade on ProxyAdmin or directly on proxy
+                const upgradeData = callAfterUpgrade && upgradeCalldata
+                    ? (0, viem_1.encodeFunctionData)({
+                        abi: PROXY_ADMIN_ABI,
+                        functionName: "upgradeAndCall",
+                        args: [proxyAddress, newImplementationAddress, upgradeCalldata]
+                    })
+                    : (0, viem_1.encodeFunctionData)({
+                        abi: PROXY_ADMIN_ABI,
+                        functionName: "upgrade",
+                        args: [proxyAddress, newImplementationAddress]
+                    });
+                const gas = await publicClient.estimateGas({
+                    account: walletClient.account.address,
+                    to: proxyAdminAddress,
+                    data: upgradeData
+                });
+                upgradeTx = await walletClient.sendTransaction({
+                    to: proxyAdminAddress,
+                    data: upgradeData,
+                    gas: (gas * 120n) / 100n
+                });
+            }
+            else {
+                // UUPS - upgrade through the proxy itself
+                const upgradeData = callAfterUpgrade && upgradeCalldata
+                    ? (0, viem_1.encodeFunctionData)({
+                        abi: UUPS_PROXY_ABI,
+                        functionName: "upgradeToAndCall",
+                        args: [newImplementationAddress, upgradeCalldata]
+                    })
+                    : (0, viem_1.encodeFunctionData)({
+                        abi: UUPS_PROXY_ABI,
+                        functionName: "upgradeTo",
+                        args: [newImplementationAddress]
+                    });
+                const gas = await publicClient.estimateGas({
+                    account: walletClient.account.address,
+                    to: proxyAddress,
+                    data: upgradeData
+                });
+                upgradeTx = await walletClient.sendTransaction({
+                    to: proxyAddress,
+                    data: upgradeData,
+                    gas: (gas * 120n) / 100n
+                });
+            }
+            // Wait for receipt
+            const receipt = await publicClient.waitForTransactionReceipt({ hash: upgradeTx });
+            // Verify upgrade
+            let verifiedNewImplementation = null;
+            try {
+                const implSlotData = await publicClient.getStorageAt({
+                    address: proxyAddress,
+                    slot: IMPLEMENTATION_SLOT
+                });
+                if (implSlotData) {
+                    verifiedNewImplementation = `0x${implSlotData.slice(-40)}`;
+                }
+            }
+            catch { }
+            const upgradeSuccessful = verifiedNewImplementation?.toLowerCase() === newImplementationAddress.toLowerCase();
+            return helper_js_1.mcpToolRes.success({
+                network,
+                upgrade: {
+                    proxyAddress,
+                    proxyType,
+                    previousImplementation: currentImplementation,
+                    newImplementation: newImplementationAddress,
+                    transactionHash: upgradeTx,
+                    gasUsed: receipt.gasUsed.toString(),
+                    blockNumber: receipt.blockNumber.toString()
+                },
+                verification: {
+                    upgradeSuccessful,
+                    verifiedImplementation: verifiedNewImplementation
+                },
+                status: upgradeSuccessful ? "success" : "uncertain",
+                note: upgradeSuccessful
+                    ? "Proxy upgraded successfully to new implementation"
+                    : "Upgrade transaction succeeded but implementation verification failed - check manually"
+            });
+        }
+        catch (error) {
+            return helper_js_1.mcpToolRes.error(error, "upgrading proxy");
+        }
+    });
+    // Verify contract on block explorer
+    server.tool("verify_contract", "Submit contract source code for verification on block explorers (Etherscan, Basescan, etc.)", {
+        network: types_js_1.defaultNetworkParam,
+        contractAddress: zod_1.z.string().describe("Deployed contract address"),
+        sourceCode: zod_1.z.string().describe("Contract source code (Solidity)"),
+        contractName: zod_1.z.string().describe("Contract name as it appears in source"),
+        compilerVersion: zod_1.z.string().describe("Solidity compiler version (e.g., 'v0.8.19+commit.7dd6d404')"),
+        optimizationUsed: zod_1.z.boolean().optional().default(true).describe("Whether optimization was enabled"),
+        runs: zod_1.z.number().optional().default(200).describe("Optimization runs"),
+        constructorArguments: zod_1.z.string().optional().describe("ABI-encoded constructor arguments (hex)"),
+        evmVersion: zod_1.z.string().optional().default("london").describe("EVM version"),
+        licenseType: zod_1.z.number().optional().default(3).describe("License type (3 = MIT)"),
+        apiKey: zod_1.z.string().describe("Block explorer API key")
+    }, async ({ network, contractAddress, sourceCode, contractName, compilerVersion, optimizationUsed = true, runs = 200, constructorArguments = "", evmVersion = "london", licenseType = 3, apiKey }) => {
+        try {
+            const publicClient = (0, clients_js_1.getPublicClient)(network);
+            const chainId = await publicClient.getChainId();
+            const explorerApi = EXPLORER_APIS[chainId];
+            if (!explorerApi) {
+                return helper_js_1.mcpToolRes.error(new Error(`No block explorer API configured for chain ${chainId}`), "verifying contract");
+            }
+            // Verify contract exists
+            const code = await publicClient.getCode({ address: contractAddress });
+            if (!code || code === "0x") {
+                return helper_js_1.mcpToolRes.error(new Error("No contract found at this address"), "verifying contract");
+            }
+            // Prepare verification request
+            const params = new URLSearchParams({
+                apikey: apiKey,
+                module: "contract",
+                action: "verifysourcecode",
+                contractaddress: contractAddress,
+                sourceCode: sourceCode,
+                codeformat: "solidity-single-file",
+                contractname: contractName,
+                compilerversion: compilerVersion,
+                optimizationUsed: optimizationUsed ? "1" : "0",
+                runs: runs.toString(),
+                evmversion: evmVersion,
+                licenseType: licenseType.toString()
+            });
+            if (constructorArguments) {
+                params.set("constructorArguements", constructorArguments.replace("0x", ""));
+            }
+            // Submit verification
+            const response = await fetch(explorerApi.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded"
+                },
+                body: params.toString()
+            });
+            const result = await response.json();
+            if (result.status === "1") {
+                // Verification submitted successfully, got a GUID
+                const guid = result.result;
+                // Poll for verification status
+                await new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds
+                const statusParams = new URLSearchParams({
+                    apikey: apiKey,
+                    module: "contract",
+                    action: "checkverifystatus",
+                    guid: guid
+                });
+                let verificationStatus = "pending";
+                let attempts = 0;
+                while (attempts < 6 && verificationStatus === "pending") {
+                    await new Promise(resolve => setTimeout(resolve, 10000)); // Wait 10 seconds
+                    const statusResponse = await fetch(`${explorerApi.url}?${statusParams.toString()}`);
+                    const statusResult = await statusResponse.json();
+                    if (statusResult.result === "Pending in queue") {
+                        verificationStatus = "pending";
+                    }
+                    else if (statusResult.result === "Pass - Verified") {
+                        verificationStatus = "verified";
+                    }
+                    else if (statusResult.result?.includes("Fail")) {
+                        verificationStatus = "failed";
+                        return helper_js_1.mcpToolRes.success({
+                            network,
+                            contractAddress,
+                            explorer: explorerApi.name,
+                            verificationStatus,
+                            guid,
+                            error: statusResult.result,
+                            note: "Verification failed - check compiler settings and source code"
+                        });
+                    }
+                    attempts++;
+                }
+                return helper_js_1.mcpToolRes.success({
+                    network,
+                    contractAddress,
+                    explorer: explorerApi.name,
+                    verificationStatus,
+                    guid,
+                    explorerUrl: `${explorerApi.url.replace("/api", "")}/address/${contractAddress}#code`,
+                    note: verificationStatus === "verified"
+                        ? "Contract successfully verified!"
+                        : "Verification submitted - check explorer for status"
+                });
+            }
+            else {
+                return helper_js_1.mcpToolRes.success({
+                    network,
+                    contractAddress,
+                    explorer: explorerApi.name,
+                    verificationStatus: "failed",
+                    error: result.result || result.message,
+                    note: "Verification submission failed"
+                });
+            }
+        }
+        catch (error) {
+            return helper_js_1.mcpToolRes.error(error, "verifying contract");
+        }
+    });
+    // Predict CREATE2 address
+    server.tool("predict_create2_address", "Calculate the deterministic address for a CREATE2 deployment without deploying", {
+        network: types_js_1.defaultNetworkParam,
+        bytecode: zod_1.z.string().describe("Contract bytecode"),
+        salt: zod_1.z.string().describe("Salt for deterministic address"),
+        constructorArgs: zod_1.z.array(zod_1.z.any()).optional().describe("Constructor arguments"),
+        abi: zod_1.z.array(zod_1.z.any()).optional().describe("Contract ABI (if constructor has args)"),
+        factoryAddress: zod_1.z.string().optional().describe("CREATE2 factory address")
+    }, async ({ network, bytecode, salt, constructorArgs = [], abi, factoryAddress }) => {
+        try {
+            const publicClient = (0, clients_js_1.getPublicClient)(network);
+            const chainId = await publicClient.getChainId();
+            // Validate bytecode
+            if (!bytecode.startsWith("0x")) {
+                bytecode = `0x${bytecode}`;
+            }
+            // Prepare salt
+            let saltBytes;
+            if (salt.startsWith("0x") && salt.length === 66) {
+                saltBytes = salt;
+            }
+            else {
+                saltBytes = (0, viem_1.keccak256)((0, viem_1.toBytes)(salt));
+            }
+            // Get factory address
+            const factory = factoryAddress
+                ? factoryAddress
+                : CREATE2_FACTORY[chainId];
+            if (!factory) {
+                return helper_js_1.mcpToolRes.error(new Error(`No CREATE2 factory configured for chain ${chainId}`), "predicting CREATE2 address");
+            }
+            // Prepare init code
+            let initCode;
+            if (abi && constructorArgs.length > 0) {
+                initCode = (0, viem_1.encodeDeployData)({
+                    abi,
+                    bytecode: bytecode,
+                    args: constructorArgs
+                });
+            }
+            else {
+                initCode = bytecode;
+            }
+            const initCodeHash = (0, viem_1.keccak256)(initCode);
+            const predictedAddress = (0, viem_1.getCreate2Address)({
+                from: factory,
+                salt: saltBytes,
+                bytecodeHash: initCodeHash
+            });
+            // Check if already deployed
+            const existingCode = await publicClient.getCode({ address: predictedAddress });
+            const isDeployed = existingCode && existingCode !== "0x";
+            return helper_js_1.mcpToolRes.success({
+                network,
+                prediction: {
+                    address: predictedAddress,
+                    salt: saltBytes,
+                    factory,
+                    initCodeHash,
+                    isDeployed
+                },
+                note: isDeployed
+                    ? "Contract already deployed at this address"
+                    : "Address is available for deployment"
+            });
+        }
+        catch (error) {
+            return helper_js_1.mcpToolRes.error(error, "predicting CREATE2 address");
+        }
+    });
+}
+//# sourceMappingURL=tools.js.map