DEV Community: CoolBB

The One Number in BAM Validator Economics

CoolBB — Tue, 22 Sep 2026 07:34:27 +0000

BAM validator economics are not “MEV tips got a new name.” The only number that explains why ~35% of stake flipped clients is this:

Until 30 September 2026, BAM adoption is paid by Jito protocol revenue diverted into a subsidy pool — not by traders buying preconfirmations.

Miss that and you will price October like September.

Two cashflows, one client

A validator on Agave-BAM or FireBAM sits in two ledgers.

Ledger A — the subsidy (JIP-31, extended by JIP-37).

100% of Jito protocol revenue goes to the BAM early-adopter pool through the end of Q3. Hard cut 30 Sep 2026. After that, that pipe is supposed to return to value accrual (buybacks / burns / whatever the live JIP says). This is why stake went from ~12% in January to ~34% by 9 Sep. Fastest client migration Jito has published. It was a paid switch.

Ledger B — BAM preconfirmations (live 9 Sep).

Helius / Triton sell early committed-orderflow to searchers. Split:

Share	Who	When cash actually moves
30%	distributors	they invoice now
35%	BAM validators, stake-weighted	first expected October 2026
35%	Jito DAO	same cycle

Ledger B is the story everyone wrote last week. Ledger A is why the machines are on. There is a gap: subsidy dies at month-end; validator preconf checks start the month after. Anyone modeling “BAM APR” off September’s client share is mixing a grant with a product that has not paid operators yet.

Classic Block Engine tips still exist. ~98% of stake still sees that auction. BAM share (~34–35%, ~383 validators, ~17 nodes) is the subset that can sell preconfs. Tips on bundles are not replaced. They are a third line item.

What “35% to validators” is not

It is not 35% of Solana MEV.

It is not 35% of Block Engine tips.

It is 35% of preconf product revenue Helius/Triton collect from people who subscribe to the firehose.

If searchers do not buy it, the 35% is 35% of zero. Subsidy did not care whether anyone subscribed. Preconfs do.

Maker Priority Plugin (app-defined ordering) is a fourth product on the same client. Do not fold MPP, tips, subsidy, and preconfs into one “BAM yield” cell. They have different buyers.

Concentration is the second-order risk

Independent BAM scrapes in late September: ~21.8% of BAM stake on the top node, Frankfurt heavy, ~15 regions. Subsidy math is stake-weighted. So is the 35%. A “decentralized client” that pays like a stake-weighted pool will keep paying the same large operators first. Small validators who flipped for JIP-31 should run the October invoice against their own stake weight, not the press-release 34%.

What a bundler / searcher should take

September tip floors are subsidy-era. October is the first month operators need Ledger B (and leftover tips) to justify the client. Expect preconf prices and maybe tip behavior to move when the grant ends.
A BAM leader and a non-BAM leader are different counterparties. Your pack still has to win whichever schedule is next.
DAO 35% is not validator APR. JTO unlocks and buyback policy sit on the token, not in the vote account.

The test on 1 October

If BAM stake holds after the subsidy cutoff and after the first preconf distribution, Ledger B works. If stake leaves in October–November, the 34% was rented.

That hold-or-leave print is the whole validator economy. Everything else is a slide.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

The Latest Jito Update — BAM Preconfirmations Are Live

CoolBB — Tue, 22 Sep 2026 07:17:56 +0000

The Block Engine and 5-tx bundles did not get replaced last week. The new layer is BAM preconfirmations, live 9 September 2026, sold through Helius and Triton.

That is the update that matters if you ship Jito packs for Pump.fun. The rest of mid-September is product and treasury noise around it.

What shipped

BAM (Block Assembly Marketplace) has been on mainnet since late 2025. It is the TEE / plugin path for how a leader builds a block — not just “pay a tip, hope.”

Preconfirmations are the consumer API on that path: you get an early signal that a tx is committed in the BAM pipeline before the slot is public on gossip. Coverage at launch: about 34% of stake, ~383 / 665 validators, ~17 BAM nodes. Independent scrapes around 21 Sep still sit near 34.6%.

Latency claim from the rollout writeups: on the order of 5–10 ms p50 versus waiting for the shred. That is searcher time, not retail UI time.

Revenue split on the preconf product:

Slice	Who
30%	Helius / Triton (they bill you)
35%	BAM validators (stake-weighted, first checks October 2026)
35%	Jito DAO

Opt-out today is manual (Discord). Self-serve comes later. Agave-BAM and FireBAM both count.

Q3 BAM subsidy (100% of protocol revenue to the adopter pool under JIP-37) hard-stops 30 September 2026. After that, value accrual is supposed to flip back on. Do not mix “preconf fees start in October” with “subsidy still pays the client.” Different pipes.

What did not change

Bundles are still ≤5 txs, atomic, sequential, one slot.
You still tip a current tip account.
Block Engine still sees ~98% of stake even where BAM share is a third. Classic sendBundle is not dead.
Maker Priority Plugin (Q2) is a separate BAM plugin for app-defined ordering. Preconfs are a data product. MPP is an ordering product.

Why a Pump.fun bundler should care

Detect vs land is now two markets.

Preconf subscribers see committed orderflow earlier. If you only watch shreds / Geyser, you are late to people who paid Helius/Triton for the BAM firehose. Same create you were going to backrun may already be “preconfirmed” into a pack you cannot reorder.
Your bundle can be preconfirmed too.

If you submit on a BAM-aware path, you get a faster yes/no than waiting for the explorer. Failed packs stop burning the next tip one slot sooner. That is operational, not alpha.
Leaders are not uniform.

~35% stake is BAM. The other ~65% is still classic Jito-Solana / others. A bundle tuned only for BAM nodes misses the leader schedule most of the day. Fan-out: Block Engine regions and the preconf pipe, then accept whichever slot actually fires.
Subsidy cliff is 8 days after this post’s week.

When JIP-37 ends, validator economics on BAM change. Expect tip floors and preconf prices to reprice in October when validator checks actually start. Do not hardcode September tip tables.

