Building a Pons Bundler Bot on Robinhood Chain

Token launches are one of the most interesting areas to experiment with when building bots on an EVM-compatible chain.

Recently, I’ve been working on a small Pons V2 bundler bot for Robinhood Chain to better understand how the launch contract, snipe tax, and launchAndBuy flow work together.

This isn't meant to be a production trading system. It's a small research project that makes the underlying mechanics easier to understand and experiment with.

The basic idea

Pons V2 uses a temporary snipe tax during the early stage of a token launch.

The current tax can be read through:

currentSnipeTaxBps

The value is expressed in basis points:

100 bps  = 1%
1,000 bps = 10%
9,900 bps = 99%

So an early buyer can potentially face a very high tax.

The interesting part is what happens when the token is launched and bought through launchAndBuy.

Instead of doing:

Launch
   ↓
Wait
   ↓
Buy

the contract can combine the launch and initial purchase:

launchAndBuy()
      ↓
Create launch
      ↓
Initial purchase

This gives the initial recipient different treatment from a completely unrelated wallet.

For example, after a launch, we can compare:

Initial recipient
→ 0 bps

Random wallet
→ ~9900 bps

The exact values depend on the current launch state and contract implementation, so they should always be verified directly on-chain.

Building the bot

The implementation is intentionally simple.

The main components are:

src/
├── cli.ts
├── launch.ts
└── tax.ts

The CLI provides commands for:

pnpm pons index

to inspect factory configuration.

pnpm pons can-launch 0xYourWallet

to check whether a wallet is allowed to launch.

And:

pnpm pons tax \
  --token 0xToken \
  --wallet 0xWallet

to read the current snipe tax for a wallet.

For launching, the bot can prepare a configuration and preview the transaction before execution:

pnpm pons preview --config examples/launch.json

Then, when everything looks correct:

pnpm pons launch --config examples/launch.json --live

One important detail: msg.value

One of the easy things to miss when interacting directly with a launch contract is the transaction value.

The required msg.value may include both:

Launch fee
+
Initial buy

So the bot needs to calculate the total value correctly before constructing the transaction.

I also prefer simulating the transaction before broadcasting it:

Read contract state
       ↓
Check canLaunch()
       ↓
Build launchAndBuy()
       ↓
Calculate msg.value
       ↓
Simulate
       ↓
Sign
       ↓
Broadcast

This simple workflow can prevent a lot of unnecessary failed transactions.

Why I built this as a one-wallet demo

It's tempting to immediately build a complicated multi-wallet system.

But I think understanding the basic contract interaction first is much more valuable.

Once you understand:

• canLaunch
• launch configuration
• currentSnipeTaxBps
• launchAndBuy
• msg.value
• transaction simulation

you have a much better foundation for building more advanced automation.

A production system could eventually include real-time monitoring, transaction tracking, Telegram alerts, and more sophisticated execution infrastructure.

But those are separate problems.

Security

If you're experimenting with transaction automation, keep the security model simple.

Never hard-code a private key:

const privateKey = "0x...";

Instead, use a local environment variable:

PONSBOT_PRIVATE_KEY=0x...

and make sure .env is included in .gitignore.

For testing, use a dedicated wallet and only the amount of funds required for the experiment.

Source Code

I've also been building a broader collection of Robinhood Chain trading-bot experiments and development projects.

You can find the repository here:

Robinhood Trading Bot System

https://github.com/Benjam1nCup/Robinhood-Trading-Bot-System

It includes different ideas around sniper bots, copy trading, token launches, liquidity, arbitrage, and automated trading.

If you're building something on Robinhood Chain and want to discuss bot development or this project, feel free to reach out:

Telegram: https://t.me/BenjaminCup

Final Thoughts

What I like about projects like this is that the interesting part isn't always the amount of code.

The real challenge is understanding what the smart contract is doing.

A launch that looks simple from the UI can involve:

Whitelist
   ↓
Launch configuration
   ↓
Dynamic tax
   ↓
Recipient rules
   ↓
launchAndBuy
   ↓
ETH value calculation
   ↓
Transaction simulation
   ↓
Execution

Once you understand those pieces, building automation around them becomes much easier.

This Pons bundler is my small research implementation for exploring those mechanics on Robinhood Chain.

Read the code, verify the contracts, simulate before sending, and keep your private keys under your control.