Pons v2 Multi-Wallet Volume Bot

A production-oriented CLI for generating on-chain trading volume on the Pons v2 bonding curve on Robinhood Chain. The bot coordinates multiple funded wallets through automated buy-and-sell cycles, with configurable sizing, timing, budget controls, and graduation safeguards.

This software is developed and maintained by CoolBB Agency — a multidisciplinary development studio focused on Web3 infrastructure, trading automation, and token launch tooling.

Tokens launched through Pons v2 trade on a constant-product bonding curve before graduating into a permanently locked Uniswap v4 pool. While a launch remains in phase 0 (NotGraduated), all swaps are executed directly against the curve contract — not through a DEX router.

This bot is purpose-built for that pre-graduation window. It:

1. Resolves your token's curve address and launch metadata from the Pons v2 factory.
2. Distributes activity across a pool of wallets using round-robin selection.
3. Executes a buy → delay → sell cycle on each eligible wallet.
4. Tracks cumulative volume, fees, and spend against operator-defined limits.
5. Halts automatically when safety thresholds are reached or on graceful shutdown.

The quoting engine replicates Pons v2's on-chain pricing logic off-chain (constant-product math with directional fee application), so trade parameters are computed before submission and slippage bounds are applied at execution time.

• Multi-wallet orchestration — Round-robin wallet rotation with per-wallet balance eligibility checks.
• Pons v2 curve integration — Direct buy() / sell() calls against the bonding curve contract.
• Accurate off-chain quoting — Constant-product pricing with protocol fees, creator tax, and snipe-tax handling per Pons v2 documentation.
• Native and ERC-20 quote support — Handles ETH-native launches and custom-pair (e.g. WETH) launches with automatic approval flows.
• Configurable trade randomization — Random trade sizes and inter-trade delays within operator-defined ranges.
• Safety guards — Graduation progress cap, total spend budget, max cycle count, and minimum wallet balance thresholds.
• Dry-run mode — Full cycle simulation without broadcasting transactions.
• Structured logging — JSON event lines per cycle plus human-readable status and metrics summaries.
• Graceful shutdown — SIGINT / SIGTERM handling with end-of-run metrics reporting.

┌─────────────┐     ┌──────────────┐     ┌───────────────────┐
│  CLI        │────▶│  BotRunner   │────▶│ WashVolumeStrategy│
│  (index.ts) │     │  (runner.ts) │     │ (washVolume.ts)   │
└─────────────┘     └──────────────┘     └─────────┬─────────┘
                                                   │
                     ┌─────────────────────────────┼─────────────────────────────┐
                     ▼                             ▼                             ▼
              ┌─────────────┐              ┌─────────────┐              ┌─────────────┐
              │ WalletPool  │              │ CurveTrader │              │ QuoteEngine │
              │ (pool.ts)   │              │ (trade.ts)  │              │ (quote.ts)  │
              └──────┬──────┘              └──────┬──────┘              └──────┬──────┘
                     │                            │                            │
                     └────────────────────────────┼────────────────────────────┘
                                                  ▼
                                    Robinhood Chain RPC (chain 4663)
                                    Pons v2 Factory + Bonding Curve

The bot only operates when a token is in phase 0 (NotGraduated). All other phases are rejected at startup:

Before running the bot, ensure the following:

1. Node.js 18 or later installed on the host machine.
2. A Pons v2 token that is still on its bonding curve (phase 0, not graduated).
3. ETH on Robinhood Chain distributed across bot wallets sufficient for trade sizes, gas, and the configured MIN_WALLET_ETH threshold.
4. Private keys for each participating wallet, provided via environment variable or key file.
5. Network access to the Robinhood Chain RPC endpoint.

ETH must be bridged to Robinhood Chain before use. Refer to the Robinhood Chain documentation for canonical bridge routes and supported assets. Each wallet should hold enough ETH to cover:

• The maximum configured trade size (MAX_TRADE_ETH)
• Estimated gas per buy, sell, and approval transaction
• The MIN_WALLET_ETH reserve defined in configuration

# Clone or copy the project, then install dependencies
npm install

# Create your environment file from the template
cp .env.example .env