What else moved in the last 10 days (not the bundler ABI)

21 Sep: JitoSOL (J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn) listed as collateral on Bullet. LST stays staked while you margin. Unrelated to sendBundle.
Same week: Rettig / Fortune “onchain finance” piece; Jito still hiring for JTX (self-custody trading app that public-launched in July).
~6M JTO unlock around 21 Sep. Token supply ≠ Block Engine.
GitHub: jito-solana, jito-tip-router, stakenet still pushing 22 Sep. Read the client tag you actually run; do not assume preconfs changed tip-account layout.

Practical takeaway

Latest Jito update = BAM preconfs are a paid, partner-gated look at committed BAM orderflow, covering a third of stake, billed by Helius/Triton, validator paid in October.

If your Pump.fun bundler still only does:

simulate pack → tip → sendBundle → wait for signature

you are on the 2025 path. The 2026 path is: sequential curve quotes (still the thing that reverts the atom) plus knowing whether the next leader is BAM, and whether your competitors already saw the create on the preconf stream.

Bundles did not get a sixth transaction. They got a faster rumor about who already won the five.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

The One Thing That Matters in a Pump.fun Jito Bundle

CoolBB — Tue, 22 Sep 2026 06:22:52 +0000

A Pump.fun bundler is not “send create and a buy through Jito.” Jito’s rule is simple: up to 5 transactions, sequential, all-or-nothing, one slot. If ix 4 reverts, create never happened. That is the whole product and the whole way desks blow a launch.

The important technical object is not the tip. It is whether every buy in the envelope is priced against the curve state left by the buy before it.

What the envelope actually is

Typical skilled launch:

create / create_v2
Dev buy
Wallet B buy
Wallet C buy
Tip transfer to a current Jito tip account

Cap is 5. Extra “organic” wallets are a second bundle or a later slot. They are not in this atom. Snipers cannot sit between (1) and (4) only if this bundle wins the Block Engine auction and every tx commits.

People obsess over tip lamports. Tips buy a ticket to the auction. They do not fix a SlippageExceeded on wallet C.

The failure mode that looks like “Jito is down”

Each Pump buy consumes quote and writes new virtual/real reserves. Bundle order is execution order.

Wrong (what most first bundlers ship):

quote(B) = curve at empty
quote(C) = curve at empty
quote(D) = curve at empty
max_sol_cost_* = empty * (1 + slip)

On chain:

create → empty curve
dev buy → reserves moved
B lands on moved curve → still maybe ok
C lands on twice-moved curve → max_sol_cost too low → revert
→ entire bundle dropped, mint never exists

You paid the tip for a simulation that used three copies of the same book.

Right:

S0 = initial virtual reserves (known from create constants)
S1 = apply(dev buy, S0)
S2 = apply(B, S1)
S3 = apply(C, S2)
max_sol_cost_i = quote_needed(Si-1) * (1 + slip_i)
token_out_i    = tokens_out(Si-1, sol_i)   # buy wants exact tokens or exact SOL — pick one and stick

Include 1.25% curve fees in quote_needed. Include ATA create rent on first touch of each signer. Include Mayhem / Token-2022 / buy_v2 account lists if that flag is on. A missing creator_vault or the post–2026-04-28 fee recipient reverts the same way as bad slippage: atomically.

Second, only after the math works: landing

Then the auction matters.

Tip to a live tip account from getTipAccounts, not a hardcoded pubkey from a gist.
Tip size tracks the slot’s competition, not a blog table from January.
Send the same bundle to multiple Block Engine regions. First land wins; duplicates share a hash.
Fresh blockhash (or durable nonce) on every tx in the set. One stale hash = five wasted tips.
Compute unit limit for the fattest tx (create + metadata + ATA) — over the budget and Jito rejects the pack before the leader sees it.

jitodontfront-style guards only matter once the pack simulates clean against sequential state. Protecting a bundle that cannot commit is paying validators to reject you politely.

What people still miss

Quoting all wallets in parallel “to save time.”
Putting 8 buys in one mental bundle. The ninth is not in the atom. Snipers own slot+1.
Dev buy so large that wallets 2–3 cannot fit under any sane max_sol_cost.
Simulating each tx in isolation on RPC (simulateTransaction on create alone, then on a buy against current chain — current chain has no mint yet). You must simulate the pack as a pack, or replay the curve in process.
Treating a landed bundle id as “we got supply.” Read the inner ix errors. Partial mental models do not apply; either all five committed or none did.

How you know you have it

Decode a bundle that landed. Sum SOL in order. Recompute tokens out with the official fee function after each fill. If your off-chain quotes match the TradeEvents within 1 unit, the bundler is correct.

If they only match wallet 1, you do not have a bundler. You have a create tx that sometimes survives because you only sent one buy.

Win the auction after that. Not before.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

How Skilled Solana Launch Teams Hit Trending in 2026

CoolBB — Mon, 21 Sep 2026 06:24:10 +0000

Solana prints tens of thousands of launchpad coins a day. Pump.fun still takes most of that flow. “Trend” is not a badge someone grants. It is a short window score: recent buy notional, unique buyers, market-cap velocity, last-trade recency. Time-decay is aggressive — last 5–60 minutes beat last 6 hours.

Skillful teams do not out-meme 263k daily mints. They feed that score without looking like one wallet, then sell the attention, not the dream.

The rank function they actually optimize

Unpublished, but stable enough that desks converge:

Signal	What the UI wants	What a desk does
Recent buy volume	SOL in, last hour	Real curve buys, not only wash
Unique buyers	many makers	Many signers, small clips
Velocity	MC% up now	Front-load the first 10 minutes
Recency	last tx is now	Bumps so the card does not fall off

A fat bundle with 3 wallets and 40% of supply fails unique-buyer. A wash loop with huge volume and 2 makers fails the same test. The teams that trend use more signers, less size each, then let outside flow fill the rest of the curve.

