zksnarks

Defining a Volume Bumper: How It Works
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 transactionsFollowing up with buy transactionsRunning in cycles with configurable delays
This can help with:
Increasing token visibility on DEX aggregatorsMeeting volume requirements for listingsCreating organic-looking trading activity
Prerequisites
Node.js installedA wallet with BNB for gas feesSome of your token to tradeBasic 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
Variable
Description
Example
PRIVATE_KEY
Your wallet's private key
Use env variables!
TOKEN_ADDRESS
Contract address of your token
0x...
BNB_AMOUNT_TO_SPEND_BUY
BNB amount per buy
0.002
TOKEN_TO_SELL_AMOUNT
Tokens to sell per transaction
1000000
NUMBER_OF_SELLS
Sell transactions per cycle
3
NUMBER_OF_BUYS
Buy transactions per cycle
2
LOOP_DELAY_MINUTES
Wait time between cycles
1
SLIPPAGE_TOLERANCE_PERCENT
Max acceptable slippage
5
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
Before each swap, the bot gets a quote to determine the minimum acceptable output:
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
Before selling tokens, you must approve the router to spend them:
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
When you sell tokens, you receive WBNB. This function converts it back to BNB:
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
Never hardcode private keys - Use environment variables:const PRIVATE_KEY = process.env.PRIVATE_KEY;
Start with small amounts - Test with minimal BNB firstMonitor gas prices - High gas can eat into your balanceVerify contract addresses - Always check on BSCScan before useUse a dedicated wallet - Don't use your main wallet
Troubleshooting
Issue
Solution
Insufficient BNB
Add more BNB for gas fees
Pool not found
Check if liquidity pool exists for your token
Slippage too high
Increase SLIPPAGE_TOLERANCE_PERCENT
Transaction reverted
Check token balance and allowance
Customization Ideas
Randomize timing - Add random delays to appear more naturalVolume targets - Stop after reaching a specific volumeMultiple wallets - Distribute activity across walletsPrice 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.#

En un caso reciente, un cliente mío fue engañado por un correo electrónico falso de MetaMask para entregar su frase semilla. El atacante rápidamente obtuvo el control total de la billetera del usuario. Pero dentro de 30 minutos, intervine para reducir el daño. Al mover fondos, bloquear el acceso al gas y desplegar un script simple de nodejs, logré limitar la pérdida. Así es como sucedió — y lo que puedes aprender de ello.

Historia completa de Simon Tadross – lee más en simontadros.com

Enganchado por un correo electrónico falso de MetaMask
Mi cliente recibió un correo electrónico falso de MetaMask diciendo que su billetera había sido hackeada y que necesitaba restablecer su contraseña. Parecía oficial: logo de MetaMask, tono urgente, pero era una estafa. MetaMask nunca envía correos electrónicos pidiendo contraseñas o frases semilla. En un pánico, hicieron clic e ingresaron sus 12 palabras en un sitio web de phishing.