Back to Blog

AI and MCP / D02

Предоставьте вашему AI-агенту кошелек TRON

Why AI Agents Need On-Chain Access

The conversation about AI agents has moved beyond chatbots and code assistants. The next frontier is agents that can act autonomously on blockchain networks - checking balances, sending transactions, buying resources, and managing portfolios without human intervention at every step.

TRON is the backbone of stablecoin transfers. Over 50 billion USDT moves on TRON daily, and the network's resource model - energy and bandwidth instead of gas fees - makes it uniquely suited for high-frequency, low-cost operations. But connecting an AI agent to TRON has historically required building custom integrations, managing RPC endpoints, handling resource estimation, and dealing with the complexities of TronWeb.

MERX solves this with a single MCP server that gives any compatible AI agent - Claude, Cursor, or any Model Context Protocol client - a full-featured TRON wallet and resource exchange in one integration.

This article walks through the setup, from zero to an autonomous agent that holds keys, checks balances, and buys energy on TRON mainnet.

Что такое MCP и почему это важно

The Model Context Protocol (MCP) is an open standard created by Anthropic that lets AI models interact with external tools, data sources, and services through a unified interface. Think of it as a USB port for AI - any MCP-compatible client can connect to any MCP server without custom integration code.

An MCP server exposes three primitives:

MERX implements all three primitives with 21 tools, 30 prompts, and 21 resources. No other blockchain MCP server offers this level of coverage.

Установка

The MERX MCP server is published as a standard npm package. Install it globally or use npx to run it directly:

npm install -g merx-mcp

Or add it to your MCP client configuration. For Claude Desktop, edit claude_desktop_config.json:

{
  "mcpServers": {
    "merx": {
      "command": "npx",
      "args": ["-y", "merx-mcp"],
      "env": {
        "MERX_NETWORK": "mainnet"
      }
    }
  }
}

For Cursor, the configuration goes into your project's .cursor/mcp.json:

{
  "mcpServers": {
    "merx": {
      "command": "npx",
      "args": ["-y", "merx-mcp"]
    }
  }
}

That is the entire setup. No API keys. No registration. No OAuth flows.

Настройка кошелька

The first thing your agent needs is a TRON address. MERX provides the set_private_key tool, which accepts a hex-encoded private key and automatically derives the corresponding TRON address.

Tool: set_private_key
Input: { "private_key": "your_64_char_hex_private_key" }

Response:
{
  "address": "TYourDerivedTronAddress...",
  "network": "mainnet",
  "status": "ready"
}

The private key never leaves the local machine. It is stored in the MCP server's runtime memory for the duration of the session and is used exclusively to sign transactions locally before broadcasting. MERX servers never see your private key - all signing happens client-side.

Generating a Fresh Wallet

If you need a new wallet for your agent, you can generate one using any TRON-compatible tool. The agent itself can create one using standard cryptographic libraries:

const TronWeb = require('tronweb');
const account = TronWeb.utils.accounts.generateAccount();
console.log('Address:', account.address.base58);
console.log('Private Key:', account.privateKey);

Fund the address with a small amount of TRX for activation and basic operations, then pass the private key to set_private_key.

Основные операции кошелька

Once the wallet is configured, the agent has access to a complete suite of on-chain operations.

Checking Balances

Tool: get_trx_balance
Input: { "address": "TYourAddress..." }

Response:
{
  "balance": 1523.456789,
  "balance_sun": 1523456789
}

For TRC20 tokens:

Tool: get_trc20_balance
Input: {
  "address": "TYourAddress...",
  "contract_address": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"
}

Response:
{
  "balance": "2500.00",
  "token": "USDT",
  "decimals": 6
}

Sending TRX

Tool: transfer_trx
Input: {
  "to": "TRecipientAddress...",
  "amount_trx": 100
}

The agent signs the transaction locally and broadcasts it to the TRON network. The tool returns the transaction hash for on-chain verification.

Sending TRC20 Tokens

Tool: transfer_trc20
Input: {
  "to": "TRecipientAddress...",
  "contract_address": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
  "amount": "500"
}

TRC20 transfers consume energy. This is where MERX shines - the agent can automatically estimate, purchase, and delegate energy before executing the transfer, reducing the cost from approximately 27 TRX (burned) to under 4 TRX (delegated energy).

Buying Energy - The Core Value Proposition

TRON's resource model means every smart contract interaction costs energy. A simple USDT transfer requires approximately 65,000 energy. A SunSwap trade can consume over 200,000 energy. Without delegated energy, these costs are paid by burning TRX at current network rates.

MERX aggregates energy from multiple providers and gives the agent a single tool to purchase it:

Tool: create_order
Input: {
  "energy_amount": 65000,
  "duration_hours": 1,
  "target_address": "TYourAddress..."
}

