OpenClaw Integration

Integrate Molt402 with the OpenClaw agent framework to enable autonomous transaction execution.

Overview

OpenClaw is an agent framework that provides reasoning, planning, and execution capabilities for AI systems. Molt402 extends OpenClaw with transaction execution primitives, allowing agents to interact with the x402 protocol autonomously.

Installation

Install both OpenClaw and the Molt402 provider:

pip install openclaw molt402-python

Basic setup

Configure the provider

from openclaw import Agent
from molt402 import X402TransactionProvider

# Initialize Molt402 provider
provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/wallet.json",
    policies_path="~/.molt402/policies.yaml"
)

# Create agent with provider
agent = Agent(
    name="defi_executor",
    providers=[provider]
)

Execute your first transaction

# Agent automatically uses Molt402 for transaction execution
result = agent.run("""
Transfer 50 USDC to 0xabcd...ef01 using fast priority.
""")

print(f"Transaction hash: {result.tx_hash}")
print(f"Status: {result.status}")

Provider configuration

Wallet management

Private key:

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet={
        "type": "private_key",
        "key": os.getenv("AGENT_PRIVATE_KEY")
    }
)

HD wallet:

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet={
        "type": "hd_wallet",
        "mnemonic": os.getenv("MNEMONIC"),
        "derivation_path": "m/44'/60'/0'/0/0"
    }
)

Hardware wallet:

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet={
        "type": "hardware",
        "device": "ledger",
        "derivation_path": "m/44'/60'/0'/0/0"
    }
)

Network selection

# Mainnet
provider = X402TransactionProvider(network="x402-mainnet")

# Testnet
provider = X402TransactionProvider(network="x402-testnet")

# Custom RPC
provider = X402TransactionProvider(
    network="x402-mainnet",
    rpc_url="https://custom-rpc.x402.network"
)

Approval policies

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/wallet.json",
    policies_path="~/.molt402/policies.yaml",  # YAML policy file
    # Or inline policies
    policies={
        "policies": [
            {
                "name": "auto_approve_small",
                "conditions": {
                    "max_value_usd": 100
                },
                "action": "auto_approve"
            }
        ]
    }
)

Agent capabilities

Natural language transactions

The agent can execute transactions from natural language instructions:

# Simple transfer
agent.run("Send 25 USDC to 0x1234...5678")

# Swap operation
agent.run("Swap 100 USDC for WETH with maximum 0.5% slippage")

# Contract interaction
agent.run("Approve USDC spending for Uniswap router contract")

# Batch operation
agent.run("""
Transfer 10 USDC to Alice at 0xaaaa...aaaa,
15 USDC to Bob at 0xbbbb...bbbb,
and 20 USDC to Carol at 0xcccc...cccc
""")

Conditional execution

Execute transactions based on conditions:

agent.run("""
Monitor USDC balance every 5 minutes.
When balance exceeds 1000 USDC, transfer 50% to savings vault at 0x1234...5678.
Use economy gas pricing.
""")

State-based decisions

Agents can query blockchain state and make decisions:

agent.run("""
Check if ETH price is above $3500 on Uniswap.
If yes, swap 1 ETH for USDC.
Use fast priority and require human approval for amounts >$1000.
""")

Advanced patterns

Treasury management

from openclaw import Agent
from molt402 import X402TransactionProvider

# Configure provider with policies
provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/treasury.json",
    policies_path="~/.molt402/treasury-policies.yaml"
)

agent = Agent(
    name="treasury_manager",
    providers=[provider],
    description="""
    Manages protocol treasury funds with the following responsibilities:
    1. Maintain target asset allocations (60% stablecoins, 30% ETH, 10% governance tokens)
    2. Rebalance when allocations drift >5% from targets
    3. Distribute monthly contributor payments on the 1st of each month
    4. Execute buybacks when token price falls below $0.50
    """
)

# Run autonomous treasury management
agent.run("""
Analyze current treasury holdings and rebalance if needed.
Check if it's time for monthly contributor payments.
Monitor token price and execute buybacks if conditions are met.
""")

Arbitrage bot

from openclaw import Agent
from molt402 import X402TransactionProvider

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/arbitrage.json",
    mev_protection=True  # Enable MEV protection
)

agent = Agent(
    name="arbitrage_bot",
    providers=[provider],
    description="""
    Monitors price discrepancies across DEXes and executes arbitrage when profitable.
    Requires >$50 profit after gas costs to execute.
    """
)

