Learn OpenClaw – Resource Center

Integrating Wallet Connect with OpenClaw: Automate Web3 Payments Using AI Agents

Web3 payments are transforming how applications handle transactions, and combining them with OpenClaw’s AI agent capabilities opens up powerful automation possibilities. In this comprehensive guide, you’ll learn how to integrate Wallet Connect with OpenClaw to automate cryptocurrency payments, NFT transactions, and blockchain interactions.

Why Integrate Wallet Connect with OpenClaw?

OpenClaw AI agents can monitor blockchain events, trigger payment workflows, and automate complex Web3 interactions. By integrating Wallet Connect, your OpenClaw agents can:

  • Automate recurring crypto payments based on schedules or triggers
  • Monitor wallet balances and alert you to changes
  • Process NFT minting and transfers automatically
  • Execute smart contract interactions through agent workflows
  • Handle multi-chain transactions across Ethereum, Polygon, BSC, and more

Unlike traditional payment gateways that require intermediaries, Wallet Connect provides direct, decentralized wallet connections that your OpenClaw agents can leverage programmatically.

Understanding Wallet Connect

Wallet Connect is an open-source protocol that connects decentralized applications (dApps) to mobile wallets using end-to-end encryption. It supports over 170 wallets including MetaMask, Trust Wallet, Coinbase Wallet, and Rainbow.

Key Benefits for OpenClaw Integration

  • Multi-chain support: Ethereum, Polygon, Arbitrum, Optimism, BSC, Avalanche, and more
  • Secure connections: End-to-end encrypted communication between your OpenClaw agent and wallets
  • No private keys: Your OpenClaw agent never handles private keys—transactions are signed in the user’s wallet
  • Real-time events: Listen for wallet connection, disconnection, and transaction events

Setting Up Your OpenClaw Environment for Web3

First, let’s prepare your OpenClaw workspace with the necessary dependencies for Wallet Connect integration.

Install Required Packages

$ cd ~/.openclaw/workspace
$ npm install @walletconnect/sign-client @walletconnect/qrcode-modal ethers@5.7.2

Create Environment Variables

Wallet Connect requires a project ID from WalletConnect Cloud. Create one at cloud.walletconnect.com, then add it to your OpenClaw environment:

$ cat >> ~/.openclaw/workspace/.env.walletconnect << 'EOF'
WALLETCONNECT_PROJECT_ID=your_project_id_here
DEFAULT_CHAIN_ID=1
RPC_URL=https://eth-mainnet.g.alchemy.com/v2/your-api-key
EOF

Note: For testing, use a testnet RPC URL like Goerli or Sepolia.

Building Your First OpenClaw Wallet Connect Integration

Now let's create an OpenClaw skill that connects to a wallet and handles basic transactions.

Create the Wallet Connect Skill

$ mkdir -p ~/.openclaw/workspace/scripts
$ touch ~/.openclaw/workspace/scripts/walletconnect-init.js

Implementation Code

Create the main Wallet Connect integration script:

// walletconnect-init.js
require('dotenv').config({ path: '.env.walletconnect' });
const SignClient = require('@walletconnect/sign-client').default;
const { ethers } = require('ethers');

class OpenClawWalletConnect {
  constructor() {
    this.client = null;
    this.session = null;
    this.accounts = [];
  }

  async initialize() {
    this.client = await SignClient.init({
      projectId: process.env.WALLETCONNECT_PROJECT_ID,
      metadata: {
        name: 'OpenClaw Agent',
        description: 'AI-powered Web3 automation',
        url: 'https://openclaw.ai',
        icons: ['https://openclaw.ai/icon.png']
      }
    });

    console.log('✅ OpenClaw Wallet Connect client initialized');
    
    // Set up event listeners
    this.client.on('session_proposal', this.handleProposal.bind(this));
    this.client.on('session_event', this.handleEvent.bind(this));
    this.client.on('session_delete', this.handleDisconnect.bind(this));
  }

