22 min read

Overview

Copytrading allows you to automatically mirror the trades of successful traders by monitoring their onchain transactions and executing similar trades in real-time. In this guide, you'll build a copytrading bot that monitors token purchases on the four.meme platform (BNB Chain's popular memecoin launchpad) and automatically executes proportional trades when your target wallet makes a purchase.

By leveraging QuickNode's Webhooks, you'll receive instant notifications of onchain events, enabling your bot to react within seconds of a tracked wallet's trade.

What You Will Do

• Set up QuickNode Webhooks to monitor specific wallet addresses and contract events on BNB Chain
• Build a custom JavaScript filter to extract TokenPurchase events with decoded parameters
• Create an Express webhook server to receive and validate real-time trade notifications
• Implement a copytrading logic with configurable trade sizing and slippage protection
• Execute trades automatically using Viem

What You Will Need

• A QuickNode account with a BNB Chain endpoint
• Node.js v20.x or higher installed
• A funded wallet on BNB Chain (for executing copy trades)
• Basic understanding of JavaScript/TypeScript, webhooks, and smart contracts
• A text editor or IDE (VS Code recommended)

Disclaimer

This guide is for educational purposes only. Cryptocurrency trading carries significant risks, and copytrading does not guarantee profits. Successful traders' past performance is not indicative of future results. Always conduct your own research and only trade with funds you can afford to lose. Automated trading bots can malfunction or be exploited, potentially resulting in loss of funds.

Technical Background of four.meme Smart Contract

Before building the bot, it's essential to understand how the four.meme platform works and what data we can extract from its smart contract events.

The platform uses a bonding curve mechanism similar to Solana's Pump.fun. When users create tokens on the platform:

1. Token Launch: Creators deploy tokens.
2. Bonding Curve Trading: Tokens trade on an internal bonding curve where price increases as more tokens are purchased.
3. Graduation: When the bonding curve reaches 100%, some of the tokens automatically pair with the raised BNB on PancakeSwap, creating permanent liquidity.

The main contract, TokenManager2, is deployed at 0x5c952063c7fc8610FFDB798152D69F0B9550762b on the BNB Chain mainnet. While the contract emits multiple events, we will focus on the TokenPurchase event to track user purchases and trigger our copytrading logic.

Token Purchase Events

When a user buys a token on the platform, the contract emits a TokenPurchase event with the following structure:

event TokenPurchase(
    address token,
    address account,
    uint256 price,
    uint256 amount,
    uint256 cost,
    uint256 fee,
    uint256 offers,
    uint256 funds
);

The event signature hash of TokenPurchase(address,address,uint256,uint256,uint256,uint256,uint256,uint256) is 0x7db52723a3b2cdd6164364b3b766e65e540d7be48ffa89582956d8eaebe62942, which we use to filter for TokenPurchase events.

See the four.meme Protocol Integration Guide for more details on the contract and event structures.

Indexed vs Non-Indexed Parameters

Important: None of these parameters are indexed, meaning they all appear in the event's data field rather than as separate topics. This requires manual decoding of the data field to extract individual values.

In Ethereum and EVM-compatible blockchains, event parameters can be indexed or non-indexed. Indexed parameters are stored in the topics array of the event log, allowing for efficient filtering and searching. Non-indexed parameters are stored in the data field and require decoding to access their values.

Decode Data Field on Event Log

Non-indexed parameters of events are in the data field of the event log as a single hex string. To extract individual parameters, we need to decode this data according to the ABI specification.

The following is a portion of a sample event log for a TokenPurchase event. And below it, we break down how to decode the data field.

Sample TokenPurchase Event Log

{
  "address": "0x5c952063c7fc8610ffdb798152d69f0b9550762b",
  "topics": [
    "0x7db52723a3b2cdd6164364b3b766e65e540d7be48ffa89582956d8eaebe62942" // Event signature hash
  ],
  "data": "0x00000000000000000000000076138888158f7ce4bbe14c59e18e880d57ab44440000000000000000000000004262f7b70b81538258eb2c5ecad3947ba4e0c8b0000000000000000000000000000000000000000000000000000000029c13f53700000000000000000000000000000000000000000003a339d3d41d9ad2a4520000000000000000000000000000000000000000000000000000ae1e3ecafdee3e0000000000000000000000000000000000000000000000000001bdbe1163d1be000000000000000000000000000000000000000001991941ab911ad2ead4940000000000000000000000000000000000000000000000000021ff7f07b91232ea",
  // ...
}