The agent can also check current market prices before purchasing:

Tool: get_best_price
Input: {
  "energy_amount": 65000,
  "duration_hours": 1
}

Response:
{
  "best_price": 3.42,
  "provider": "sohu",
  "price_per_unit": 0.0000526
}

The ensure_resources Tool

For agents that want to focus on intent rather than mechanics, ensure_resources is the high-level tool that handles everything:

Tool: ensure_resources
Input: {
  "address": "TYourAddress...",
  "energy_needed": 65000,
  "bandwidth_needed": 350
}

This tool checks what the address already has, calculates the deficit, purchases only what is needed, and waits for delegation to arrive before returning. The agent does not need to understand energy markets, provider APIs, or delegation mechanics.

The Zero-Registration Path with x402

MERX offers a path that requires no account creation at all. The x402 protocol enables pay-per-use energy purchases where payment is verified on-chain.

The flow works like this:

  1. The agent calls create_paid_order to get an invoice
  2. The invoice specifies an exact TRX amount and a memo string
  3. The agent signs and broadcasts the payment transaction using its local wallet
  4. MERX verifies the payment on-chain using the memo as a correlation key
  5. Energy is delegated to the target address
Tool: create_paid_order
Input: {
  "energy_amount": 65000,
  "duration_hours": 1,
  "target_address": "TYourAddress..."
}

Response:
{
  "invoice": {
    "amount_trx": 1.43,
    "pay_to": "TMerxTreasuryAddress...",
    "memo": "merx_ord_abc123",
    "expires_at": "2026-03-30T12:05:00Z"
  }
}

The agent then sends TRX with the specified memo, and the order is fulfilled. No API key. No email. No signup form. Pure on-chain commerce between an autonomous agent and a service.

A Real Autonomous Agent Flow

Here is a complete example of what an autonomous agent session looks like when connected to MERX:

Step 1: Agent configures its wallet

The agent loads its private key from a secure environment variable and calls set_private_key. MERX derives the TRON address and confirms the wallet is ready.

Step 2: Agent checks its financial position

The agent calls get_trx_balance and get_trc20_balance for USDT. It now knows it has 500 TRX and 2,000 USDT.

Step 3: Agent receives a task - "Send 100 USDT to this address"

The agent calls check_address_resources to see what energy and bandwidth are available. It finds 0 energy delegated.

Step 4: Agent estimates the cost

The agent calls estimate_transaction_cost for a USDT transfer. The response shows 65,000 energy needed. Without energy, this would burn approximately 27 TRX. With energy purchase, the cost is approximately 3.5 TRX.

Step 5: Agent buys energy

The agent calls ensure_resources with the energy requirement. MERX finds the cheapest provider, places the order, and waits for delegation to arrive.

Step 6: Agent executes the transfer

With energy now delegated, the agent calls transfer_trc20 to send 100 USDT. The transaction consumes the delegated energy instead of burning TRX.

Step 7: Agent verifies the result

The agent calls get_transaction with the transaction hash to confirm success.

Total cost: approximately 3.5 TRX instead of 27 TRX. The agent saved 87% on fees without any human intervention.

Вопросы безопасности

Private Key Management

The private key exists only in the MCP server's runtime memory. It is never transmitted to MERX servers, never written to disk by the MCP server, and never included in API calls. All transaction signing happens locally.

For production deployments, store the private key in your infrastructure's secret management system (AWS Secrets Manager, HashiCorp Vault, or environment variables in a secure runtime) and pass it to the MCP server at startup.

Transaction Limits

For autonomous agents, consider implementing guardrails:

Network Selection

MERX supports both mainnet and Shasta testnet. Always test new agent workflows on Shasta first:

{
  "env": {
    "MERX_NETWORK": "shasta"
  }
}

Switch to mainnet only after validating the complete flow.

За пределами базовых операций кошелька

Once your agent has a wallet, the MERX MCP server unlocks capabilities far beyond simple transfers:

Each of these capabilities is exposed as a tool the agent can call, with prompts that guide the agent through complex workflows and resources that provide real-time market data.

Начало работы сегодня

The fastest path from zero to a working agent wallet:

  1. Install the MCP server: npm install -g merx-mcp
  2. Configure your MCP client (Claude Desktop, Cursor, or any MCP-compatible tool)
  3. Generate or import a TRON private key
  4. Call set_private_key to activate the wallet
  5. Call get_trx_balance to verify connectivity

The entire setup takes under five minutes. No registration, no API keys, no approval process.

MERX is the bridge between AI agents and the TRON blockchain. The MCP server is open source, the protocol is standardized, and the energy market is live.

Your agent is ready for a wallet. Give it one.

Ссылки:

All Articles