  async connect() {
    const { uri, approval } = await this.client.connect({
      requiredNamespaces: {
        eip155: {
          methods: ['eth_sendTransaction', 'personal_sign'],
          chains: [`eip155:${process.env.DEFAULT_CHAIN_ID}`],
          events: ['chainChanged', 'accountsChanged']
        }
      }
    });

    console.log('🔗 Scan this QR code with your wallet:');
    console.log(uri);

    // Wait for user to approve connection
    this.session = await approval();
    this.accounts = this.session.namespaces.eip155.accounts.map(
      acc => acc.split(':')[2]
    );

    console.log('✅ Connected to wallet:', this.accounts[0]);
    return this.accounts[0];
  }

  async sendTransaction(to, amount) {
    if (!this.session) throw new Error('No active session');

    const tx = {
      from: this.accounts[0],
      to: to,
      value: ethers.utils.parseEther(amount).toHexString(),
      gasLimit: '0x5208'
    };

    const result = await this.client.request({
      topic: this.session.topic,
      chainId: `eip155:${process.env.DEFAULT_CHAIN_ID}`,
      request: {
        method: 'eth_sendTransaction',
        params: [tx]
      }
    });

    console.log('✅ Transaction sent:', result);
    return result;
  }

  handleProposal(proposal) {
    console.log('📨 Session proposal received:', proposal);
  }

  handleEvent(event) {
    console.log('🔔 Wallet event:', event);
  }

  handleDisconnect() {
    console.log('❌ Wallet disconnected');
    this.session = null;
    this.accounts = [];
  }
}

module.exports = OpenClawWalletConnect;

// CLI usage
if (require.main === module) {
  const wc = new OpenClawWalletConnect();
  
  wc.initialize()
    .then(() => wc.connect())
    .then(account => {
      console.log('🎉 OpenClaw is now connected to:', account);
      console.log('Ready to automate Web3 transactions!');
    })
    .catch(err => {
      console.error('❌ Error:', err.message);
      process.exit(1);
    });
}

Test the Connection

Run the script to test your OpenClaw Wallet Connect integration:

$ node scripts/walletconnect-init.js

You'll see a QR code URL printed. Scan it with MetaMask or any compatible wallet to establish the connection.

Creating an OpenClaw Skill for Payment Automation

Now let's create a reusable OpenClaw skill that your agents can use to handle crypto payments.

Skill Structure

$ mkdir -p ~/.openclaw/workspace/skills/web3-payments
$ cd ~/.openclaw/workspace/skills/web3-payments
$ touch SKILL.md execute-payment.js

SKILL.md Documentation

# Web3 Payments Skill

Execute cryptocurrency payments via Wallet Connect.

## Usage

When the user asks to send crypto, pay someone, or transfer tokens:

1. Load recipient address and amount
2. Verify wallet connection status
3. Execute payment via `execute-payment.js`
4. Confirm transaction on blockchain

## Example Commands

- "Send 0.1 ETH to 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
- "Pay 50 USDC to alice.eth"
- "Transfer 1000 tokens to recipient address"

## Environment

Requires `.env.walletconnect` with WALLETCONNECT_PROJECT_ID.

Payment Execution Script

// execute-payment.js
const OpenClawWalletConnect = require('../../scripts/walletconnect-init');

async function executePayment(recipientAddress, amount, token = 'ETH') {
  const wc = new OpenClawWalletConnect();
  
  try {
    await wc.initialize();
    
    // Try to restore existing session first
    const sessions = wc.client.session.getAll();
    if (sessions.length > 0) {
      wc.session = sessions[0];
      wc.accounts = wc.session.namespaces.eip155.accounts.map(
        acc => acc.split(':')[2]
      );
      console.log('✅ Restored wallet session');
    } else {
      // No session found, need to connect
      await wc.connect();
    }

    // Execute the payment
    const txHash = await wc.sendTransaction(recipientAddress, amount.toString());
    
    console.log('💸 Payment sent!');
    console.log('Transaction:', txHash);
    console.log('View on Etherscan:', `https://etherscan.io/tx/${txHash}`);
    
    return {
      success: true,
      txHash,
      amount,
      recipient: recipientAddress
    };
    
  } catch (error) {
    console.error('❌ Payment failed:', error.message);
    return {
      success: false,
      error: error.message
    };
  }
}