Breakdown of the data field

00000000000000000000000076138888158f7ce4bbe14c59e18e880d57ab4444 // 64 hex chars (bytes32/uint256 - zero-padded address - token)
0000000000000000000000004262f7b70b81538258eb2c5ecad3947ba4e0c8b0 // 64 hex chars (bytes32/uint256 - zero-padded address - buyer)
000000000000000000000000000000000000000000000000000000029c13f537 // 64 hex chars (uint256 - price)
00000000000000000000000000000000000000000003a339d3d41d9ad2a45200 // 64 hex chars (uint256 - amount)
00000000000000000000000000000000000000000000000000ae1e3ecafdee3e // 64 hex chars (uint256 - cost)
0000000000000000000000000000000000000000000000000001bdbe1163d1be // 64 hex chars (uint256 - fee)
000000000000000000000000000000000000000001991941ab911ad2ead49400 // 64 hex chars (uint256 - offers)
00000000000000000000000000000000000000000000000021ff7f07b91232ea // 64 hex chars (uint256 - funds)

So, to decode the data field, we split it into 8 segments of 32 bytes (64 hex characters) each, corresponding to the 8 parameters of the TokenPurchase event. Then, we use the parameter types to determine the data type and decode it accordingly.

Now that we understand the event structure and how to decode it, we can proceed to learn how to filter for these events using QuickNode Webhooks.

QuickNode Webhook Filter Configuration

QuickNode Webhooks allow you to filter blockchain events server-side before they're delivered to your endpoint. This saves bandwidth and costs by only sending relevant events.

The QuickNode Webhooks UI allows for creating simple filters easily, but for more complex scenarios like ours, where we need to decode non-indexed event data and filter by multiple parameters, we can use a custom JavaScript filter.

To monitor TokenPurchase events from the four.meme contract, we'll create a custom JavaScript filter that:

1. Match the four.meme contract address
2. Identify TokenPurchase events by their signature hash
3. Extract the buyer address from the data field
4. Compare against the target wallet address
5. Decode all event parameters for trading decisions

Custom JavaScript Filter

The filter function below implements the above logic. It processes each block's receipts, filters for relevant logs, decodes the TokenPurchase event parameters, and returns a structured payload optimized for our copytrading bot.

Before we dive into the code, let's break down the logic:

Contract Address Matching: We normalize the contract address to lowercase to avoid case-sensitive comparisons.

Event Signature Matching: We use the event signature hash to filter for TokenPurchase events. This ensures we only process the relevant events.

Data Extraction: Since TokenPurchase parameters aren't indexed, we manually parse the data field. Each parameter occupies 32 bytes (64 hex characters). Addresses are padded, so we skip the first 24 hex characters (12 bytes) to extract the 20-byte address. extractAddress and extractUint256 helper functions handle this.

Offset Calculation: Parameter positions are zero-indexed:

• Offset 0: token address
• Offset 1: buyer address (our filter target)
• Offset 2-7: uint256 values price, amount, cost, fee, offers, funds

Cost Optimization: Returning null for non-matching blocks prevents unnecessary data transfer. QuickNode only charges for delivered payloads, so filtering server-side is cost-effective.

View JavaScript FilterCode

four.meme TokenPurchase Filter

