Custom Bundle

Custom Bundle launches a token you own that isn't trading yet. In one run it whitelists your bundle wallets, calls your contract's open-trading function, and buys from every bundle wallet right after. Base has no bundle market, so Execute offers two modes (see Launch modes on Base below). Burst, the default, sends the whitelist, the open and each wallet's buy as separate transactions in one ordered batch, so buys look organic. Atomic puts all of it into ONE EIP-7702 transaction, so nothing can land in between.

The wizard has six steps: Token → Keys → Recipients → Distribute → Review → Execute. You can open any step at any time, and each button checks you have what it needs. The URL keeps ?bundle=<id>, so if you leave, a banner offers to Continue → your unfinished bundle. You can also reopen it from Manage.

#Step 1 — Token

• Token contract address: a live preview shows name, owner, the ETH and tokens on the contract, and the pair status.
• Max Tx % (default 1): the share of supply each bundle wallet aims to buy. It also sets how much ETH Master needs.
• Randomize buy amounts (0–50 %, default 15): each wallet buys a random amount between (100 − x)% and 100% of its Max Tx target, so the launch doesn't show N identical buys that bundle scanners flag instantly. 0 makes every wallet buy exactly the target. Wallets are still funded for the full target, so nothing comes up short.
• Contract trading function: the default is enableTrading(). Other presets are openTrading(), openTrade(), OpenTrade(), launch(), startTrading(), StartTrading(), startTrade() and activate(). Choose ✎ Custom function name... for anything else. It must take no arguments.
• Pre-launch whitelist function (optional): use this if your contract blocks non-whitelisted buyers at launch. Find in My Contract searches the bytecode for common names with the (address[],bool) signature, such as configureLaunch and whitelistBundle.
• Service fee tier: see Fees.

#Step 2 — Keys

Paste the Deployer (Owner) key and click Check Ownership. You get ✓ Ownership confirmed, or a warning if the key doesn't match the owner the contract reports. Paste the Master key and click Use this wallet. Keys can have the 0x prefix or not.

#Step 3 — Recipients

• Generate new wallets or Import my wallets. Generate creates fresh wallets on the server. Import takes your own private keys, one per line (with or without 0x, up to 100); they are encrypted and stored like generated wallets and buy in the order pasted. Imported wallets that already hold ETH count toward funding, so you can use Skip (already funded) on step 4.
• Number of wallets: 1–100 (default 35). With Import, it is the number of keys pasted.
• Initial liquidity ETH (default 1) and Token % (default 80): what you will have seeded into the contract. Used to price the buys.
• Generate N Wallets creates the bundle wallets on the server and adds your tier's service wallets at the end. Regenerating replaces them, and is refused while any old generated wallet still holds ETH (imported wallets are yours and keep their keys, so they don't block it).
• The cost box prices each wallet in order against the pool (progressive cost) and compares the total with Master's balance.
• Show key reveals a bundle wallet's key after you confirm once. Service wallet keys are never shown.

#Step 4 — Distribute

Fund wallets sends one Multicall3 transaction from Master that gives every wallet its exact amount plus 0.0005 ETH per wallet (its own buy gas, Base's L1 data fee and a later sell) for gas. The bundle becomes funded, which Execute requires.

#Step 5 — Review

Check the token, trading function, Deployer, Master, wallet count and funding status. 🧪 Simulate Bundle dry-runs three calls without gas or keys: the whitelist call, the open-trading call, and a 0.001 ETH sample buy. The sample buy usually shows expected — trading not open yet, because it runs against the current state.

#Launch modes on Base

Base has no public mempool and no bundles (no eth_sendBundle). On step 6 you pick how the launch goes out:

Why Burst is safe with your own token

A Clog or Standard Tax token from Deploy Token has an anti-snipe window (15 blocks, about 30 seconds, by default). During it only whitelisted wallets can buy. Execute whitelists every bundle wallet before it opens trading, so any other buy in that window simply fails, even if it lands between your transactions. Our tests on a Base fork check exactly that: a non-whitelisted buy right after the open is refused.

Burst with someone else's token

Nobody sees your open-trading transaction before it is in a 200 ms Flashblock, and the sequencer orders a Flashblock by priority fee, then arrival. Burst gives every transaction the same fee and sends them together, so your buys usually land right behind the open, in the same block. The remaining risk is a buy that misses that Flashblock and competes in the next one, where snipers who saw the open can be too. If you need a guarantee there, use Atomic.

How Atomic buys from many wallets in one transaction

For the launch, the Deployer and each bundle wallet temporarily point their account at TokenBundle's small LaunchDelegate contract (EIP-7702). The Deployer's one transaction then makes the token calls, and each wallet's buy runs as that wallet, with its own ETH. LaunchDelegate only runs a buy the wallet's own key signed, once, before a deadline; it has no owner and can't move funds on its own. Right after the launch every delegation is revoked.

#Step 6 — Execute

Above Simulate Bundle a balance check shows whether the Deployer can pay gas for the launch transactions and the Master can pay the service fee, with Refresh balances. Execute stays disabled while the Deployer is short. A Master warning can be ignored if a previous attempt already paid the fee: it is charged only once.

1. Service fee
   Master pays the tier fee to the TokenBundle treasury in a separate transaction first. It needs the fee + 0.0002 ETH. The fee is charged once: if you retry, it is not charged again.
2. Sign everything in advance
   Whitelist call (every bundle wallet, including service wallets), open-trading call, and one Uniswap V2 buy per wallet. Each wallet buys exactly its Max Tx % of supply, priced in order against the pool as it will be after open (the token's own launch tax, such as Clog, included), with 3% tolerance. The rest of its ETH stays for a later sell.
3. Simulate before sending
   Every signed transaction (Burst) or the single launch transaction (Atomic) is dry-run in order on a Base RPC. If anything would fail, nothing is sent.
4. Send to the Base sequencer
   Burst: one ordered batch straight to the Base sequencer, same priority fee on every transaction. Atomic: the one transaction goes to the sequencer, then every wallet's temporary delegation is revoked.
5. Done
   You get X/N buy(s) succeeded, a hash or error per wallet, and Open Terminal →. The launch appears in Overview with its PNL.

Bundle lifecycle

draft → wallets_generated → funded → executed. An executed bundle can't be reopened. You can delete a bundle from Manage only once every bundle wallet is empty.