// CLI interface for OpenClaw agents
if (require.main === module) {
  const [recipient, amount, token] = process.argv.slice(2);
  
  if (!recipient || !amount) {
    console.error('Usage: node execute-payment.js   [token]');
    process.exit(1);
  }
  
  executePayment(recipient, amount, token)
    .then(result => {
      console.log(JSON.stringify(result, null, 2));
      process.exit(result.success ? 0 : 1);
    });
}

module.exports = executePayment;

Automating Payments with OpenClaw Cron Jobs

One of OpenClaw's most powerful features is the ability to schedule recurring tasks. Let's set up automated crypto payments.

Create a Recurring Payment Schedule

Use OpenClaw's cron system to automate monthly payments:

$ openclaw cron add \
  --name "Monthly DAO Contribution" \
  --schedule "0 0 1 * *" \
  --command "node ~/.openclaw/workspace/skills/web3-payments/execute-payment.js 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb 0.5" \
  --notify

This creates a cron job that sends 0.5 ETH on the 1st of every month and notifies you via your configured OpenClaw channel (Telegram, Discord, etc.).

Monitor Wallet Balances

Create a balance monitoring script that your OpenClaw agents can run:

// monitor-balance.js
const { ethers } = require('ethers');
require('dotenv').config({ path: '.env.walletconnect' });

async function checkBalance(walletAddress) {
  const provider = new ethers.providers.JsonRpcProvider(process.env.RPC_URL);
  const balance = await provider.getBalance(walletAddress);
  const balanceInEth = ethers.utils.formatEther(balance);
  
  console.log(`💰 Balance: ${balanceInEth} ETH`);
  
  // Alert if balance is low
  if (parseFloat(balanceInEth) < 0.1) {
    console.log('⚠️ Low balance alert! Consider topping up.');
  }
  
  return balanceInEth;
}

const walletAddress = process.argv[2];
if (!walletAddress) {
  console.error('Usage: node monitor-balance.js ');
  process.exit(1);
}

checkBalance(walletAddress);

Schedule this as an OpenClaw cron job to get daily balance alerts:

$ openclaw cron add \
  --name "Daily Wallet Balance Check" \
  --schedule "0 9 * * *" \
  --command "node scripts/monitor-balance.js YOUR_WALLET_ADDRESS" \
  --notify

Handling Multiple Chains

OpenClaw can manage transactions across multiple blockchains. Here's how to configure multi-chain support:

Extended Chain Configuration

// chains-config.js
module.exports = {
  ethereum: {
    chainId: 1,
    name: 'Ethereum Mainnet',
    rpc: 'https://eth-mainnet.g.alchemy.com/v2/YOUR-KEY',
    explorer: 'https://etherscan.io'
  },
  polygon: {
    chainId: 137,
    name: 'Polygon',
    rpc: 'https://polygon-rpc.com',
    explorer: 'https://polygonscan.com'
  },
  arbitrum: {
    chainId: 42161,
    name: 'Arbitrum One',
    rpc: 'https://arb1.arbitrum.io/rpc',
    explorer: 'https://arbiscan.io'
  },
  optimism: {
    chainId: 10,
    name: 'Optimism',
    rpc: 'https://mainnet.optimism.io',
    explorer: 'https://optimistic.etherscan.io'
  }
};

Multi-Chain Payment Function

