Deploy Your Own Automated Trading Bot for four.meme on BSC — Free & Open Source $bumper

A volume bumper is a trading bot that automatically executes buy and sell transactions to generate trading activity for your token. This guide walks you through building one using PancakeSwap V3 on BNB Smart Chain.

What is a Volume Bumper?

A volume bumper creates artificial trading volume by:

• Executing multiple sell transactions
• Following up with buy transactions
• Running in cycles with configurable delays

This can help with:

• Increasing token visibility on DEX aggregators
• Meeting volume requirements for listings
• Creating organic-looking trading activity

Prerequisites

• Node.js installed
• A wallet with BNB for gas fees
• Some of your token to trade
• Basic understanding of JavaScript

Installation

The Configuration

Create a file called bumper.js and set up your configuration:

const { ethers } = require('ethers');

// --- CONFIGURATION ---
// SECURITY WARNING: Use environment variables for private keys in production!
const PRIVATE_KEY = "YOUR_PRIVATE_KEY_HERE";
const SENDER_ADDRESS = "YOUR_WALLET_ADDRESS_HERE";

// The token you want to trade
const TOKEN_ADDRESS = "YOUR_TOKEN_ADDRESS_HERE";

// --- SWAP AMOUNTS ---
// Amount of BNB to spend for BUY (with randomization for natural-looking trades)
const BNB_AMOUNT_TO_SPEND_BUY = 0.002 * (0.5 + Math.random() * 0.7);

// Amount of TOKEN to sell (with randomization)
const TOKEN_TO_SELL_AMOUNT = 1000000 * (0.5 + Math.random() * 0.5);

// --- SLIPPAGE & FEES ---
const SLIPPAGE_TOLERANCE_PERCENT = 5; // 5% slippage tolerance

// Fee tiers: 500 = 0.05%, 2500 = 0.25%, 10000 = 1%
const FEE_TIER = 500;
const FEE_TIERS_TO_TRY = [500, 2500, 10000];

// --- LOOP CONFIGURATION ---
const LOOP_DELAY_MINUTES = 1; // Delay between cycles
const DELAY_BETWEEN_SELLS_MS = 10000; // 10 seconds between individual transactions

// --- NUMBER OF TRANSACTIONS PER CYCLE ---
const NUMBER_OF_SELLS = 3; // How many sell transactions per cycle
const NUMBER_OF_BUYS = 2;  // How many buy transactions per cycle

Key Configuration Variables Explained

PancakeSwap V3 Contract Addresses (BSC)

const PANCAKESWAP_ROUTER_V3_ADDRESS = '0x1b81D678ffb9C0263b24A97847620C99d213eB14';
const PANCAKESWAP_QUOTER_V2_ADDRESS = '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997';
const WBNB_ADDRESS = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c';
const BSC_RPC_URL = "https://bsc-dataseed.binance.org/";

The ABIs

// Router ABI for swaps
const ROUTER_ABI = [
    "function exactInputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) payable returns (uint256 amountOut)"
];

// Quoter ABI for getting price quotes
const QUOTER_V2_ABI = [
    "function quoteExactInputSingle(tuple(address tokenIn, address tokenOut, uint256 amountIn, uint24 fee, uint160 sqrtPriceLimitX96) params) returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)"
];

// ERC-20 Token ABI
const TOKEN_ABI = [
    "function decimals() view returns (uint8)",
    "function approve(address spender, uint256 amount) returns (bool)",
    "function allowance(address owner, address spender) view returns (uint256)",
    "function balanceOf(address account) view returns (uint256)"
];

// WBNB ABI for unwrapping
const WBNB_ABI = [
    "function balanceOf(address account) view returns (uint256)",
    "function withdraw(uint256 wad)"
];

Core Functions

1. Getting Price Quotes

