Layerzero MCP

🚀 LayerZero OFT MCP Server

The LayerZero OFT MCP is a TypeScript/Node.js Model Context Protocol (MCP) server that simplifies the creation, deployment, and bridging of Omnichain Fungible Tokens (OFTs) across multiple blockchains.

This MCP abstracts the complexity of omnichain token creation and cross-chain interactions by providing a structured, context-aware layer for initiating, managing, and bridging OFTs. It is designed for easy integration with LLM agents, bots, or applications that require secure and reliable access to decentralized cross-chain functionality.

🚀 Quick Start

LayerZero OFT MCP is a TypeScript/Node.js Model Context Protocol (MCP) server. It enables the creation, deployment, and bridging of Omnichain Fungible Tokens (OFTs) across multiple blockchains. Interactions are mainly managed via ethers.js, relying on LayerZero contracts and protocols for cross - chain communication.

✨ Features

Deterministic Cross - Chain Contract Addressing

The MCP uses Solidity's CREATE2 opcode to deploy OFT contracts at the same address on every chain. The address is derived from the bytecode and a fixed salt, which currently includes the token name and symbol. Ensure you use unique identifiers during deployment because you cannot create the same token (same name and symbol) twice using the same factory.

This is a working starting point. You can bring your own OFT contract and expand it with custom features or token logic. The system is open and extendable by design.

Exposed Interaction Tools

This MCP server provides the following tools for interaction:

1. deploy - and - configure - oft - multichain

• Description: Deploys an Omnichain Fungible Token (OFT) contract to one or more specified LayerZero - supported chains. After successful deployments, it configures each new OFT contract to be a peer with all other newly deployed OFTs in the set. It also sets standard enforced options (e.g., for gas limits) on each contract to enable cross - chain transfers to its peers.
• Parameters:
  • tokenName (string): Name of the token (e.g., "MyToken").
  • tokenSymbol (string): Symbol of the token (e.g., "MYT").
  • initialTotalSupply (string): Total supply of the token in human - readable format (e.g., "1000000"). This will be parsed using the decimals value.
  • decimals (number, Optional, default: 18): Number of decimals for the token.
  • targetChains (array of strings): List of chain names (from the configured NETWORKS in utils.ts, e.g., ["Arbitrum sepolia", "baseSepolia"]) to deploy and configure the OFT on. Must select at least one. For peering to occur, at least two chains must be specified and result in successful deployments.
  • owner (string, Optional): The Ethereum address to be the owner of the deployed contracts. If not provided, defaults to the OWNER_ADDRESS set in the .env file.
• Output: Details the success or failure of deployments on each target chain, peering status between them, and the status of setting enforced options.

2. bridge - oft

• Description: Bridges OFT tokens from one chain to another using LayerZero.
• Parameters:
  • tokenAddress (string): The address of the OFT contract on the source chain.
  • amount (string): The amount of tokens to bridge (e.g., "100"). This is parsed assuming 18 decimals; ensure your token uses this or modify the tool if necessary.
  • fromChain (string): The source chain name (e.g., "Arbitrum sepolia").
  • toChain (string): The destination chain name (e.g., "baseSepolia").
  • receiverAddress (string): The address to receive tokens on the destination chain.
  • extraOptions (string, optional, default: "0x"): Extra options for LayerZero message execution.
• Output: Details of the bridging transaction, including the transaction hash.

📦 Installation

Prerequisites

• Node.js (v16 or higher recommended)
• npm or yarn
• Access to an LLM or application that can communicate via the Model Context Protocol (e.g., Claude for Desktop).

Steps

1. Clone the repository:

   git clone https://github.com/your - username/layerzero - oft - mcp.git
   cd layerzero - oft - mcp
   

2. Install dependencies:

   npm install
   # or
   yarn install
   

3. Create a .env file: Copy the .env.example (if provided) or create a new .env file in the root of the project and populate it with your details:

   PRIVATE_KEY="your_hex_encoded_private_key_here"
   OWNER_ADDRESS="your_owner_ethereum_address_here"
   ARBITRUM_SEPOLIA_RPC_URL="your_Arbitrum sepolia_testnet_rpc_url_here"
   BASE_SEPOLIA_RPC_URL="your_base_sepolia_testnet_rpc_url_here"
   ARBITRUM_FACTORY_ADDRESS="0x754a2643Ce68e0e34510B1E246254f93946AE3a1"
   BASE_FACTORY_ADDRESS="0x754a2643Ce68e0e34510B1E246254f93946AE3a1"
   
   # Add other RPC URL env variables if you configure more networks in utils.ts
   

   Security Note: Never commit your .env file containing private keys to a public repository.