async function sendMultiChainPayment(chain, recipient, amount) {
  const chainConfig = require('./chains-config')[chain];
  
  if (!chainConfig) {
    throw new Error(`Unsupported chain: ${chain}`);
  }
  
  const wc = new OpenClawWalletConnect();
  await wc.initialize();
  
  // Connect with multi-chain support
  const { uri, approval } = await wc.client.connect({
    requiredNamespaces: {
      eip155: {
        methods: ['eth_sendTransaction', 'personal_sign'],
        chains: [`eip155:${chainConfig.chainId}`],
        events: ['chainChanged', 'accountsChanged']
      }
    }
  });
  
  console.log(`🔗 Connect your wallet for ${chainConfig.name}`);
  console.log(uri);
  
  wc.session = await approval();
  
  // Execute transaction on the specified chain
  const result = await wc.client.request({
    topic: wc.session.topic,
    chainId: `eip155:${chainConfig.chainId}`,
    request: {
      method: 'eth_sendTransaction',
      params: [{
        from: wc.accounts[0],
        to: recipient,
        value: ethers.utils.parseEther(amount).toHexString()
      }]
    }
  });
  
  console.log(`✅ Transaction sent on ${chainConfig.name}`);
  console.log(`${chainConfig.explorer}/tx/${result}`);
  
  return result;
}

Testing on Testnets

Before going live with mainnet transactions, always test your OpenClaw Web3 integrations on testnets.

Configure Testnet Environment

$ cat >> .env.walletconnect.testnet << 'EOF'
WALLETCONNECT_PROJECT_ID=your_project_id
DEFAULT_CHAIN_ID=5
RPC_URL=https://eth-goerli.g.alchemy.com/v2/your-api-key
NETWORK=goerli
EOF

Get Testnet Tokens

Use these faucets to get free testnet tokens for testing your OpenClaw integrations:

Run Test Transactions

$ export $(cat .env.walletconnect.testnet | xargs)
$ node scripts/execute-payment.js 0xYourTestAddress 0.01

Error Handling and Best Practices

When building production-ready OpenClaw Web3 integrations, implement robust error handling:

Common Issues and Solutions

  • Connection timeout: Wallet Connect sessions expire after 7 days. Implement session restoration logic.
  • Transaction failures: Always check gas estimates before submitting transactions.
  • Network congestion: Implement retry logic with exponential backoff for failed transactions.
  • User rejection: Handle cases where users decline transaction signing.

Enhanced Error Handling

