Borrower Guide

This guide walks you through the full process of borrowing SOL from Moono Protocol to launch a token on pump.fun.

Live values

All numbers on this page (loan limits, fees, durations) are pulled from the current mainnet on-chain configuration at build time. See Economics for the full breakdown and live recalculation examples.

Prerequisites

• A Solana wallet (Phantom, Solflare, or any compatible wallet)
• SOL in your wallet to cover fees and interest (see Economics for exact costs)

You can prepare token metadata in advance, but the app can also generate everything for you in-flow.

Step 1: Register Your Profile

Before your first loan, you need to create a User Profile on the protocol. This is a one-time action.

• Connect your wallet to the Moono app
• Click Register (or the profile creation action)
• Approve the transaction — this costs 0.01 SOL (registration fee) plus a small amount for Solana account rent

The current profile version (v3) also stores a service wallet — an in-browser key derived from your wallet signature. The protocol never spends from it on-chain; it’s used only for off-chain authentication (AI generator, IPFS upload, ALT management). If you registered earlier with v1 or v2, the app will prompt you to migrate to v3 the next time you connect.

The profile tracks your loan history, launch preset list, LP activity bitmap, and assigns sequential loan / preset IDs.

Step 2: Create a Launch Preset

Launches run from a Launch Preset — a reusable on-chain account that holds your token’s metadata, mint, supply, decimals, and bundle wallet configuration. See the dedicated Launch Presets guide for details.

In short, on /presets/new you fill in:

• Launch Configuration — which platform/quote asset combination to use (mainnet today: pump.fun + WSOL)
• Base Mint — generate a fresh keypair, import an existing one, or paste a vanity address; private keys are encrypted and stored locally in the browser
• Base Name / Symbol / URI — token name, ticker, and metadata URI; the Construct button opens a modal that builds the JSON and uploads it (with image) to IPFS
• Base Supply / Decimals — total supply (raw units) and decimals up to 9
• Bundle Addresses Count + Bundle Distribution Type — how many bundle wallets to use and how to split the buy across them
• Bundle ALT — Address Lookup Table that holds the bundle wallet addresses; the app can create or amend it for you

Save the preset, then optionally fund the bundle wallets from the preset page. See Bundle Wallets for the full bundle workflow.

AI generator

On the Construct Metadata modal, click Generate Using AI to have the app produce a name, symbol, description, and image automatically. The result is uploaded to IPFS and the URI is filled in for you.

You only need to do this once per token concept. The same preset can be reused for as many launches as you want, as long as no loan is currently open against it.

Step 3: Configure the Loan

From the preset page, click Launch to open the loan configuration. You can also launch without a preset from /launch/:address — in that case you fill the token fields inline. Either way you set:

Loan Amount

How much SOL the protocol borrows from the LP pool. This is the budget that funds the initial buy and the bundle buys combined.

	Min	Max
Loan Amount	0.1 SOL	2500 SOL

A larger loan means a larger total fill on the bonding curve.

Initial Buy Amount (preset launches)

When launching from a preset, the loan amount is split between the initial buy (the very first buy on the curve, made by the protocol’s execution wallet) and the bundle buys (additional buys distributed across bundle wallets). You can move the slider to choose how much goes to the initial buy versus the bundle.

If you don’t use a preset, the entire loan amount goes to the initial buy and bundle wallets are not used.

Loan Duration

How long you need the loan:

	Min	Max
Duration	1 hour	336 hours

You can repay any time before expiration. After expiration the loan becomes eligible for admin liquidation; self-liquidation is allowed at any time, before or after expiry.

User Buy (optional)

A separate amount in SOL that you spend from your wallet to buy the token in the same atomic transaction as the launch. The protocol guarantees that no third party can buy between the protocol’s last buy and your buy on the bonding curve — this is a built-in anti-frontrun checkpoint specific to Moono.

If User Buy is greater than 0, the app strongly recommends enabling Jito in Profile → Settings. Jito bundles increase the chance that the launch and your buy land atomically.