KOTH cost is just competition: quiet UTC nights maybe tens of SOL of buy flow; US/EU overlap can take hundreds. They pick the window on purpose. Peak hours cost more and convert better. Dead hours are cheap and die on an empty homepage.

Layer 1 — there is no “create then hope”

Default 2026 launch is a Jito envelope: create + dev buy + 2–4 more buys, atomic, same slot. Jito cap is 5 txs per bundle, so extra “organic” wallets are a second wave, not magic.

Why: snipers cannot sit between create and the first fill. The book starts already marked up. Dexscreener / Bubblemaps will still show a cluster if the funder is one treasury — skilled desks randomize size, stagger the second wave by a few slots, and do not park 60% in five keys. Over-bundling gets you supply and suppresses the unique-buyer rank.

Mayhem is a side bet, not the meta. Fee-free agent flow can print a tape and then sell it. Serious teams treat it as optional noise, not the plan.

Layer 2 — two bots, two jobs

Volume = notional for the 1h window.
Bump = last-tx recency so the card stays on the board.

They are not interchangeable. Volume without bumps falls off when a louder coin prints. Bumps without unique buyers look like a heartbeat on a corpse.

Comments and favorites are the same game on the social slot of the Pump page. Phrase-bank comments are readable in five minutes. Teams that still do it mix real TG members in the first 3 minutes so the unique-buyer count is not 100% ATA clones.

Layer 3 — attention is scheduled, not hoped

The CA drops the same second the bundle lands. Pre-written CT, TG primed, image already on Arweave. Delay is how you trend to bots only.

KOL use split in 2026:

Small engaged accounts (narrative-native) before or at T+0.
Large paid call after the coin is already on the board — that call is often the exit liquidity for the bundle, not the discovery.

If the public KOL wallet buys 20 seconds after create and sells inside a minute, you are not looking at a believer. You are looking at the distribution pipe. Track the funder cluster, not the display name.

Dexscreener paid boost is a second homepage for people who never open Pump. Same idea: rent the rank function of a different site once the curve is mid-fill.

Layer 4 — the second venue is the product

Graduation (~85 SOL real on the classic Pump curve, then PumpSwap) is when amateurs disappear and desks keep working. Rank on Pump dies; rank on Dexscreener / Birdeye is now pool volume. The same maker fleet rotates to the AMM. A launch that “died on the curve” and “woke up on PumpSwap” was not organic resurrection. It was a venue change.

Other pads (Letsbonk, LaunchLab / StonkFun-style custom quote coins) are used when the narrative is a stock ticker or a non-SOL pair. Same bonding-curve scoreboard, different quote mint. Teams pick the pad whose front page the target audience already lives on.

What “skill” actually is

Not a bigger Jito tip. The tip only lands the envelope.

Skill is:

Leave float. Enough unique outside buys that the algorithm and the later tape have someone to work with.
Time the decay window. Do not dump the bundle into the same 5 minutes you need unique buyers.
Separate discovery from distribution. Board first, KOL second.
Know which scoreboard you are on (Pump recency vs Dex volume vs quote-asset pad).
Have a sink. SOL comes home to one treasury. Costume wallets do not.

How to read it as a trader

Same-slot create+buys + one funder = desk.

15 makers in 10 minutes with no shared funder = closer to a crowd.

Volume up, unique buyers flat, comments identical = rented tape.

KOL buy after the bundle, hold < 30s = you are the bid.

Trending in 2026 is a manufactured liquidity event aimed at a decaying rank function. The teams that keep doing it treat the homepage as a media buy they settle on-chain. The image and the ticker are packaging.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

How Pump.fun Mayhem Mode Can Backfire a Launch

CoolBB — Mon, 21 Sep 2026 06:20:48 +0000

Mayhem is sold as early volume: flip mayhemMode: true on create_v2, an agent random-walks the coin for 24 hours, leftover inventory burns. Creators turn it on because the chart looks alive.

On the curve, “alive” and “launch-safe” are not the same variable.

What actually gets created

Normal Pump mint: 1B supply, all on the bonding curve.

Mayhem mint:

Total supply 2B (Token-2022).
1B still seeds the curve (same virtual-reserve start as a normal coin).
1B goes to the Mayhem agent (MAyhSmzXzV1pTf7LsNkrNwkWKTo4ougAJ1PPg47MD4e path / disclosed agent wallets).
Flag is immutable. You cannot turn it off after create.
Agent is not guaranteed to trade every opted-in coin. Cap is about 1 trade/sec/mint, size capped, may react to slippage.
Agent trades do not pay protocol or creator fees.
Protocol fees that humans pay on Mayhem coins route to a reserved recipient (GesfTA3X2arioaHp8bbKdjG9vJtskViWACZoYvxp4twS), not the normal Pump fee set — they also stay off fees.pump.fun.
After 24 hours, unsold agent inventory burns. Tokens random people sent to the agent also burn if they were in-window Mayhem inventory.

Fee-tier math uses actual mintSupply, not the hardcoded 1B used for normal coins. Market-cap tiers and “this looks like a $X coin” screens lie if your bot still assumes 1B.

Backfire 1 — the agent is inventory, not a market maker

A market maker quotes two sides and keeps inventory tight. Mayhem is documented as a random walk with equal buy/sell probability, and the disclaimer says sell size can run slightly above or below buy size on a discretionary bias.

On a constant-product curve that is lethal:

Agent buy lifts virtual SOL, snipers and copy-traders print the tape, Telegram calls “organic.”
Agent sell hits the same thin virtual reserves. Humans who bought the up-print are now exit for a wallet that paid zero 1.25% fee.

You paid the fee. The bot that moved the candle did not. Creator fee on those agent fills is zero. You bought volatility and sold your own fee stream.

Users already reported the ugly version: agent flow that pulls SOL off the curve until early wallets cannot sell into anything. That is not “discovery.” That is the reserved 1B being used as a dump clip against a 30 SOL virtual book.

Backfire 2 — price is not a function of the SOL you saw

Decipher’s reconstruction of pre–May 13 2026 Mayhem agent fills is the important technical paper here.