async function safeExecutePayment(recipient, amount, maxRetries = 3) {
  let attempt = 0;
  
  while (attempt < maxRetries) {
    try {
      const result = await executePayment(recipient, amount);
      return result;
      
    } catch (error) {
      attempt++;
      
      if (error.message.includes('user rejected')) {
        console.log('❌ User rejected the transaction');
        return { success: false, reason: 'user_rejected' };
      }
      
      if (error.message.includes('insufficient funds')) {
        console.log('❌ Insufficient balance');
        return { success: false, reason: 'insufficient_funds' };
      }
      
      if (attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`⏳ Retrying in ${delay}ms (attempt ${attempt}/${maxRetries})`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
}

Advanced Use Cases for OpenClaw Web3 Automation

Now that you have the basics working, here are some advanced automation scenarios:

1. NFT Minting Automation

Create an OpenClaw agent that monitors your website for NFT mint requests and executes them automatically:

async function mintNFT(contractAddress, recipientAddress) {
  const abi = ['function mint(address to) public payable'];
  const contract = new ethers.Contract(contractAddress, abi);
  
  const data = contract.interface.encodeFunctionData('mint', [recipientAddress]);
  
  const tx = {
    from: wc.accounts[0],
    to: contractAddress,
    data: data,
    value: ethers.utils.parseEther('0.01').toHexString()
  };
  
  const result = await wc.client.request({
    topic: wc.session.topic,
    chainId: 'eip155:1',
    request: {
      method: 'eth_sendTransaction',
      params: [tx]
    }
  });
  
  console.log('🎨 NFT minted! Transaction:', result);
  return result;
}

2. DAO Voting Automation

Automatically vote on DAO proposals based on predefined rules:

$ openclaw cron add \
  --name "Auto-vote on DAO proposals" \
  --schedule "0 */6 * * *" \
  --command "node scripts/dao-vote-checker.js" \
  --notify

3. Token Swap Automation

Monitor token prices and execute swaps when conditions are met using DEX aggregators like 1inch or Uniswap:

// Price monitoring with OpenClaw agents
async function checkAndSwap(fromToken, toToken, targetPrice) {
  const currentPrice = await fetchTokenPrice(fromToken, toToken);
  
  if (currentPrice <= targetPrice) {
    console.log(`💹 Price target met! Executing swap...`);
    await executeSwap(fromToken, toToken, '1000');
  } else {
    console.log(`⏳ Waiting for better price. Current: ${currentPrice}, Target: ${targetPrice}`);
  }
}

Security Considerations

When integrating Wallet Connect with OpenClaw agents, keep these security practices in mind:

  • Never store private keys: Wallet Connect's design ensures your OpenClaw agent never has access to private keys
  • Use environment variables: Store API keys and project IDs in .env files, never in code
  • Implement spending limits: Add checks to prevent agents from executing unexpectedly large transactions
  • Enable transaction confirmations: For critical operations, require manual approval before execution
  • Monitor sessions: Implement session expiry notifications and automatic disconnection after periods of inactivity
  • Use testnet first: Always validate new OpenClaw automation workflows on testnets before mainnet deployment

Implementing Spending Limits

const DAILY_LIMIT = ethers.utils.parseEther('1.0'); // 1 ETH
let dailySpent = ethers.BigNumber.from(0);

async function executeWithLimit(recipient, amount) {
  const amountBN = ethers.utils.parseEther(amount);
  
  if (dailySpent.add(amountBN).gt(DAILY_LIMIT)) {
    throw new Error('Daily spending limit exceeded. Manual approval required.');
  }
  
  const result = await executePayment(recipient, amount);
  dailySpent = dailySpent.add(amountBN);
  
  return result;
}

Troubleshooting Common Issues

Connection Drops

If your OpenClaw agent loses connection to the wallet:

// Check session validity
async function ensureConnected() {
  const sessions = wc.client.session.getAll();
  
  if (sessions.length === 0) {
    console.log('⚠️ No active sessions. Reconnecting...');
    await wc.connect();
  } else {
    wc.session = sessions[0];
    console.log('✅ Session restored');
  }
}

Gas Estimation Failures

Always estimate gas before submitting transactions:

const provider = new ethers.providers.JsonRpcProvider(process.env.RPC_URL);

async function estimateGas(tx) {
  try {
    const gasEstimate = await provider.estimateGas(tx);
    console.log(`⛽ Gas estimate: ${gasEstimate.toString()}`);
    return gasEstimate;
  } catch (error) {
    console.error('❌ Gas estimation failed:', error.message);
    throw new Error('Transaction would likely fail. Aborting.');
  }
}

Next Steps

You now have a complete OpenClaw Web3 integration with Wallet Connect! Here are some ways to extend this foundation:

  • Add ENS support: Allow your agents to resolve human-readable ENS names to addresses
  • Implement multi-sig wallets: Integrate with Gnosis Safe for added security
  • Build DeFi integrations: Connect to Aave, Compound, or other DeFi protocols
  • Create custom alerts: Use OpenClaw's messaging tools to send transaction notifications via Telegram, Discord, or Slack
  • Monitor blockchain events: Set up event listeners for specific smart contract activities

Resources

Conclusion

Integrating Wallet Connect with OpenClaw unlocks powerful Web3 automation capabilities. Your AI agents can now handle cryptocurrency payments, interact with smart contracts, and manage blockchain operations—all while maintaining security through decentralized wallet connections.

Whether you're automating DAO contributions, monitoring wallet balances, or building complex DeFi workflows, OpenClaw's agent system combined with Wallet Connect provides the foundation for sophisticated Web3 automation.

Start experimenting with testnets, build custom OpenClaw skills for your specific use cases, and join the OpenClaw community to share your Web3 automation workflows!

Posted in:

Want to learn more about OpenClaw? 🦞

Join our community to get access to free support and special programs!

🎉

Welcome to the OpenClaw Community!

Check your email for next steps.