Token Fields (inline launches only)

If you launch without a preset:

• Base Mint — generate, import, or paste an address (same UX as on the preset page)
• Base Name / Symbol / URI — fill manually or use the Construct modal (with optional AI generator)

Runtime ALT

The launch transaction is large and uses a per-loan Address Lookup Table to fit within Solana’s transaction limits. Click Generate in the form to have the app create the ALT before submitting; on success the field shows the ALT address.

Step 4: Review Costs

Before confirming, review the total cost breakdown. All numbers come from the live mainnet Economics page.

1. Protocol Fee — fixed (0.01 SOL today)
2. Migration Reserve — proportional to loan size
3. Launch Overhead — refundable on close (0.05 SOL today)
4. Interest — depends on loan amount, duration, and which ticks fund the loan
5. Bundle Wallet Funding (optional, separate transaction) — SOL you transfer to bundle wallets so they can pay rent for ATAs and fees

You pay the interest and fees upfront from your wallet. The borrowed SOL is what funds the on-curve buys.

Note

The pump.fun launch configuration uses WSOL for fees and interest. If you don’t have enough WSOL, the app automatically converts the required amount from your native SOL balance. For frequent launches, consider pre-wrapping SOL — see Working with WSOL.

Tip

Use the Check button to dry-run validation (balances, ALT, bundle wallet funding, derived accounts) before clicking Launch.

Step 5: Launch

Click Launch. The app builds an atomic entry bundle — a sequence of transactions sent together (via Jito if enabled). The exact sequence depends on whether your loan amount caps the bonding curve.

How the launch lands

Before submission the app does a pre-flight check: how much SOL would your launch push into the bonding curve, and does that cap the curve (push it over the 85 SOL threshold). One of three things happens:

• All-pre-grad — your total demand fits comfortably below the cap. The launch stays on pump.fun’s bonding curve. launch_migrate_0 and launch_complete_0 run as cheap no-ops in the bundle.
• Cap-path — your initial buy alone is large enough to cap the curve. launch_0 graduates the curve; launch_migrate_0 migrates to PumpSwap; launch_complete_0 spends the leftover SOL on PumpSwap; bundle buys and user buy then route on PumpSwap. All in the same atomic bundle.
• Gray zone (rejected client-side) — total demand crosses the threshold but the initial buy alone doesn’t. The app refuses to submit; the slider asks you to either bump the initial buy above the cap or shrink the bundle/user buy below it. This restriction exists because mid-flow graduation is rejected on-chain.

See Migration for the full conceptual picture.

What the entry bundle does

In the atomic bundle (or Jito atomic bundle), Moono Protocol:

1. Deducts fees and interest from your wallet
2. Borrows SOL from the LP pool, starting from the lowest-cost ticks
3. Creates your token on pump.fun (launch_0)
4. Executes the initial buy on the bonding curve
5. Migrates to PumpSwap if the initial buy capped the curve (launch_migrate_0)
6. Spends the cap-path leftover on PumpSwap (launch_complete_0) — no-op if there was no leftover
7. Distributes the remaining loan amount across bundle wallets and executes their buys (bundle_buy_universal_0 × N chunks)
8. Optionally executes your user buy with the curve checkpoint guarantee
9. Stores the initial-buy and bundle-buy tokens as collateral in program-controlled escrows

After confirmation, the Launch Result panel shows the loan address, the Jito bundle ID (if used), and per-step transaction signatures. Click Go to Loan to open the loan page.

Jito recommended

With multiple txs in the entry bundle, Jito atomic submission gives you the best landing characteristics — either the whole bundle lands or none of it does. Enable in Profile → Settings.

Step 6: Manage Your Loan

Once your token is launched, you have two main paths.

External graduation during the loan