They watched an agent sell that paid ~0.01 SOL while virtual SOL reserves dropped ~34 SOL versus the normal update rule, and spot fell ~63%.

Normal human buy/sell:

virtualSol'  = virtualSol ± solMoved
virtualTok'  = virtualTok ∓ tokensMoved
price        = virtualSol / virtualTok

On the agent path they recovered, virtual SOL was recomputed from post-trade global state, and the agent fill cancels against a term that tracks external users’ net token buys. When that external net is small (exactly the start of a launch), a tiny real SOL transfer can reprice the whole book.

So your sniper quotes getBondingCurve like a normal Pump buy. The next agent ix is not the same state transition. Slippage that looked like 5% is a gap-down. This is why “I simulated 0.05 SOL and it was fine” dies on Mayhem mints.

Treat agent signatures as a different pricing function until you have verified the live program still uses the human update rule for that ix.

Backfire 3 — fake tape, real bundlers

Mayhem volume is not unique makers. Screeners, bump bots, and KOLs still rank tx count and notional. The agent manufactures both.

What arrives:

Agent buy → trending.
Snipers and copy fleets hit the same curve.
Agent sell (or biased sell) + those fleets exiting.
Graduation math still needs real SOL in the curve, not agent round-trips.

You can look busy at 8% of the curve and never graduate. After 24h the leftover 1B burns — that does not rewind the SOL the agent already extracted or the bags humans bought into the print.

Backfire 4 — the integration tax

Mayhem is why half the public snipers revert:

Token-2022 vs classic SPL.
Vault PDAs from the Mayhem program, not the Pump curve ATA.
reservedFeeRecipient instead of global.feeRecipient.
buy_v2 account lists that assume is_mayhem_mode.
Market cap / fee bps computed off 2B supply.

A launch that “should have gotten sniper bid” gets silence because every bot’s ix list is wrong. Silence plus an agent that is allowed to sell is a one-sided book.

What to check before you opt in

Do you need fee-free flow on your own curve for 24 hours?
Can your first buyers sell if the agent’s next fill is a sell with the recompute path?
Are you okay with 2B circulating optics and every MC widget being wrong?
Did you confirm the agent even selected your mint? Opt-in ≠ scheduled.

Mayhem can backfire because it puts a large, fee-exempt, optionally biased inventory on the same virtual reserves your launch price is made of — and in at least one program vintage, it did not even update those reserves with the same formula humans use. That is not extra liquidity. It is a second trader with a different state machine sitting in slot 1.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

Detecting and Grouping Related Wallets on Solana Memecoins

CoolBB — Mon, 21 Sep 2026 06:16:57 +0000

A Kolscan row is one pubkey. An operator is a component in a graph. If you copy addresses one-by-one you will clone the billboard wallet and miss the ring that actually bought slot 0.

This is how you group them on-chain. No off-chain stalking. Signatures, transfers, and program ix lists only.

The graph

Nodes = wallets that touched a Pump / PumpSwap / Raydium mint you care about.

Edges = evidence they share control. Weight the edge by how many independent tests fire.

Then run union-find (disjoint set). Two wallets in the same parent are one persona for copy / snipe decisions.

Do not require every test. Require two independent families: money flow and behavior.

Test family A — money flow

A1. Shared funder (the main edge).

Walk inbound SOL / WSOL one hop. If 8 “unrelated” traders were funded from the same address inside a 15–60 minute window, they are a spray. Stronger if amounts are near-identical or a fixed grid (0.101, 0.101, 0.102).

edge(A, B) += 3 if funder(A) == funder(B)

             and |fundtime(A) - fundtime(B)| < T

             and count(siblings) >= 5

A2. Shared sink.

After sells, SOL lands back on one treasury. Consolidation is quieter than the spray and more reliable. A KOL costume leaves PnL in the public key. A farm sweeps.

A3. Peel chain.

Treasury → W1 → W2 → W3 where each hop only exists to trade once. Treat the leaf as the signer, the root as the person. Copying W3 without the root is how you miss the next leaf.

A4. Rent / ATA payer.

The wallet that paid rent for 40 ATAs is the operator even if those ATAs sit on other signers.

Test family B — same-slot behavior

B1. Jito bundle_id.

Create + N buys with one bundle id = one intent. Label every signer in that envelope insider_bundle for that mint. They may never share a funder you have indexed yet. The bundle is enough.

B2. First-buyer co-occurrence.

For each mint, take wallets that buy in slots [create, create+K] (K = 2 to 8). Build an undirected graph: edge if two wallets co-appear in that window on ≥ N distinct mints (N = 3 is already loud; N = 8 is a desk).

This is how persistent sniper rings show up: they are not funded the same morning every time, but they keep arriving together.

B3. Same compute budget + tip shape.

Identical CU limit, identical tip account class, identical buy_v2 account order bugs. Weak alone. Strong with A1 or B2.

Test family C — trade geometry (wash vs trader)

C1. Round trip.

Same wallet buys and sells the same base amount inside one tx, or within a few seconds at the same curve price. That wallet is a volume machine. Do not put it on a “smart money” list.

C2. Ping-pong.

A buys, B sells the same size, funds return to A. Two nodes, one inventory.

C3. Inventory vs volume.

net_sol_in ≈ 0 across 50 swaps of one mint, but 24h volume is huge. Cluster as washer, not sniper.

Union-find recipe

parent = {w: w for w in wallets}

def find(w):

while parent[w] != w:

    parent[w] = parent[parent[w]]

    w = parent[w]

return w

def union(a, b):

parent[find(a)] = find(b)

for (a, b, score) in edges:

if score >= THRESHOLD:

    union(a, b)

Store on the component:

size
root funder / root sink
mints in common
median entry_slot - create_slot
median hold slots
fraction of buys that share a bundle with create

A component with median_hold_slots < 50 and bundle_with_create > 0.3 is a launch desk. A component with long holds, many mints, no create-bundle overlap is closer to a real trader. Copy only the second, and even then as a classifier (this mint has informed flow), not a market order.