async function getMinimumAmountOut(provider, tokenIn, tokenOut, amountIn, fee, outputDecimals = 18) {
    const quoterContract = new ethers.Contract(PANCAKESWAP_QUOTER_V2_ADDRESS, QUOTER_V2_ABI, provider);

const quoteParams = {
        tokenIn: ethers.getAddress(tokenIn),
        tokenOut: ethers.getAddress(tokenOut),
        amountIn: amountIn,
        fee: fee,
        sqrtPriceLimitX96: BigInt(0)
    };

const result = await quoterContract.quoteExactInputSingle.staticCall(quoteParams);
    const amountOut = result[0];

// Apply slippage tolerance
    const slippageMultiplier = BigInt(10000 - (SLIPPAGE_TOLERANCE_PERCENT * 100));
    const minimumAmountOut = (amountOut * slippageMultiplier) / BigInt(10000);

return { amountOut: minimumAmountOut, fee: fee };
}

2. Token Approval

async function approveToken(wallet, tokenAddress, routerAddress, amountInWei) {
    const tokenContract = new ethers.Contract(tokenAddress, TOKEN_ABI, wallet);
    const allowance = await tokenContract.allowance(wallet.address, routerAddress);

if (allowance >= amountInWei) {
        console.log("Token already approved.");
        return true;
    }

const approvalTx = await tokenContract.approve(routerAddress, amountInWei);
    await approvalTx.wait();
    return true;
}

3. Buy Function (BNB → Token)

async function buyToken(wallet, routerContract, tokenDecimals) {
    const amountInWei = ethers.parseUnits(BNB_AMOUNT_TO_SPEND_BUY.toFixed(6), 18);
    const deadline = Math.floor(Date.now() / 1000) + (60 * 5);

const quoteResult = await getMinimumAmountOut(
        wallet.provider, WBNB_ADDRESS, TOKEN_ADDRESS, amountInWei, FEE_TIER, tokenDecimals
    );

const swapParams = {
        tokenIn: WBNB_ADDRESS,
        tokenOut: TOKEN_ADDRESS,
        fee: quoteResult.fee,
        recipient: wallet.address,
        deadline: deadline,
        amountIn: amountInWei,
        amountOutMinimum: quoteResult.amountOut,
        sqrtPriceLimitX96: BigInt(0)
    };

const tx = await routerContract.exactInputSingle(swapParams, {
        value: amountInWei,
        gasLimit: 500000
    });

await tx.wait();
    console.log(`Buy successful! Hash: ${tx.hash}`);
}

4. Sell Function (Token → BNB)

async function sellToken(wallet, routerContract, tokenDecimals) {
    const amountInWei = ethers.parseUnits(TOKEN_TO_SELL_AMOUNT.toString(), tokenDecimals);
    const deadline = Math.floor(Date.now() / 1000) + (60 * 5);

// Approve router first
    await approveToken(wallet, TOKEN_ADDRESS, PANCAKESWAP_ROUTER_V3_ADDRESS, amountInWei);

const quoteResult = await getMinimumAmountOut(
        wallet.provider, TOKEN_ADDRESS, WBNB_ADDRESS, amountInWei, FEE_TIER, 18
    );

const swapParams = {
        tokenIn: TOKEN_ADDRESS,
        tokenOut: WBNB_ADDRESS,
        fee: quoteResult.fee,
        recipient: wallet.address,
        deadline: deadline,
        amountIn: amountInWei,
        amountOutMinimum: quoteResult.amountOut,
        sqrtPriceLimitX96: BigInt(0)
    };

const tx = await routerContract.exactInputSingle(swapParams, { gasLimit: 500000 });
    await tx.wait();
    console.log(`Sell successful! Hash: ${tx.hash}`);
}

5. WBNB Unwrapping

async function unwrapWbnb(wbnbContract, wallet) {
    const wbnbBalance = await wbnbContract.balanceOf(wallet.address);
    if (wbnbBalance > 0n) {
        const unwrapTx = await wbnbContract.withdraw(wbnbBalance);
        await unwrapTx.wait();
        console.log(`Unwrapped ${ethers.formatEther(wbnbBalance)} WBNB to BNB`);
    }
}

The Main Loop

async function executeLoop() {
    const provider = new ethers.JsonRpcProvider(BSC_RPC_URL);
    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);

const routerContract = new ethers.Contract(PANCAKESWAP_ROUTER_V3_ADDRESS, ROUTER_ABI, wallet);
    const wbnbContract = new ethers.Contract(WBNB_ADDRESS, WBNB_ABI, wallet);
    const tokenDecimals = await getTokenDecimals(provider, TOKEN_ADDRESS);

let cycleCount = 0;