function main(payload) {
  const { data, metadata } = payload;

  // Configuration constants
  const TARGET_WALLET = "YOUR_TARGET_WALLET_ADDRESS_HERE"; //  👈 REPLACE WITH YOUR TARGET WALLET ADDRESS
  const TARGET_CONTRACT = "0x5c952063c7fc8610FFDB798152D69F0B9550762b";
  const TOKEN_PURCHASE_SIG =
    "0x7db52723a3b2cdd6164364b3b766e65e540d7be48ffa89582956d8eaebe62942";

  // Normalize for comparison
  const normalizedContract = TARGET_CONTRACT.toLowerCase();
  const normalizedWallet = TARGET_WALLET.toLowerCase();

  const copyTrades = [];

  // Helper function to extract address from data field at given offset
  function extractAddress(dataHex, offset) {
    const data = dataHex.slice(2);
    // Each parameter is 32 bytes (64 hex chars)
    // Address is 20 bytes, padded with 12 bytes of zeros on the left
    const start = offset * 64 + 24; // Skip 24 hex chars (12 bytes) of padding
    const addressHex = data.slice(start, start + 40);
    return "0x" + addressHex.toLowerCase();
  }

  // Helper function to extract uint256 from data field at given offset
  function extractUint256(dataHex, offset) {
    const data = dataHex.slice(2);
    const start = offset * 64;
    const uint256Hex = data.slice(start, start + 64);
    // Return as hex string with 0x prefix (can be converted to BigInt if needed)
    return "0x" + uint256Hex;
  }

  // Helper function to convert hex to decimal string (for readability)
  function hexToDecimal(hexString) {
    try {
      // Remove 0x prefix if present
      const hex = hexString.startsWith("0x") ? hexString.slice(2) : hexString;
      // Convert to BigInt to handle large numbers
      return BigInt("0x" + hex).toString();
    } catch (error) {
      return hexString; // Return original if conversion fails
    }
  }

  // Process all receipts in the block
  data[0].receipts.forEach((receipt) => {
    // Filter logs matching the contract and event signature
    const relevantLogs = receipt.logs.filter((log) => {
      if (
        !log.address ||
        log.address.toLowerCase() !== normalizedContract ||
        !log.topics ||
        log.topics[0] !== TOKEN_PURCHASE_SIG ||
        !log.data
      ) {
        return false;
      }

      // Extract buyer address from data field (2nd parameter, offset 1)
      try {
        const buyerAddress = extractAddress(log.data, 1);
        return buyerAddress === normalizedWallet;
      } catch (error) {
        // Skip malformed logs
        return false;
      }
    });

    if (relevantLogs.length > 0) {
      // Decode all parameters for each relevant log
      const decodedLogs = relevantLogs.map((log) => {
        try {
          // Extract all 8 parameters
          const token = extractAddress(log.data, 0);
          const buyer = extractAddress(log.data, 1);
          const price = extractUint256(log.data, 2);
          const amount = extractUint256(log.data, 3);
          const cost = extractUint256(log.data, 4);
          const fee = extractUint256(log.data, 5);
          const offers = extractUint256(log.data, 6);
          const funds = extractUint256(log.data, 7);

          return {
            token: token,
            buyer: buyer,
            price: hexToDecimal(price),
            amount: hexToDecimal(amount), // Human-readable decimal
            cost: hexToDecimal(cost),
            fee: hexToDecimal(fee),
            offers: hexToDecimal(offers),
            funds: hexToDecimal(funds),
          };
        } catch (error) {
          return {
            error: "Failed to decode log",
            errorMessage: error.message,
            rawData: log.data,
          };
        }
      });

      copyTrades.push({
        transactionHash: receipt.transactionHash,
        blockNumber: receipt.blockNumber,
        blockTimestamp: parseInt(data[0].block.timestamp, 16),
        buyer: TARGET_WALLET,
        contract: TARGET_CONTRACT,
        from: receipt.from,
        to: receipt.to,
        logs: decodedLogs,
        status: receipt.status,
      });
    }
  });

  // Return null for no matches (saves bandwidth and costs)
  if (copyTrades.length === 0) {
    return null;
  }

  // Return structured payload optimized for trading bot
  return {
    trades: copyTrades,
  };
}

The payload returned by this filter will be sent to our webhook server, which will process the trades and execute them using Viem. The following is a sample payload from a TokenPurchase event:

View QuickNode Webhook Payload

Sample QuickNode Webhook Payload