agent.run("""
Monitor USDC/WETH price on Uniswap and SushiSwap every 10 seconds.
When spread exceeds 0.3% and estimated profit >$50:
1. Calculate optimal arbitrage size
2. Execute atomic swap via flash loan
3. Use instant priority for time-sensitive execution
""")

Conditional staking

agent.run("""
Monitor ETH balance daily at 9am UTC.
When balance >5 ETH:
1. Check current staking APR
2. If APR >4%, stake 2 ETH to Lido
3. Use economy priority for cost efficiency
4. Require human approval for staking operations
""")

Event-driven workflows

Listen for blockchain events

from openclaw import Agent
from molt402 import X402TransactionProvider, EventListener

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/wallet.json"
)

# Configure event listener
event_listener = EventListener(
    provider=provider,
    events=[
        {
            "contract": "0x1234...5678",  # Governance contract
            "event": "ProposalCreated",
            "handler": "handle_proposal"
        }
    ]
)

agent = Agent(
    name="governance_bot",
    providers=[provider],
    event_listeners=[event_listener]
)

# Define event handler
def handle_proposal(event):
    agent.run(f"""
    New governance proposal detected: {event.proposal_id}

    1. Analyze proposal description and code changes
    2. Check voting power and quorum requirements
    3. If proposal aligns with community temperature check:
       - Vote 'yes' with all available voting power
    4. Otherwise vote 'no' or abstain

    Use standard priority and notify governance team.
    """)

# Run agent with event listening
agent.listen()

Webhook integration

from flask import Flask, request
from openclaw import Agent
from molt402 import X402TransactionProvider

app = Flask(__name__)

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/wallet.json"
)

agent = Agent(
    name="webhook_responder",
    providers=[provider]
)

@app.route('/webhook/payment', methods=['POST'])
def handle_payment_webhook():
    data = request.json

    # Execute transaction based on webhook data
    result = agent.run(f"""
    Received payment webhook for order {data['order_id']}.
    Transfer {data['amount']} USDC to merchant at {data['recipient_address']}.
    Use fast priority for user-facing operation.
    """)

    return {"tx_hash": result.tx_hash, "status": result.status}

app.run(port=5000)

Error handling

Automatic retries

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/wallet.json",
    retry_config={
        "enabled": True,
        "max_retries": 3,
        "backoff": "exponential",  # or "linear"
        "retry_on": ["timeout", "network_error", "gas_too_low"]
    }
)

Custom error handlers

from openclaw import Agent
from molt402 import X402TransactionProvider, TransactionError

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/wallet.json"
)

agent = Agent(
    name="error_handler_example",
    providers=[provider]
)

try:
    result = agent.run("Transfer 100 USDC to 0x1234...5678")
except TransactionError as e:
    if e.code == "insufficient_funds":
        print(f"Insufficient balance. Need {e.required}, have {e.available}")
    elif e.code == "simulation_failed":
        print(f"Transaction would fail: {e.reason}")
    elif e.code == "policy_rejected":
        print(f"Rejected by policy: {e.policy_name}")
    else:
        print(f"Transaction error: {e.message}")

Testing

Testnet deployment

# Use testnet for development
provider = X402TransactionProvider(
    network="x402-testnet",
    wallet_path="~/.molt402/testnet-wallet.json"
)

agent = Agent(
    name="test_agent",
    providers=[provider]
)

# Execute test transactions
result = agent.run("Transfer 10 TEST tokens to 0x1234...5678")

Dry-run mode

# Simulate without actual execution
provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/wallet.json",
    dry_run=True  # Simulate only, don't submit
)

agent = Agent(
    name="dry_run_test",
    providers=[provider]
)

# Will simulate but not execute
result = agent.run("Swap 1000 USDC for WETH")
print(f"Simulation result: {result.simulation}")

Unit testing

import unittest
from unittest.mock import Mock
from openclaw import Agent
from molt402 import X402TransactionProvider

class TestAgentTransactions(unittest.TestCase):
    def setUp(self):
        # Mock provider for testing
        self.provider = Mock(spec=X402TransactionProvider)
        self.agent = Agent(
            name="test_agent",
            providers=[self.provider]
        )

    def test_transfer(self):
        # Mock successful transaction
        self.provider.execute.return_value = {
            "tx_hash": "0xabc123...",
            "status": "confirmed"
        }

        result = self.agent.run("Transfer 10 USDC to 0x1234...5678")

        self.assertEqual(result.status, "confirmed")
        self.provider.execute.assert_called_once()