4. Update ABI and Bytecode: As mentioned in the "IMPORTANT" section above, open layerzero - mcp.ts and replace OFT_ABI and OFT_BYTECODE placeholders with your actual contract details.

5. Build the project (if using TypeScript compilation):

   npm run build
   # or
   yarn run build
   

   (This command assumes you have a build script in your package.json that compiles TypeScript to JavaScript, e.g., tsc)

Configure the MCP for Claude for Desktop (Example)

Add the MCP configuration to your Claude for Desktop configuration file (typically found at C:\Users\{User}\AppData\Roaming\Claude\claude_desktop_config.json on Windows):

{
    "layerzero - oft - mcp": {
        "command": "node",
        "args": [
            "<PROJECT_ABSOLUTE_FILEPATH>/build/index.js"
        ],
        "env": {
            "PRIVATE_KEY": "your_hex_encoded_private_key_here",
            "OWNER_ADDRESS": "your_owner_ethereum_address_here",
            "ARBITRUM_SEPOLIA_RPC_URL": "your_Arbitrum_sepolia_testnet_rpc_url_here",
            "BASE_SEPOLIA_RPC_URL": "your_base_sepolia_testnet_rpc_url_here",
            "ARBITRUM_FACTORY_ADDRESS": "0x754a2643Ce68e0e34510B1E246254f93946AE3a1",
            "BASE_FACTORY_ADDRESS": "0x754a2643Ce68e0e34510B1E246254f93946AE3a1"
        }
    }
}

• Replace <PROJECT_ABSOLUTE_FILEPATH> with the actual absolute path to your project directory.
• Ensure the env variables here match those required by your server, or that they are correctly picked up from your .env file if your Node.js setup loads them (the dotenv.config() call in the scripts should handle this). For Claude Desktop, explicitly setting them in claude_desktop_config.json is required.

Follow the official MCP guide for more details on testing with Claude for Desktop.

💻 Usage Examples

Running the Application

Once configured (including ABI/Bytecode and environment variables), the MCP server will be launched by the host application (e.g., Claude for Desktop) when needed.

Example Usage

You can interact with it using natural language prompts if using an LLM. For example:

To deploy and configure a new OFT:

"Deploy a new OFT named 'OmniCoin' (OMC) with a total supply of 500,000 tokens across both Arbitrum sepolia and Base Sepolia testnets." This will use the deploy - and - configure - oft - multichain tool.

To bridge existing OFT tokens:

"Bridge 50 MyOFT from Arbitrum sepolia to Base Sepolia to address 0x123...abc. The token is deployed at 0xabc...123 on Arbitrum sepolia." This will use the bridge - oft tool.

⚠️ Important Note

Ensure you have sufficient gas tokens (e.g., testnet ETH or MATIC) on the respective chains for the account associated with your PRIVATE_KEY to cover deployment and bridging transaction fees.

📚 Documentation

IMPORTANT: Configure ABI and Bytecode

Before running the server, you MUST replace these paths with the absolute path to your contract artifacts:

// --- index.ts ---
// Replace these paths with the actual ABI and Bytecode JSON file of your OFT contract (e.g., from MyOFT.sol)
const oftPath = resolve(
  "D:\\Dev\\layerzero - mcp\\artifacts\\MyOFT\\MyOFT.json"
);
// Same here for the factory contract
// This should point to the CREATE2Factory ABI and Bytecode JSON file
const factoryPath = resolve(
  "D:\\Dev\\layerzero - mcp\\artifacts\\factory\\CREATE2Factory.json"
);
// --- --- ---

Failure to do so will result in errors when attempting to use the deploy - and - configure - oft - multichain tool. The bridge - oft tool also requires the OFT_ABI to be correctly set for interacting with existing contracts.

🖼️ Example Screenshots

Deploying an OFT

Bridging an OFT