What people skip

Clustering only by “bought the same coin.” That merges the whole front page.
Using 24h PnL before the graph. The billboard wallet is often the last hop.
One-hop funding and stopping. Peel chains exist so that hop looks clean.
Ignoring sells. The sink is the identity.
Treating each mint independently. Rings are cross-mint.
Copying every signer in a component at full size. You just cloned the farm’s impact.

How I check a cluster is real

Pick 20 mints the component touched. For each mint list first 16 buyers. If the same 4–10 component wallets occupy that window again and again, it is not coincidence.

Then replay: remove the component’s own buys from “organic flow.” If the mint had almost no other buyers in 30 minutes, the cluster was the market. Copying them is buying their bag.

Last sanity check: destroy the public KOL address and see if the component still trades next week. If yes, you grouped the desk. If the graph dies with the tweet wallet, you grouped a costume.

That component id — not the Kolscan handle — is what a sniper watchlist should store.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

Tracking KOL / Smart-Money Wallets for Memecoin Snipes — What People Don’t Solve

CoolBB — Mon, 21 Sep 2026 06:13:58 +0000

Copying a Kolscan / GMGN / Dexscreener “top wallet” feels like sniping with a brain. On a bonding curve it is usually buying the same person’s exit.

The technical job is not “subscribe to a pubkey and buy the same mint.” It is answering three questions before you fire:

Is this wallet a trader, a bundled farm, or a caller dumping into followers?
Did their fill happen on the curve, in a Jito envelope, or after graduation?
Can your tx arrive close enough that the curve move they caused is still smaller than their edge?

If you skip any of those, you are not tracking alpha. You are indexing someone else’s distribution.

What to track (the actual objects)

A useful watchlist is not Twitter handles. It is:

Signer set — one persona is 5–40 wallets. Funding graph first, PnL second.
Venue — Pump program 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P vs PumpSwap pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA vs Raydium. Copying a curve buy through an aggregator hop is a different trade.
Slot distance — their buy slot vs first public mention vs your land slot.
Hold clock — entry signature → first sell of that mint. Median copied Solana meme holds are measured in seconds, not hours.
Size in curve space — SOL in as a fraction of real_sol_reserves, not USD PnL screenshots.

Detection path that is late by design: REST leaderboard → Telegram alert → human tap. Path that can even see the trade: Yellowstone / shred filter on those pubkeys, decode buy / buy_v2 / sell from the ix list, no second RPC of the curve.

What people miss

The imitation penalty is math, not lag.

On a constant-product curve, the next buyer always pays a worse average than the last. A paper that copied “smart money” on ~6k meme coins still saw the source green and the copier red under the same rules. Faster copy shrinks the gap. It does not delete it.

Leaderboard PnL is the wrong random variable.

Mean PnL is one 50x plus nine deaths. You want median trade, sample size (hundreds, not 12), token diversity, and realized SOL back to a sink — not mark-to-curve on inventory they never sold. Wash loops inflate win rate: buy and sell the same size, net position ~0, volume and “trades” look elite.

The wallet you copy is rarely the wallet that ate the cheap supply.

Dev bundles 5 txs in one Jito envelope (create + buys). Cohort rings co-fire in the first-buyer window across many launches (research has pulled 1,000+ persistent 2–12 wallet rings on Pump.fun). The public “KOL” address buys 20 seconds later for the screenshot. You copy the screenshot wallet.

Followers are the product.

A wallet with 1,500 copiers is a known order. Sandwich searchers love identical direction + predictable size. Hold times around 20–25 seconds plus a tweet is not skill. It is a pipeline: accumulate quiet → announce → sell into copies.

You copy the buy and sleep on the sell.

Their edge is often the exit. Your bot mirrors entry, then holds because “the KOL is still in” — while they already rotated to a sibling wallet. Cluster the graph or you will invent conviction they do not have.

Size does not scale.

Their 0.3 SOL into a 4 SOL curve is not your 5 SOL into the same curve after 40 copiers. Impact is Δx / (x + Δx). Copy ratio without reserve context is how you become the candle.

Wrong chain of custody for “smart money.”

CEX → mixer → 40 fresh wallets → one “clean” trader. If you only watch the last hop, you label a farm as a genius. If you only watch the tweet wallet, you miss the farm that actually sniped.

How I figured it out

Not from a leaderboard. From joining their signature to the mint’s first 32 slots.

Build the person, not the address.

For every “smart” pubkey, walk inbound SOL one hop. Group wallets that share a funder inside a few hours and reuse the same program id + similar max_sol_cost. Union-find on co-occurrence: wallets that appear together in the first-buyer window of many different mints are a ring, not 12 independent alphas.
Score the fill, not the PnL tile.

For each of their buys: slot of create, slot of their ix, real_sol_reserves before their fill (from the parent tx or pre-ix state), SOL in, tokens out, slot of first sell. Wallets that are green only when entry_slot - create_slot ≤ 2 and hold_slots < 50 are snipers or dumpers. Copying them with +8 slots is buying the dump.
Split bundled vs organic.

Same Jito bundle_id as create → insider. Same-block non-creator buys with a shared funder → farm. A lone buy 15 slots later from a wallet that also pays a known fee program of a Telegram bot → copy-of-a-copy. I stopped treating those three as one “KOL class.”
Replay myself as the copier.

Take their historical buys, shift them +1 / +3 / +10 slots, fill against the next curve state (or the next on-chain swap). That curve is the real backtest. The leaderboard is theirs. The shifted tape is yours. The delta is the tax you will pay in production.
Watch the sink.

Profitable farms consolidate to one address. Callers leave inventory in the public wallet until the reply guys finish buying. If SOL does not come home, the PnL is a costume.

The sniper use of this stack is narrow: treat a clustered wallet as a launch classifier (this mint has informed flow), not as a market order to clone. If their buy is inside the create bundle, you already lost the cheap side. If it is a quiet wallet with long holds, diversified mints, and a funder that is not a mixer spray — then you have a signal worth racing. Everything on the front page of a copy-trade app failed at least two of those tests.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