Monitoring

Agent metrics

from openclaw import Agent
from molt402 import X402TransactionProvider

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/wallet.json",
    metrics={
        "enabled": True,
        "export": "prometheus",  # or "cloudwatch", "datadog"
        "port": 9090
    }
)

agent = Agent(
    name="monitored_agent",
    providers=[provider]
)

# Metrics automatically exported:
# - molt402_transactions_total
# - molt402_transactions_failed
# - molt402_gas_spent_total
# - molt402_confirmation_time_seconds

Logging

import logging
from openclaw import Agent
from molt402 import X402TransactionProvider

# Configure logging
logging.basicConfig(level=logging.INFO)

provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/wallet.json",
    logging={
        "level": "info",  # or "debug"
        "format": "json",
        "destination": "file",
        "path": "/var/log/molt402/agent.log"
    }
)

agent = Agent(
    name="logged_agent",
    providers=[provider]
)

Production deployment

Docker container

FROM python:3.11-slim

WORKDIR /app

# Install dependencies
RUN pip install openclaw molt402-python

# Copy agent code
COPY agent.py .
COPY policies.yaml .

# Run agent
CMD ["python", "agent.py"]

Kubernetes deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: molt402-agent
spec:
  replicas: 1
  selector:
    matchLabels:
      app: molt402-agent
  template:
    metadata:
      labels:
        app: molt402-agent
    spec:
      containers:
      - name: agent
        image: your-registry/molt402-agent:latest
        env:
        - name: AGENT_PRIVATE_KEY
          valueFrom:
            secretKeyRef:
              name: molt402-secrets
              key: private-key
        - name: MOLT402_NETWORK
          value: "x402-mainnet"
        volumeMounts:
        - name: policies
          mountPath: /app/policies.yaml
          subPath: policies.yaml
      volumes:
      - name: policies
        configMap:
          name: molt402-policies

Systemd service

[Unit]
Description=Molt402 Agent
After=network.target

[Service]
Type=simple
User=molt402
WorkingDirectory=/opt/molt402
ExecStart=/usr/bin/python3 /opt/molt402/agent.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Examples

Complete treasury manager

from openclaw import Agent
from molt402 import X402TransactionProvider
import schedule
import time

# Configure provider
provider = X402TransactionProvider(
    network="x402-mainnet",
    wallet_path="~/.molt402/treasury.json",
    policies_path="~/.molt402/treasury-policies.yaml",
    mev_protection=True
)

# Create agent
agent = Agent(
    name="treasury_manager",
    providers=[provider],
    description="Manages protocol treasury with automated rebalancing and payments"
)

# Define scheduled tasks
def rebalance_portfolio():
    agent.run("""
    Check current asset allocations in treasury:
    - Target: 60% stablecoins, 30% ETH, 10% governance tokens
    - If any allocation drifts >5%, rebalance to targets
    - Use economy priority for cost efficiency
    - Batch all rebalancing trades into single transaction
    """)

def process_monthly_payments():
    agent.run("""
    It's the 1st of the month. Process contributor payments:
    - Load payment schedule from treasury_payments.json
    - Verify sufficient USDC balance for all payments
    - Execute batch transfer to all recipients
    - Use fast priority for timely delivery
    - Notify finance team when complete
    """)

def monitor_token_price():
    agent.run("""
    Check current token price on Uniswap.
    If price <$0.50:
    - Calculate buyback amount (2% of treasury USDC)
    - Execute buyback using instant priority
    - Notify team of buyback execution
    """)

# Schedule tasks
schedule.every().hour.do(rebalance_portfolio)
schedule.every().day.at("09:00").do(process_monthly_payments)
schedule.every(15).minutes.do(monitor_token_price)

# Run agent
while True:
    schedule.run_pending()
    time.sleep(60)

Next steps

• Approval policies: Configure transaction permissions

• Gas optimization: Reduce transaction costs

• Monitoring and alerts: Production observability

• Security best practices: Secure your deployment

Resources

• OpenClaw documentation: docs.openclaw.ai

• Example agents: github.com/molt402-dev/examples

• Discord: discord.gg/molt402

• Support: [email protected]