Even if you launched in all-pre-grad mode, other traders can push the bonding curve past the threshold before you close the loan. Moono’s universal buy/sell instructions detect curve state at execution time and route to PumpSwap automatically — so the exit flow works regardless of what happened to the curve while the loan was open. The app inserts a defensive launch_migrate_0 as the first step of the exit bundle to crank a pending PumpSwap migration if needed. It’s idempotent: a no-op when migration isn’t required.

Option A: Repay

Before the loan expires, repay to recover your tokens:

1. Ensure your wallet has enough SOL/WSOL to cover the repayment amount
2. Open the loan page and click Repay
3. Approve the transaction

On repayment:

• The borrowed SOL is returned to the LP pool
• The initial-buy collateral is transferred to your wallet
• All bundle wallet base tokens are also swept to your wallet (changed from earlier versions where they stayed on the bundle wallets)
• The refundable launch overhead is returned
• The loan is marked as Repaid
• The preset unlocks for reuse

Bundle wallets still hold their accumulated native SOL (unspent funding, ATA rent buffer). To recover that, run bundle_drain_0 from the preset page when you retire the preset — see Bundle Wallets.

Option B: Liquidate / Sell & Liquidate

If you want to settle in SOL directly, or if the loan expired without repayment:

• Liquidate — sells the initial-buy collateral (on bonding curve or PumpSwap, whichever is live), repays the LP pool, and distributes any surplus 3-way (LP / platform / borrower — see below)
• Sell & Liquidate — first sells all bundle wallet base holdings via the bundle sell instruction, then liquidates the loan in the same flow; this is the one-click way to fully unwind a launch

Self-liquidation is allowed at any time. The admin may also liquidate after expiration; there is no grace period.

Bundle base must be unwound first

liquidate_0 requires bundled_base_amount == 0 — if your preset had bundle wallets, you must either repay (which sweeps them automatically) or run bundle_sell_all_market_0 before plain liquidate. Sell & Liquidate combines both in one flow.

Liquidation surplus split

When sale proceeds exceed the borrowed amount, the surplus is divided three ways. The shares are snapshotted on your loan at launch_0 time (so admin changes mid-loan don’t affect you). Current mainnet values:

Recipient	Share of surplus
LP (added to per-tick interest pool)	0.00%
Platform (protocol fees)	0.00%
Borrower (your WSOL ATA)	100.00%

surplus           = sale_proceeds − quote_borrowed         (only when positive)
your_payout       = surplus × {surplusBorrowerPct}% (per current mainnet config)

See Earning Strategies for worked examples. The split applies only to upside; LP/platform never take from your principal recovery.

P&L panel

After a loan closes, the loan page shows an audit-trail panel with snapshot fields stored on-chain: launch_lp_interest_paid, launch_protocol_fees_paid, liquidation_lp_paid, liquidation_platform_paid, plus per-tick breakdowns (launch_lp_per_tick, liquidation_lp_per_tick). These let you reconstruct exactly what you paid and what was distributed, without replaying tx history.

Loan Statuses

Status	Meaning
Open	Loan is active; you can repay any time before expiration
Repaid	You repaid the loan and recovered your initial-buy + bundle collateral
Liquidated by User	You (the borrower) triggered liquidation
Liquidated by Admin	Protocol admin triggered liquidation (typically post-expiration)

The loan page also surfaces low-level fields: launch_phase, bonding_curve_complete, quote_reserved, quote_borrowed, initial_quote_buy_amount, initial_quote_buy_remaining, quote_amount_liquidated, bundled_base_amount, remain_base_pool_amount, and the per-tick borrow breakdown.

Tips

• Start small — try a 0.1 SOL loan first to understand the flow
• Use a preset for repeat launches — it saves the metadata round-trip and lets you reuse a vanity mint
• Pre-fund bundle wallets — funding before launch is a separate transaction; without it the launch can’t pay for the bundle ATAs
• Enable Jito for User Buy — without Jito your user buy may land in a separate slot and lose the curve checkpoint protection
• Watch the clock — set a reminder before expiration if you plan to repay
• Factor in all costs — interest is one of several components; check the Economics page for the full breakdown