Pump.fun Snipers — The One Technical Thing That Actually Matters

CoolBB — Sun, 20 Sep 2026 06:46:56 +0000

People treat a Pump.fun sniper like a latency toy. Faster gRPC, fatter Jito tip, more endpoints. That is how you lose slower.

The thing that actually decides the trade is this:

The create transaction is already the full buy template. If you wait for a second read of the curve, you are not sniping. You are auctioning leftovers after the atomic bundle.

What the chain actually does

A launch is create / create_v2 on 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P. Bonding curve PDA is deterministic:

bonding_curve = PDA(["bonding-curve", mint])

CreateEvent already carries mint, creator, quote mint, mayhem/cashback flags, virtual reserves. A serious buyer never calls getAccountInfo between detect and send. They patch a pre-built buy / buy_v2 at fixed byte offsets and fire.

Creators know this. In 2026 the default defense is a Jito bundle: create + creator buy + N wallet buys as one atomic envelope. Nothing inserts between those instructions. Your earliest legal slot is after that envelope. “Block 0 snipe” against a bundled launch is a slogan. You are block 0 of the remainder.

Virtual reserves start around 30 SOL / ~1.073B tokens. Real tokens sold on the curve are the usual ~800M-class slice. Price is the product, plus 1.25% on every fill (0.30% creator + 0.95% protocol on the curve). You pay that on the way in and on the way out.

Why people miss

They listen to the wrong layer.

logsSubscribe and third-party “new coin” APIs are late. Some feeds still drop tx v1 creates. Shred / Geyser sees the create bytes in the first shred of the segment, not after the block is cooked. If your detector is HTTP, the bundle already landed.

The instruction layout moved and their tx never simulates.

Pump is not a stable ABI. buy vs buy_v2 (27 accounts). Creator vault. Volume accumulators. Fee program. The 2026-04-28 trailing fee-recipient account. USDC-paired curves that reject SOL. A bot that still sends the 2025 account list fails 100% of the time and still burns priority fees. Misses look like “RPC is slow.” They are InstructionError.

They quote a curve that no longer exists.

By the time a Telegram bot paints the mint, the bundle already lifted virtual SOL. Your 5% slippage is a coin flip against 16 bundled wallets. Simulation used empty reserves. Execution used post-bundle reserves. SlippageExceeded. You paid the tip anyway.

ATA + compute.

First buy must create the ATA. That extra ix + account data size limit is why “it worked on paper” dies in the slot.

Why people lose after they “win”

Landing a fill is not a PnL.

Graduation is rare (often <1%). Most snipes are inventory in a token that dies at 3% of the curve.

The other side of your bid is the same desks. They exit into you.

Jito tip + priority + 1.25% × 2 + the Telegram bot’s 0.5–1% is a tax on attempts, including fails.

You sized like you were first. You were tenth through the same product. Tokens per SOL collapsed; your average is already mid-curve.

Speed without an exit that does not share the entry cluster is just a faster donation.

How I figured it out

Not from a vendor blog. From the txs that landed versus the ones that did not.

Diff a bundled launch against a naked create. Same program, same slot shape. One has create then N buys in one Jito bundle. The other is create-only. Every “I was first” fill I logged sat after the first pattern. Once you see that, racing Yellowstone against a bundle is a category error.

Replay failed signatures. The error was almost never “lost the race.” It was missing creatorvault, wrong fee recipient after Apr 28, stale buy instead of buyv2, or maxsolcost computed on pre-bundle reserves.

Time the path. Detect timestamp (shred 0) vs signed send vs landed slot. Code after the event was microseconds. The hole was: RPC fetch of the curve, ATA rent check, fresh blockhash wait. Remove those and you still lose to atomic order, not to 2 ms of RTT.

Watch net SOL on the curve, not volume. Wash and snipes both print volume. Only one moves realsolreserves from new wallets. When volume spiked and unique funders did not, the “snipe” was circular. Exit liquidity was a ghost.

The important technical object is not the sniper. It is the create transaction as a closed set of accounts. Decode that set, pre-sign against it, and treat a Jito create+buy envelope as a filled book. Everything else is paying Solana to learn the same lesson again.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

Volume Boosters on Pump.fun — What They Are, Why They Exist, What They Don’t Buy

CoolBB — Sat, 19 Sep 2026 16:59:27 +0000

A “volume booster” on Pump.fun is not a market maker in the exchange sense. It is a paid fleet of wallets that buy and sell the same mint so the coin’s volume, tx count, and sometimes holder count move. The product exists because the homepage is an auction for attention.

Pump.fun ranks the live board (trending / King of the Hill) on a mix of recent buy volume, velocity, unique traders, and tx frequency. Exact weights are unpublished. Operators inferred the rest: if the list is scored on activity, you can rent activity.

Two different machines

Do not mix these up.

Tool	What it optimizes	Typical pattern
Volume bot	SOL notional on the curve or PumpSwap	buy → sell loops, sized to print “24h volume”
Bump bot	recency / tx count	tiny buys so the coin keeps “last traded now”

Same industry. Different scoreboard. Volume without bumps can still fall off the front page. Bumps without volume look like a dead chart with a noisy tape.

After graduation the same desks switch venue: curve → PumpSwap (or whatever pool the mint landed in). DexScreener / Birdeye still sort on volume, so the incentive does not end at the curve.

What actually hits the chain

Conceptually: fund N throwaway wallets from a treasury, jitter size and delay, buy the curve, sell some or all back, recycle SOL, optionally drop comments and “favorites.” Fees and slippage are the burn rate. You are paying Pump.fun (curve fee is SOL-denominated) plus Jito/priority plus the desk’s cut (vendors advertise flat percents of target volume or per-maker fees).

That last part matters. Wash volume on the bonding curve still pays real SOL fees. It is expensive theater. Wash volume on some PumpSwap pools is a different animal: if a washer makes their junk token the quote, they can inflate notional while paying fees in a token they print. Blockworks-style filters exist because raw PumpSwap volume and fee-wallet inflows diverge hard. Protocol revenue is the fee wallets, not the unfiltered ticker.