Edit .env with your token address, wallet keys, and operational parameters before running any commands.

Security: Never commit .env, private keys, or key files to version control. The .gitignore excludes .env and keys/ by default.

All settings are loaded from environment variables and validated at startup via Zod. Invalid or conflicting values (e.g. MIN_TRADE_ETH greater than MAX_TRADE_ETH) cause an immediate exit with a descriptive error.

At least one wallet key source must be provided.

Validates the token launch record, prints curve metadata, graduation progress, fee rates, and per-wallet ETH balances with eligibility flags.

npm run status

Estimates the output of a buy followed by a full sell-back, including fees and round-trip loss — without executing any transaction.

npm run quote -- --eth 0.01

Starts the wash volume loop. Respects the DRY_RUN setting in .env.

npm run start

Press Ctrl+C to request a graceful shutdown. The bot finishes the current cycle, prints a metrics summary, and exits.

npm run build    # TypeScript type-check
npm test         # Offline quote engine unit tests

We recommend the following sequence before enabling live trading:

For each eligible wallet, the bot performs:

1. Select wallet — Round-robin from the pool; skip wallets below MIN_WALLET_ETH or insufficient for trade + gas.
2. Size trade — Random amount between MIN_TRADE_ETH and MAX_TRADE_ETH.
3. Buy — Submit curve.buy(quoteIn, minTokensOut, recipient); parse CurveBuy event for actual tokensOut.
4. Delay — Random pause between MIN_DELAY_MS and MAX_DELAY_MS.
5. Sell — Submit curve.sell(tokensIn, minQuoteOut, recipient) for the acquired token balance.
6. Record metrics — Update volume, fees, spend, and cycle count.
7. Guard check — Evaluate graduation progress, budget, and cycle limits before the next iteration.

Volume generation on a bonding curve is not cost-free. Every round-trip incurs:

• Protocol fee — Charged on the quote leg (feeBps on the curve).
• Creator tax — Additional quote-leg charge set at launch (creatorTaxBps).
• Price impact — Buys move the curve price up; sells move it back down.
• Gas — ETH spent on approvals, buys, sells, and receipt confirmation.

Buy fees are deducted from the input before pricing; sell fees are deducted from the output after pricing. These directions are not symmetric — the quote command reflects the actual round-trip economics.

Use npm run quote to model expected loss per cycle before committing capital.

• Verify the token contract address is correct before starting. Token names and symbols on Pons are not unique; the contract address is canonical.
• Monitor graduation progress during operation, especially with large trade sizes.
• Comply with applicable laws, platform terms of service, and exchange policies. Artificial volume generation may be restricted or prohibited in certain jurisdictions and contexts.
• Secure private keys. Use dedicated wallets with limited funds rather than primary holdings.

src/
├── index.ts                 # CLI entry point (status, quote, start)
├── config.ts                # Environment loading and Zod validation
├── chain/
│   └── robinhood.ts         # Chain definition, public/wallet client factories
├── pons/
│   ├── abis.ts              # Factory, curve, and ERC-20 ABIs
│   ├── launch.ts            # Token resolution, phase checks, status formatting
│   ├── quote.ts             # Off-chain constant-product quote engine
│   ├── trade.ts             # Buy/sell execution and event parsing
│   └── quote.test.ts        # Quote engine unit tests
├── wallets/
│   └── pool.ts              # Multi-wallet loading, balances, eligibility
├── strategy/
│   └── washVolume.ts        # Cycle logic, guards, randomization
└── bot/
    ├── runner.ts            # Main loop, shutdown handling
    └── metrics.ts           # Cumulative volume, fees, and cycle tracking

• CoolBB Agency
• Pons documentation
• Pons v2 builder guide
• Pons v2 quoting
• Robinhood Chain documentation
• Uniswap v3 on Robinhood Chain

Copyright © 2026 CoolBB Agency. All rights reserved.

This software is written and maintained by CoolBB Agency. Unauthorized reproduction, redistribution, or commercial use without prior written consent from CoolBB Agency is prohibited.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL COOLBB AGENCY BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM THE USE OF THIS SOFTWARE.