Bundle Wallets

A bundle is a set of protocol-controlled wallets (PDAs) that perform additional buys alongside the initial buy of a launch. Bundles distribute the launch’s purchase pressure across many wallets in one atomic flow, then let the borrower unwind those holdings on exit.

Bundles are configured per Launch Preset and reused across many launches.

What Bundle Wallets Are

Each bundle wallet is a Program Derived Address (PDA) derived from:

• the seed "bundle"
• the preset’s address
• the wallet index (0, 1, 2, …)

Because the addresses are deterministic, the protocol can sign for them in CPI calls without holding any private keys. There is no individual wallet you control — the protocol does. Your role is to configure how many wallets the bundle uses, warm them up once, then reuse them across launches and drain them when you retire the preset.

The number of bundle wallets is set by Bundle Addresses Count on the preset (program-enforced upper bound). The actual addresses are stored in a per-preset Address Lookup Table (Bundle ALT) so the launch transaction can fit them within Solana’s account limits.

Why Use Bundle Wallets

• Distributed initial fill — instead of one wallet buying everything, buy pressure is spread across N wallets in a single atomic flow. Useful for launch dynamics where having many holders right after launch matters.
• Anti-snipe — combined with Moono’s curve checkpoint and Jito support, bundle buys give you a tightly atomic sequence that snipers can’t easily wedge into.
• Single-action unwind — bundle holdings can be sold via bundle_sell_all_market_0 (per-tx chunks of up to 20 wallets) and the remaining SOL drained via bundle_drain_0.

If you don’t need any of these properties, set bundle_addresses_count = 0 (or launch without a preset) and the bundle layer is skipped entirely.

Lifecycle: warmup once, reuse, drain at retirement

initialize_launch_preset       ← create preset
bundle_warmup_0 × chunks       ← ONE-TIME setup of bundle wallets
═══ reuse across many launches ═══
launch_0 → migrate → complete → bundle_buy × chunks → user_buy → … → repay/liquidate
launch_0 → migrate → complete → bundle_buy × chunks → user_buy → … → repay/liquidate
═══ retire ═══
bundle_drain_0 × chunks        ← closes everything, sweeps SOL to you
delete_launch_preset           ← optional final cleanup

The warmup–reuse–drain pattern is a significant change from earlier versions, where setup happened per-launch. Now setup costs are paid once and amortised across every launch from the preset.

1. Create the Bundle ALT

On the preset page (or during preset creation), set Bundle Addresses Count and click Recreate ALT. The app derives all bundle wallet PDAs and writes them into a new Address Lookup Table owned by your wallet. The ALT address is stored on the preset.

If you later change the bundle count, Recreate ALT (or Amend ALT to add new slots without rebuilding) to keep the ALT in sync.

2. Warm up the bundle wallets

Before the first launch from this preset, run bundle_warmup_0 — a one-time initialization of each bundle wallet’s per-protocol state:

• WSOL ATA on the bundle wallet (so it can hold quote tokens)
• pump.fun user_volume_accumulator (UVA)
• PumpSwap user_volume_accumulator

The warmup is mandatory for any preset whose bundle chunks will be ≥4 wallets on the post-graduation branch — without warmup, those chunks exceed Solana’s 64-instruction trace limit per tx. For presets used only with ≤3 wallets per chunk pre-graduation, warmup is optional (it still saves compute units but isn’t required).

Warmup is idempotent per wallet — safe to re-run on already-warm wallets. Chunk size up to ~6 wallets per tx (ATA creation is heavy).

Warmup is gated on no open loan: the preset’s active_loan must be the default pubkey. Close any open loan first.

3. Fund the bundle wallets

Each bundle wallet also needs native SOL to:

• Cover transaction fees on bundle sell / collect operations
• Provide a small buffer for any additional ATAs created on the fly during trades

The preset page shows a Bundle Wallets table with each wallet’s index, address, ATA, volume accumulator, and SOL balance. Click Fund Wallets to top them up to the recommended baseline. Wallets below the threshold are highlighted.

Funding is a separate transaction; SOL comes from your main wallet.

4. Launch (reuse across many)

When you launch from a preset, the Initial Buy Amount slider splits the loan between the initial buy and the bundle pot. The bundle pot is divided across all wallets per the Bundle Distribution Type (currently only Equal). Each chunk of bundle buys runs as one bundle_buy_universal_0 tx; the app automatically chunks by MAX_BUNDLE_CHUNK_SIZE = 20.

Bundle base-token holdings are tracked in loan.bundled_base_amount separately from the initial-buy collateral. The same preset can power many sequential launches — once each loan closes (repay or liquidate), active_loan releases and the next launch is allowed.

5. Unwind on loan close

On repay, the protocol automatically sweeps the bundle wallets’ base tokens to your main wallet — no separate action needed.

On liquidate, the program requires bundled_base_amount == 0 first. Use one of:

• Sell & Liquidate (loan page) — one click; sells all bundle base via bundle_sell_all_market_0, then liquidates the loan in the same flow
• Sell Selected (preset → Bundle Wallets) — explicit per-wallet selection; useful if you want to stagger sells across multiple txs

The sell/collect actions accept arbitrary subsets of wallet indexes (wallet_indexes: Vec<u16>), so operations can be chunked across multiple txs. Practical limit: ~20 wallets per chunk for sell.

After repay/liquidate, the bundle wallets still hold their accumulated native SOL (unspent funding + ATA rent buffer). That’s recovered at preset retirement.

6. Drain (preset retirement)

When you’re done with a preset, run bundle_drain_0 to:

1. Close the WSOL ATA on each bundle wallet (rent → bundle wallet, unwrapping any WSOL balance to native SOL)
2. Close the pump.fun UVA (rent → bundle wallet)
3. Close the PumpSwap UVA (rent → bundle wallet)
4. System-transfer all the bundle wallet’s lamports to the recipient (your main wallet)

Drain is gated on no open loan, same as warmup. Chunk size up to ~6 wallets per tx.

This is how you recover the rent paid during warmup, plus any leftover funding.

SPL Display

The Bundle Wallets table can show the SPL balance for any mint you choose (default: the launch’s base mint). Click SPL token above the table to switch the displayed mint — useful when checking pre-launch funding or post-launch balances on a different token.

Loan-side Helper

If you reach the preset later with no active loan reference but bundle wallets still hold tokens, click Try to Find Loan to have the app search for a recent loan that used this preset and pre-fill the loan address for sell/collect routing.

Distribution Types

Type	Behavior
Equal (0)	The protocol divides the bundle portion of the loan amount into N equal slices, one per bundle wallet

More distribution types may be added in the future.

Pre/post-graduation routing

Bundle buys and sells go through bundle_buy_exact_quote_in_market_universal_0 and bundle_sell_all_market_0. These instructions are universal — they read the bonding curve’s complete flag at execution time and route to pump.fun or PumpSwap automatically. The Bundle ALT contains both branches’ addresses, so the same ALT works pre- and post-graduation.

You don’t need a separate ALT or workflow when the curve graduates mid-loan.

Tips

• Warm up once per preset — don’t skip this; it amortises setup cost across all future launches
• Recreate ALT after changing count — the ALT must contain exactly the bundle wallet PDAs the program expects
• Top up funding before each launch — funding survives across launches but is consumed by sell/collect fees
• Use Jito for atomicity — without Jito, bundle chunks may land in different slots; with Jito the whole entry bundle lands together
• Drain only at retirement — drain is rent-recoverable; if you plan to launch again from this preset, leave it warm