A 2026 arXiv pass on pump.fun still found millions of wash-shaped txs (tight buy/sell, same cluster) and a higher graduation rate on coins that ran them. That is a ranking exploit, not proof of buyers.

What it does not buy

Holders who stay. Makers that round-trip are not a community.
A bid when the bot stops. The chart gap after the session is the tell.
Safety from screeners. Clustered funding, identical size bands, comment spam, 200 “holders” with the same parent — terminals show this now.
Legal cover. Coordinated wash to mislead a market is market manipulation in a lot of jurisdictions. This article is how the metric works, not a playbook.

How to read a boosted tape

Look for:

Volume up, unique funded wallets and net SOL into the curve flat.
Buys and sells paired in time from wallets that were dusted from one source.
Graduation, then an empty PumpSwap book.
Comments that read like a phrase bank.

Organic KOTH still happens — real SOL in, holders that do not recycle, curve progress that survives a 30-minute pause. Boosters exist because that is rare and the UI pays for the fake version of it.

If you trade these boards, treat 24h volume as a visibility score, not demand. If you launch, assume anyone who can read a funding graph will discount rented tape. The only volume that survives the bot turning off is the volume that was never the bot.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

Why Ponsfamily and Robinhood Chain Memecoins Are Cooling

CoolBB — Sat, 19 Sep 2026 16:48:14 +0000

This is not “Pons is dead.” It is a cooldown after a two-month blow-off.

Early September: Pons printed days near $6M fees and $500M+ launch volume, briefly ahead of Pump.fun. Robinhood Chain logged a $6M fee day (Sep 4) and week DEX volume around $12B. PONS tagged an ATH near $0.97 (Sep 5). Tens of thousands of tokens launched in a single day.

Mid-to-late September: Pons V2 curve volume sat near $113M on Sep 13 and ~$50M on Sep 17–18. Daily fees slid from the $5–6M spike toward ~$3M. On Sep 19, GMGN showed a broad 12-hour drawdown across the stack: PONS >7% (MC ~$687M), AI ~14%, BONER ~15%, MEME ~13%, SHROOM ~20%. CMC framed PONS −10% on a report of a sharp drop in Robinhood Chain fee income.

Cooling is real. Collapse-to-zero is not what the 30-day tape says — Pons still did ~$2.2B V2 curve volume and ~$135M fees over 30 days. The story is mean reversion after a subsidy-fueled mania.

Why it cooled

1. Meme seasons are inventory cycles.

Pons minted on the order of hundreds of thousands of tokens since July. Graduation has hovered near 1–1.5%. Most names never leave the curve. Traders rotate into this week’s mint. A Dune cut already showed >50% of a week’s DEX volume in tokens that had zero volume the week before. When the new-mint firehose slows, charts look empty even if the protocol is still large.

2. The token is a leveraged fee token.

~70% of the 1% trade fee goes to creators. Protocol share funds PONS buybacks/burns (team has cited ~80% of protocol revenue; ~29–31% of supply burned by mid-September). That loop runs forward in a boom and backward in a fade: less volume → less burn → weaker bid → more selling in names that only existed as a fee multiple.

Same trap on “coin-equity” memes (stock-paired names, holder dividends). Those payouts are just fee residue. Volume down, dividend story dies. Ignas said that out loud before this dip.

3. Attention left the chain, not just the pad.

StonkFun on Solana took the stock-pair meme and LaunchLab narrative in the same window Pons peaked. Launchpad traders are one roster. They do not need Robinhood Chain if Solana is printing the same ticker against SPYx with better wallets and faster social density.

4. The free-gas clock.

Robinhood Chain’s 90-day gas waiver (from Jul 1) is slated to end ~Sep 30. Sub-$1 launches and washy volume only exist while blockspace is a gift. Markets price the end of a subsidy before the date.

5. V2 made the casino slower on purpose.

Snipe tax (99% → 0% in seconds), reserved pool slice, ~1% graduation. That cut the “same-block free money” flow that inflated July–August prints. Healthier microstructure, lower bot volume. Both can be true.

6. Peak fees per user were unsustainable.

The Block noted fees per active account jumping from ~$0.13 in mid-August to ~$15.90 by early September while daily actives did not rise as fast as fees. That is the same users pressing harder, not a new nation onboarded. Mean revert that intensity and fees fall even if wallet counts look “fine.”

How to read it

Signal	Peak (early Sep)	Cool (mid/late Sep)
Pons daily fees	~$5–6M	~$3M
Pons V2 curve vol	$100M+ days	~$50M
PONS	~$0.97 ATH	~$0.60 area
Chain story	“new pump.fun”	rotation + gas cliff

A cooldown is default after a pad does Pump.fun numbers in week eight on a new L2. What matters next is not a 12-hour red candle. It is whether quote-asset pairs and graduated V4 pools still trade when gas is no longer free, and whether burns still clear when daily fees live at $2–3M instead of $6M.

Do not annualize the peak. Do not write the chain off at $50M/day of curve flow either.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

StonkFun Bonding Curve Math (LaunchLab, Not a Custom AMM)

CoolBB — Sat, 19 Sep 2026 14:54:22 +0000

StonkFun is a Solana launchpad that pairs a new mint with any quote the UI allows: SOL, tokenized stocks (SPYx, NVDAx), pre-IPO tokens, or other crypto. Since early September 2026 new launches do not open a one-sided CLMM first. They run on Raydium LaunchLab (LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj), then migrate_to_cpswap into a Raydium CPMM at the 0.25% fee tier.

The curve math is LaunchLab’s constant-product engine. StonkFun’s product surface is the quote asset and two platform configs.

What gets minted

Supply: 1,000,000,000 tokens, 6 decimals, Token-2022.
Sold on the curve: 793,100,000 (79.31%).
Held for the pool: 206,900,000.