{
  "trades": [
    {
      "blockNumber": "0x3e5cecb",
      "blockTimestamp": 1761045030,
      "buyer": "0x4262F7B70b81538258EB2C5ECAD3947Ba4e0C8b0",
      "contract": "0x5c952063c7fc8610FFDB798152D69F0B9550762b",
      "from": "0x4262f7b70b81538258eb2c5ecad3947ba4e0c8b0",
      "logs": [
        {
          "amount": "4397589923821429000000000",
          "buyer": "0x4262f7b70b81538258eb2c5ecad3947ba4e0c8b0",
          "fee": "490099009900990",
          "funds": "2449816393459315434",
          "offers": "494569930785511810000000000",
          "price": "11208488247",
          "token": "0x76138888158f7ce4bbe14c59e18e880d57ab4444",
          "cost": "49009900990099006"
        }
      ],
      "status": "0x1",
      "to": "0x1de460f363af910f51726def188f9004276bf4bc",
      "transactionHash": "0x4f4e720a02e9523a7637426f64982552a791ab55d63b5849466826dd20289523"
    }
  ]
}

We'll use the filtering function in the next section to set up QuickNode Webhooks. For now, we will proceed to create a webhook server to receive the payload and implement the copytrading logic based on the payload.

Project Architecture and Key Components

Before jumping into the code, let's review the project structure and key components. If you want to skip ahead, feel free to jump to the Copytrading Bot Project Setup section.

File Structure

├── src/
│   ├── config.ts           # Configuration and environment variables
│   ├── webhookServer.ts    # Express server for receiving webhooks
│   ├── tradingBot.ts       # Viem-based trading logic
│   └── index.ts            # Entry point
├── .env.example            # Template for environment variables
└── package.json            # Node.js project file

Configuration and Environment Variables

The config.ts file contains the configuration and environment variables for the bot. It imports the dotenv package to load environment variables from the .env file.

Webhook Server

The webhook server handles incoming notifications from QuickNode with HMAC signature verification for security. It processes the payload and triggers the trading logic, by calling the executeCopyTrade function from tradingBot.ts.

A snippet from webhookServer.ts

/**
 * Webhook endpoint to receive trade notifications
 */
app.post("/webhook", async (req: Request, res: Response) => {
  try {
    // Extract security headers
    const nonce = req.headers["x-qn-nonce"] as string;
    const timestamp = req.headers["x-qn-timestamp"] as string;
    const signature = req.headers["x-qn-signature"] as string;

    // Get payload
    const payload =
      typeof req.body === "string" ? req.body : JSON.stringify(req.body);

    // Verify HMAC signature
    if (
      config.quicknodeSecurityToken &&
      !verifyHMAC(payload, nonce, timestamp, signature)
    ) {
      console.error("❌ HMAC verification failed");
      return res.status(401).json({ error: "Invalid signature" });
    }

    // Parse payload
    const data = typeof req.body === "string" ? JSON.parse(req.body) : req.body;

    // Immediately respond to prevent retry
    res.status(200).json({ status: "received" });

    // Process trades asynchronously
    if (data.trades && data.trades.length > 0) {
      console.log(`\n${"=".repeat(60)}`);
      console.log(`🚨 New Webhook Received - ${new Date().toISOString()}`);
      console.log(`${"=".repeat(60)}`);

      for (const trade of data.trades) {
        await executeCopyTrade(trade);
      }
    }
  } catch (error: any) {
    console.error("❌ Webhook processing error:", error.message);
  }
});

Trading Logic

The executeCopyTrade function contains the core trading logic. It calculates the copy trade size based on the configured multiplier, checks wallet balance, applies slippage tolerance, and executes the trade using Viem.

• Trade Sizing: The bot calculates trade size proportionally using COPY_TRADE_MULTIPLIER. For example, if a whale buys with 0.1 BNB and your multiplier is 0.1 (10%), you'll trade 0.01 BNB.

• Safety Limits:

  • MIN_COPY_TRADE_AMOUNT: Filters out small trades to avoid excessive gas costs
  • MAX_TRADE_AMOUNT: Caps maximum exposure per trade
  • MIN_BALANCE: Reserves BNB for gas fees to prevent failed transactions

• Slippage Protection: The bot calculates minAmount based on the whale's price and your configured slippage tolerance. If the price moves unfavorably beyond this threshold, the transaction reverts, protecting you from sandwich attacks or rapid price changes.

• Transaction Simulation: Using simulateContract before writeContract catches potential errors (insufficient funds, contract reverts) without spending gas. This is a best practice for all production bots.

Understanding the buyTokenAMAP Function Call

The four.meme contract has multiple buyTokenAMAP overloads. We use the 4-parameter version:

function buyTokenAMAP(
    uint256 origin,      // Referral/origin code (use 0 for direct)
    address token,       // Token address to purchase
    uint256 funds,       // BNB amount to spend (in wei)
    uint256 minAmount    // Minimum tokens to receive (slippage protection)
) external payable

Function Parameters:

• origin: Referral tracking parameter. Set to 0 for direct purchases without referral
• token: The memecoin address from the webhook event
• funds: Amount of BNB you want to spend (in wei). Must match the value parameter
• minAmount: Minimum tokens you're willing to accept. Calculated as expectedTokens * (100 - slippage%) / 100

The function is payable, so you must send BNB via the value parameter matching the funds argument.

Here is a snippet from tradingBot.ts demonstrating the copy trade execution logic:

A snippet from tradingBot.ts

    const tradeData = payload.logs[0]; // First log entry
    const whaleCostBNB = parseFloat(formatEther(BigInt(tradeData.cost)));
    const whaleFee = parseFloat(formatEther(BigInt(tradeData.fee)));

    // Strategy: Only copy if whale buys significantly
    if (whaleCostBNB < config.minCopyTradeAmount) {
      console.log(
        `⏭️  Skipping - Trade too small (< ${config.minCopyTradeAmount} BNB)`
      );
      return;
    }

    // Calculate our trade amount (e.g., 10% of whale's trade)
    let ourTradeAmount = whaleCostBNB * config.copyTradeMultiplier;

    // Apply safety limits
    if (ourTradeAmount > config.maxTradeAmount) {
      console.log(
        `⚠️  Capping trade at max limit: ${config.maxTradeAmount} BNB`
      );
      ourTradeAmount = config.maxTradeAmount;
    }

    // Check wallet balance
    const balance = await client.getBalance({ address: account.address });
    const balanceBNB = parseFloat(formatEther(balance));

    console.log(`\n💰 Wallet Balance: ${balanceBNB.toFixed(6)} BNB`);

    if (balanceBNB < ourTradeAmount + config.minBalance) {
      console.log(
        `❌ Insufficient balance (need ${
          ourTradeAmount + config.minBalance
        } BNB including reserve)`
      );
      return;
    }

    // Calculate minAmount with slippage tolerance
    // Estimate expected tokens based on whale's rate
    const expectedAmount =
      (BigInt(tradeData.amount) * parseEther(ourTradeAmount.toString())) /
      BigInt(tradeData.cost);
    const minAmount =
      (expectedAmount * BigInt(100 - config.slippageTolerance)) / BigInt(100);

    // Execute the trade
    const { request } = await client.simulateContract({
      account: account,
      address: config.contractAddress,
      abi: TRADING_ABI,
      functionName: "buyTokenAMAP",
      args: [
        BigInt(0), // origin
        tradeData.token, // token address
        parseEther(ourTradeAmount.toString()), // BNB amount in wei
        minAmount, // minimum tokens to receive
      ],
      value: parseEther(ourTradeAmount.toString()),
    });


    const txHash = await client.writeContract(request);

    console.log(`✅ Transaction sent: ${txHash}`);
    console.log(`🔍 View on BscScan: https://bscscan.com/tx/${txHash}`);

    // Wait for confirmation
    const receipt = await client.waitForTransactionReceipt({
      hash: txHash,
    });

Copytrading Bot Project Setup

Now, let's set up the project and dependencies.

Prerequisites

To follow along with this guide, ensure you have:

• A QuickNode account to have a BNB Chain endpoint and Webhooks access
• Webhook Security Token from QuickNode Webhooks dashboard (optional)
• A funded wallet on BNB Chain (for executing copy trades)

QuickNode BNB Chain RPC URL and Webhook Setup

1. Sign up for QuickNode

   • Visit QuickNode and create a free account