while (true) {
        cycleCount++;
        console.log(`\n=== CYCLE #${cycleCount} START ===`);

// Execute SELL operations
        for (let i = 1; i <= NUMBER_OF_SELLS; i++) {
            await sellToken(wallet, routerContract, tokenDecimals);
            if (i < NUMBER_OF_SELLS) {
                await delay(DELAY_BETWEEN_SELLS_MS);
            }
        }

// Unwrap any WBNB received
        await unwrapWbnb(wbnbContract, wallet);

// Execute BUY operations
        for (let i = 1; i <= NUMBER_OF_BUYS; i++) {
            await buyToken(wallet, routerContract, tokenDecimals);
            if (i < NUMBER_OF_BUYS) {
                await delay(DELAY_BETWEEN_SELLS_MS);
            }
        }

console.log(`=== CYCLE #${cycleCount} END ===`);
        console.log(`Waiting ${LOOP_DELAY_MINUTES} minutes before next cycle...`);
        await delay(LOOP_DELAY_MINUTES * 60 * 1000);
    }
}

executeLoop();

Running the Bot

node bumper.js

Important Security Tips

1. Never hardcode private keys - Use environment variables:

   const PRIVATE_KEY = process.env.PRIVATE_KEY;
   

2. Start with small amounts - Test with minimal BNB first

3. Monitor gas prices - High gas can eat into your balance

4. Verify contract addresses - Always check on BSCScan before use

5. Use a dedicated wallet - Don't use your main wallet

Troubleshooting

Customization Ideas

• Randomize timing - Add random delays to appear more natural
• Volume targets - Stop after reaching a specific volume
• Multiple wallets - Distribute activity across wallets
• Price monitoring - Pause if price drops too much

Disclaimer

This tool is for educational purposes. Creating artificial volume may violate exchange terms of service and could be considered market manipulation in some jurisdictions. Use responsibly and at your own risk.

Comparing Ethereum ERC-8004 vs Virtuals' Agentic Commerce Protocol: A Technical Deep Dive

Introduction

The rise of autonomous AI agents has created a fundamental challenge: how can these agents discover, trust, and collaborate with each other across organizational boundaries without pre-existing relationships? Two significant approaches have emerged to address this problem—Ethereum's ERC-8004 trust framework and Virtuals Protocol's Agentic Commerce Protocol (ACP).

ERC-8004: Ethereum's Trust Framework for AI Agents

ERC-8004 establishes a public discovery and trust layer for AI agents through three lightweight on-chain registries. The design philosophy prioritizes modularity and composability over feature completeness.

Identity Registry: Portable Agent Identities via ERC-721

The Identity Registry implements agent identities as ERC-721 non-fungible tokens, giving each agent a globally unique identifier.

Reputation Registry: Decentralized Performance Tracking

Standardized interface for posting and retrieving performance feedback about agents.

Validation Registry: Pluggable Task Verification

Allows independent task verification by third parties.

What ERC-8004 Intentionally Omits

As a minimal trust layer, ERC-8004 excludes financial exchange mechanisms and communication protocols.

Virtuals' Agentic Commerce Protocol (ACP)

ACP defines an integrated standard that encompasses the entire agent interaction lifecycle—from discovery through negotiation to payment settlement and outcome validation.

Agent Discovery and Flexible Identity

ACP's discovery mechanism centers on a shared on-chain registry where agents advertise their capabilities.

Four-Phase Task Coordination Workflow

1. Request: A client agent submits a request.
2. Negotiation: Agreement on task terms.
3. Transaction: Execution and payment coordination.
4. Evaluation: Outcome validation by a third-party evaluator.

Integrated Trust and Economic Incentives

Economic design reinforces honest behavior throughout the system.

Overlapping Goals and Shared Philosophy

Both frameworks emphasize verifiable on-chain identities and reputations.

Fundamental Architectural Differences

ERC-8004 focuses on trust primitives while ACP encompasses complete workflows.

Technical Implementation Comparison

Examining the identity and reputation mechanisms highlights the architectural distinctions.

Real-World Application: The EthiQ Case Study

EthiQ, a peer-to-peer donation platform, illustrates the practical synergy of both approaches in fostering trust in autonomous agent coordination.