Those 206.9M plus the raised quote seed the CPMM. That is why you can read progress from the base reserve alone:

progress% = 100 - ((baseReserve - 206_900_000) * 100 / 793_100_000)

Do not hard-code “85 SOL” as the only finish line.

Graduation is a quote amount, not a ticker

total_quote_fund_raising is set at initialize_with_token_2022 from a fixed dollar target, converted into the chosen quote at launch time.

UI copy for SOL pairs: raise 85 SOL, then graduate. Same dollar size in another asset is a different number — roughly 0.112 WBTC or ~11.5 SPYx in published examples, and it moves with the quote’s price. Always read the launch args.

Configs:

Mode	Platform config	Extra
Standard	`4E876qZTE9FJMrBzgVtBrSrzz2TLivB5Y5QXPjB4gZL7`	no transfer tax
Reward	`6BwHHDg3u1854jC8PDLXvR4spTcLNaoBxLJNGC4nTESt`	Token-2022 transfer fee 1% or 3%

Reward tax is on transfers, not a second AMM fee. It is a separate haircut after the curve.

Price = constant product in the quote

$$x \cdot y = k$$

x = quote reserve (SOL, SPYx, …). y = tokens still on the curve.

Curve fee is 1% of the quote leg (fee_rate = 10_000 / 1_000_000 on the platform config):

Buy: fee comes off quote before the product.
Sell: fee comes off quote after the product.

Raydium’s 0.25% (RAY buyback) is taken from that 1%, not stacked on top. Creator curve-fee rate on LaunchLab is 0 in the documented StonkFun configs; the site’s “~0.5% to creator, auto-forwarded” is the platform payout path after the split, including post-graduation pool fees — confirm live config per launch.

Net buy sketch:

netQuote   = quoteIn * (1 - 0.01)
tokensOut  = y * netQuote / (x + netQuote)

A buy that would pass the reserved 206.9M is the graduation trade; after migrate_to_cpswap the curve stops.

What bots get wrong

Treating every pair as SOL. You pay in the quote mint.
Using 85 SOL on a SPYx curve.
Ignoring Token-2022 transfer fee on reward mints when simulating a sell.
Routing to CPMM while the pool account is still the LaunchLab curve.
Assuming first-slot snipes work like the old one-sided CLMM path. The curve is the sniper tax.

Detect: initialize_with_token_2022 whose accounts include a StonkFun platform config. Sixth account = pool state, seventh = base mint, eighth = quote. Graduate: migrate_to_cpswap on the same program.

Same (k) as every other LaunchLab pad. The StonkFun-specific math is which reserve is (x), and that 793.1 / 206.9 split.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site

Ponsfamily V2 Bonding Curve Math (What Your Quoter Must Mirror)

CoolBB — Fri, 18 Sep 2026 10:01:16 +0000

Ponsfamily V2 does not price on a Uniswap pool first. The full supply mints to a constant-product bonding curve that already trades in the same quote asset the future V4 pool will use (native ETH or pairToken). Graduation later seeds that pool from the curve’s real reserves — no router, no oracle.

There is no quote() on the curve. You rebuild the price from getReserves(), feeBps, creatorTaxBps, sellableTokens(), and currentSnipeTaxBps(recipient).

Invariant

The curve is Uniswap-v2-style:

$$x \cdot y = k$$

x is the quote reserve (phantom + real). y is the token reserve. A phantom quote reserve sets the opening price so the first buy is not free. realQuoteReserve() is what actually arrived from traders; graduation watches that against the launch’s threshold.

Core output (from PonsV2BondingCurveMath):

$$
\Delta y = \frac{\Delta x_{\text{net}} \cdot y}{x + \Delta x_{\text{net}}}
$$

On-chain they pass feeBps = 0 into the AMM helper because fees are applied on the quote leg first, not inside the product.

Buy: fees come off the input

Order of operations on buy(quoteIn, minTokensOut, recipient):

Read snipe tax for this recipient (decays from 99% toward 0 over ~5s; exempt addresses skip it).
Take protocol feeBps and optional creatorTaxBps from the quote spent.
Feed what remains into getAmountOut.
If the buy would eat the reserved graduation slice, fill only sellableTokens() and refund the rest.

Sketch:

spent     = quoteIn                       // may clamp to sellable
snipe     = spent * snipeTaxBps / 10_000  // buys only
fee       = spent * feeBps / 10_000
tax       = spent * creatorTaxBps / 10_000
netIn     = spent - snipe - fee - tax
tokensOut = getAmountOut(netIn, quoteReserve, tokenReserve, 0)

Caps: curve fee ≤ 10%, creator tax ≤ 10%, total trade fee ≤ 20%, snipe start ≤ 99%. A taxed buy still nets something.

Sell: fees come off the output

Sells never pay snipe tax.

gross     = getAmountOut(tokensIn, tokenReserve, quoteReserve, 0)
fee       = gross * feeBps / 10_000
tax       = gross * creatorTaxBps / 10_000
quoteOut  = gross - fee - tax

When readyToGraduate() is true, sells revert (CurveGraduated) even before graduate() runs. The curve is already holding pool seed; selling would move the price the pool is supposed to inherit.

Graduation price

After drain, PonsV2GraduationMath seeds V4 with

$$\texttt{sqrtPriceX96} = \sqrt{\frac{\text{amount1}}{\text{amount0}}} \cdot 2^{96}$$

from the curve’s final token and quote amounts. Full-range position. Same quote asset the curve already collected.

What a bot gets wrong

Quoting like V3 / V4 before phase == 0 (still on curve).
Putting fee inside getAmountOut and subtracting it from quote (double fee).
Ignoring phantom vs real quote when estimating “how close to graduate.”
Buying at t=0: ~99% snipe tax vs ~1–3% a couple of seconds later. Price impact rarely outruns that decay unless the curve is already graduating.

Read reserves, subtract quote-leg haircuts, then run the product. That is the whole market until the pool exists.

Telegram: https://t.me/C00LBB

Site: https://coolbb.site