2. Create a BNB Chain Endpoint

   • Click "Create Endpoint" from your dashboard
   • Select "BNB Smart Chain" → "Mainnet"
   • Choose your desired plan
   • Click "Create Endpoint"
   • Copy your HTTP Provider URL (e.g., https://example.bnb.quiknode.pro/abc123/)

3. Set Up Webhook

   • Navigate to Webhooks Dashboard
   • Click "Create Webhook"
   • Select "BNB Smart Chain" → "Mainnet"
   • Choose "Write a custom filter"
   • Copy the filter code from the previous section and paste it into the filter editor
   • Update TARGET_WALLET in the filter to the address you want to monitor (e.g., 0x4262F7B70b81538258EB2C5ECAD3947Ba4e0C8b0)
   • Test the filter with a BNB Chain mainnet block number you want to monitor (e.g., 65392331)
   • Save the Security Token shown in the webhook settings

Note: Setting destination URL and creating the webhook will be done after setting up your public URL, which we'll cover in the following section. So, leave it here for now. We will come back to it later.

Webhook Security Token

QuickNode Webhooks provides a security token to validate incoming requests. While it is optional, it is highly recommended to use it to ensure that only legitimate requests from QuickNode are processed by your webhook server. See How to Validate Incoming Streams Webhook Messages (Streams & Webhooks use the same HMAC scheme) for more details.

Clone the Sample Project

We'll use our QuickNode Guide Examples repository to set up the copytrading bot easily. Clone the repository and navigate to the webhooks/copytrading-bot-bnb directory.

git clone https://github.com/quiknode-labs/qn-guide-examples.git
cd qn-guide-examples/webhooks/copytrading-bot-bnb

Install Dependencies

Install the required dependencies using a package manager of your choice (npm, yarn, pnpm, etc.).

npm install
# or
yarn install
# or
pnpm install

Key dependencies:

• viem: Modern TypeScript library for Ethereum interactions
• express: Lightweight web server for webhook endpoint
• dotenv: Environment variable management
• tsx: TypeScript execution without compilation step

Configure Environment Variables

Copy the .env.example file to .env.

cp .env.example .env

Then, edit .env with your credentials:

# Blockchain Configuration
BNB_RPC_URL=your-quicknode-rpc-url # 👈 UPDATE HERE

# Wallet Configuration (⚠️ KEEP THIS SECURE)
PRIVATE_KEY=your-private-key # 👈 UPDATE HERE

# Webhook Security
QUICKNODE_SECURITY_TOKEN=your-security-token # 👈 UPDATE HERE

# Server Configuration
PORT=3000

# Trading Strategy
MIN_COPY_TRADE_AMOUNT=0.01     # Only copy trades >= 0.01 BNB
COPY_TRADE_MULTIPLIER=0.01     # Copy 0.01 (1%) of whale's trade size
MAX_TRADE_AMOUNT=0.5           # Maximum 0.5 BNB per trade
MIN_BALANCE=0.0001             # Keep 0.0001 BNB reserve for gas
SLIPPAGE_TOLERANCE=5           # 5% slippage tolerance

Security Note

Never commit your .env file to version control. The .gitignore file already excludes it.

Start the Bot

Run the bot using the following command:

npm run dev

Expected output:

🔑 Trading wallet: 0x...
💰 Current Balance: 0.523456 BNB

============================================================
🚀 BNB Chain Copytrading Bot Started
============================================================
📡 Webhook URL: http://localhost:3000/webhook
💚 Health Check: http://localhost:3000/health
🎯 Target Contract: 0x5c952063c7fc8610FFDB798152D69F0B9550762b
📊 Copy Multiplier: 10%
⚡ Max Trade Amount: 0.5 BNB
============================================================

The bot will start listening for incoming webhook requests on port 3000. You can now test the bot by sending a TokenPurchase event to the webhook endpoint.

Expose Your Webhook URL

For QuickNode to deliver webhooks, your endpoint must be publicly accessible. During development, use:

ngrok (recommended):

ngrok http 3000

Copy the HTTPS URL (e.g., https://abc123.ngrok.io) and use https://abc123.ngrok.io/webhook as your webhook destination in QuickNode.

For production, consider deploying to platforms like Vercel, Heroku, or AWS.

Test and Create Your Webhook

As the final step, we will test if everything is working correctly and create the webhook in QuickNode.

1. Go back to your QuickNode Webhooks dashboard, where you left off earlier.
2. Set the Destination URL to your public webhook URL (e.g., https://abc123.ngrok.io/webhook).
3. Test the webhook by sending a test payload to the webhook endpoint.
4. If everything is working correctly and the test block has a suitable TokenPurchase event, you should see your bot perform a copy trade based on the test data.
5. Create your webhook.

Monitor Bot Activity

The bot will now receive webhooks when your target wallet makes purchases. You'll see output like:

============================================================
🚨 New Webhook Received - 2025-01-15T10:30:45.123Z
============================================================

📊 Whale Trade Detected:
├─ Token: 0x76138888158f7ce4bbe14c59e18e880d57ab4444
├─ Whale: 0x4262F7B70b81538258EB2C5ECAD3947Ba4e0C8b0
├─ Amount: 4397.589924 tokens
├─ Cost: 0.000049 BNB
├─ Fee: 0.000000 BNB
├─ Total Spent: 0.000049 BNB
└─ TX: 0x4f4e720a...

💰 Wallet Balance: 0.523456 BNB

🎯 Executing Copy Trade:
├─ Our Amount: 0.000005 BNB
├─ Expected Tokens: 439.758992
├─ Min Tokens: 417.870842
└─ Slippage: 5%

⏳ Sending transaction...
✅ Transaction sent: 0x789abc...
🔍 View on BscScan: https://bscscan.com/tx/0x789abc...
✅ Copy trade successful! Block: 45678901

Congratulations! You've successfully built a memecoin copytrading bot on BNB Chain using QuickNode Webhooks and Viem.

Conclusion

You've built a functional copytrading bot that monitors BNB Chain transactions in real-time using QuickNode Webhooks and executes automated trades with Viem. The bot demonstrates key blockchain development concepts: event filtering, webhook handling, secure transaction signing, and intelligent trade execution.

QuickNode's Webhooks product provides a reliable, low-latency infrastructure needed for time-sensitive trading applications. By filtering events server-side and delivering only relevant transactions, you minimize bandwidth costs and maximize responsiveness.

The copytrading strategy implemented here serves as a foundation for more sophisticated trading systems. As you expand the bot's capabilities with the improvements suggested above, you'll gain deeper insights into on-chain trading dynamics and develop more refined automated strategies.

Subscribe to our newsletter for more Web3 development guides and blockchain tutorials. If you have questions or need assistance, join our Discord community or provide feedback using the form below. Follow us on X (@QuickNode) and Telegram for the latest updates.

Further Improvements

Once you have a working copytrading bot, consider these enhancements:

There are a wide range of marketplace add-ons and services available on QuickNode Marketplace that can help you implement some of these features easily.

Advanced Trading Features

Dynamic Slippage Based on Volatility: Adjust slippage tolerance based on recent price movements. During high volatility periods, increase slippage to improve execution rates while maintaining acceptable price impact.

Multi-Wallet Monitoring: Track multiple successful traders simultaneously. Implement weighted copying where you allocate different percentages to different wallets based on their historical performance.

Position Sizing Based on Win Rate: Track each whale's success rate and adjust your copy percentage accordingly. Successful traders get higher multipliers, while underperforming wallets get reduced or eliminated.

Market Intelligence

USD Price Integration: Convert all BNB amounts to USD. This helps you set consistent dollar-based limits regardless of BNB price fluctuations.

Profit/Loss Tracking: Save trade history in a database (e.g., PostgreSQL or MongoDB) to compute both realized and unrealized P&L. Use this data to monitor performance metrics such as win rate, average profit per trade, and overall return on investment (ROI).

Performance Optimization

Gas Price Optimization: Monitor BNB Chain gas prices and adjust your transactions accordingly. During high congestion, you may want to increase gas price for faster execution or pause copytrading to avoid excessive costs.

MEV Protection: Integrate with private transaction relays that support BNB Chain to prevent sandwich attacks on your copy trades.

Risk Management

Stop-Loss Mechanisms: Automatically sell positions that drop below a certain percentage threshold. This limits downside while allowing winners to run.

Position Limits: Cap total exposure across all tokens. For example, never have more than 50% of your capital in active memecoin positions.

Blacklist/Whitelist: Maintain lists of tokens to avoid (known rugs, honeypots) or prefer (verified projects, high liquidity). Update these lists based on onchain analysis or community reports.

We ❤️ Feedback!

Let us know if you have any feedback or requests for new topics. We'd love to hear from you.