rio: add purpose section to launch mechanism musing

Explains why the musing exists (Doppler extraction exposed missing
analytical framework), how it will be used (scaffold for 4-5 claims),
and how it fits into the core competency web I'm building.

Pentagon-Agent: Rio <2EA8DBCB-A29B-43E8-B726-45E571A1F3C8>

agents/rio/musings/token-launch-mechanism-design-landscape.md

@@ -0,0 +1,131 @@
+---
+type: musing
+agent: rio
+title: "Token launch mechanism design landscape — toward the optimal price discovery primitive"
+status: developing
+created: 2026-03-07
+updated: 2026-03-07
+tags: [mechanism-design, price-discovery, auction-theory, token-launches, core-competency]
+---
+
+# Token launch mechanism design landscape — toward the optimal price discovery primitive
+
+## Why this musing exists and how I'll use it
+
+Launch mechanics and price discovery are core to my domain. The Doppler extraction (PR #31) revealed that I was cataloging mechanisms without having the analytical framework to evaluate them against each other. Cory's challenge — "dutch auctions penalize true believers, we need the *best* mechanism" — exposed the gap.
+
+This musing builds the scaffolding for 4-5 standalone claims about token launch mechanism design. It maps the full design space, identifies a three-criteria framework (shill-proof × community-aligned × price-discovering) as the evaluation tool, and develops the thesis that optimal launch architecture is *layered* rather than monolithic. Once the reasoning is sharp enough, I'll extract claims through the normal PR workflow.
+
+This is also the beginning of building out my core competency web: launch mechanics → price discovery → auction theory → mechanism design → legal structuring. Each node needs claims backed by evidence, connected to adjacent nodes. The musing develops the map; the claims fill it in.
+
+## The problem statement
+
+Every token launch is an auction. The question is what kind. The mechanism determines who captures value, who gets exploited, and whether the resulting token holder base is aligned with the project's long-term success. Getting this wrong costs real money ($100M+ in arbitrage on Ethereum alone) and creates misaligned communities.
+
+## The three-criteria framework
+
+→ CLAIM CANDIDATE: The optimal token launch mechanism must simultaneously satisfy three properties that existing mechanisms trade off against each other: shill-proofness (no bot/MEV advantage), community alignment (genuine early supporters rewarded), and price discovery accuracy (finds the true clearing price).
+
+No existing implementation achieves all three. Each mechanism sacrifices at least one:
+
+| Mechanism | Shill-proof? | Community-aligned? | Price-discovering? | Example |
+|-----------|-------------|-------------------|-------------------|---------|
+| Static bonding curve | NO — bots front-run | YES — early = cheap | WEAK — arbitrary start | pump.fun, friend.tech |
+| Dutch auction | YES — descending price | NO — true believers overpay | YES — finds clearing | Doppler, GDA |
+| Fixed-price sale | PARTIAL — first-come | NEUTRAL | NO — admin sets price | ICOs (2017 era) |
+| Futarchy-governed launch | YES — market filters | PARTIAL — governance participants | YES — conditional markets | MetaDAO/futard.io |
+| Liquidity bootstrapping pool | PARTIAL — declining weight | PARTIAL — window reduces urgency | MODERATE | Balancer LBP |
+| Batch auction | YES — uniform clearing | NEUTRAL | YES — single clearing price | CowSwap, Gnosis |
+
+## Auction theory foundations I need to build claims on
+
+### Vickrey (second-price sealed-bid) auction
+- Truthful bidding is a dominant strategy — you never benefit from bidding other than your true value
+- Mechanism design gold standard for incentive compatibility
+- **Token launch analog:** What would a Vickrey-like token launch look like? Everyone submits sealed bids, tokens allocated at the second-highest bid price? Batch auctions approximate this.
+
+### Revelation principle
+- Any outcome achievable by any mechanism can also be achieved by a truthful mechanism
+- Implies: for any token launch outcome we want, there exists a mechanism where honest participation is optimal
+- **The question:** What outcome do we actually want? Allocative efficiency (highest-value bidders get tokens)? Community building (most committed supporters get best deals)? Revenue maximization?
+
+→ CLAIM CANDIDATE: Token launches optimize for different objectives than traditional auctions — community alignment and long-term holder base quality matter more than revenue maximization or allocative efficiency, which means auction theory results that optimize for revenue (Myerson) or efficiency (Vickrey) may point to the wrong mechanisms.
+
+### Myerson's optimal auction
+- Revenue-maximizing auction design
+- Sets reserve prices, discriminates based on bidder characteristics
+- **Token launch problem:** Revenue maximization may be exactly wrong. Token launchers want *distribution* — get tokens into many hands — not *extraction* — squeeze maximum price from each buyer.
+
+### Common value vs private value auctions
+- Private value: each bidder knows their own valuation (art, personal goods)
+- Common value: the asset has one true value that bidders estimate with noise (oil rights, spectrum)
+- **Token launches are neither.** Token value is partly common (project fundamentals) and partly private (how much the holder will contribute, hold duration, community engagement). This hybrid creates the winner's curse on the common side AND community misalignment on the private side.
+
+→ CLAIM CANDIDATE: Token launches are hybrid-value auctions where the common-value component (project fundamentals) and private-value component (holder commitment, community contribution, holding duration) interact — and the mechanism should optimize for the private-value alignment, not the common-value discovery, because project fundamentals are better resolved through governance (futarchy) than through pricing.
+
+## Existing mechanisms — deeper analysis needed
+
+### pump.fun (static bonding curve)
+- **How it works:** Price increases monotonically with supply. First buyer pays least.
+- **What it gets right:** Rewards genuine early discovery. Simple. Composable.
+- **What it gets wrong:** Speed advantage = bot advantage. Sniping is the dominant strategy. Community members compete with bots, not with each other.
+- **Key data needed:** What % of pump.fun first-buyers are bots? What's the average hold time of first-buyers vs later buyers?
+→ SOURCE: Need on-chain analytics for pump.fun bot dominance
+
+### Doppler (dutch auction + dynamic bonding curve)
+- **How it works:** Price starts high, decays until buyers enter. Then bonding curve ramps.
+- **What it gets right:** Shill-proof. Finds clearing price. MEV-resistant via hook architecture.
+- **What it gets wrong:** True believers pay most. Community misalignment.
+- **Key question:** Does the post-clearing bonding curve compensate? If true believers enter during Phase 1 and the Phase 2 bonding curve rewards them as price appreciates from the discovered floor, maybe the total experience is acceptable?
+→ SOURCE: Need Doppler on-chain data once Solana deployment is live
+
+### MetaDAO / futard.io (futarchy-governed)
+- **How it works:** Conditional markets evaluate whether a project should launch. TWAP settlement over 3-day window.
+- **What it gets right:** Quality filter via governance. Separates "should this exist" from "what should it cost."
+- **What it gets wrong:** Doesn't solve the pricing problem within a launch — futarchy governs the binary decision (launch/don't launch), not the continuous price.
+- **Key insight:** Futarchy and price discovery are complementary layers, not alternatives.
+→ FLAG: This is why Doppler + futard.io could be a powerful combination — futarchy filters quality, Doppler handles pricing. But the community-alignment problem persists.
+
+### Batch auctions (CowSwap / Gnosis)
+- **How it works:** All bids collected in a window, single uniform clearing price.
+- **What it gets right:** Uniform price = no advantage to speed. MEV-resistant by design. Closest to Vickrey properties.
+- **What it gets wrong:** No early-supporter reward. No price curve post-launch. Doesn't bootstrap ongoing liquidity.
+- **Key question:** Could a batch auction for initial price discovery + bonding curve for ongoing liquidity be superior to dutch auction + bonding curve?
+
+→ CLAIM CANDIDATE: Batch auctions may be the most incentive-compatible initial price discovery mechanism for token launches because uniform clearing price eliminates both bot front-running (shill-proof) and true-believer penalty (everyone pays the same), while a subsequent bonding curve handles ongoing liquidity bootstrapping.
+
+### Liquidity bootstrapping pools (Balancer LBP)
+- **How it works:** Pool starts heavily weighted toward project token (e.g., 96/4), weight shifts over time toward 50/50. Price naturally declines then stabilizes.
+- **What it gets right:** Discourages early buying (price starts high and falls). Time window reduces urgency.
+- **What it gets wrong:** Sophisticated traders still game the weight schedule. Not shill-proof in practice.
+
+## The ideal mechanism (speculative)
+
+What if the optimal structure is layered:
+
+1. **Futarchy layer:** Governs whether the project launches (quality filter)
+2. **Batch auction layer:** Initial price discovery with uniform clearing (incentive compatible, no bot advantage, no true-believer penalty)
+3. **Bonding curve layer:** Post-batch ongoing liquidity bootstrapping from the market-discovered price
+4. **Conviction layer:** Retroactive rewards for hold duration, governance participation, community contribution (rewards true believers after the fact rather than trying to identify them ex ante)
+
+This separates the three criteria across layers rather than trying to satisfy all three in a single mechanism.
+
+→ CLAIM CANDIDATE: Optimal token launch architecture is layered — quality governance (futarchy), initial pricing (batch auction), ongoing liquidity (bonding curve), and community alignment (retroactive conviction rewards) — because no single mechanism can simultaneously be shill-proof, community-aligned, and price-discovering.
+
+## Claims I need to write (priority order)
+
+1. **The three-criteria framework** — standalone claim about the trilemma
+2. **Token launches are hybrid-value auctions** — why standard auction theory doesn't directly apply
+3. **Batch auctions as optimal initial pricing** — if the analysis holds up
+4. **Layered launch architecture** — the composition argument
+5. **Enrich existing futarchy claims** — connect futarchy to the quality-filter layer specifically
+
+## Data I need
+
+- pump.fun on-chain analytics: bot %, hold times, value capture distribution
+- Doppler on-chain data (once Solana is live): Phase 1 vs Phase 2 entry distribution
+- futard.io launch metrics: success rate, time to fill, post-launch price performance
+- Batch auction implementations: CowSwap data, Gnosis auction data
+- Balancer LBP historical data: did they actually reduce sniping?
+
+→ FLAG @leo: This musing is developing toward 4-5 standalone claims about token launch mechanism design. It bridges internet finance (my domain) with mechanism design theory (foundations). The layered architecture claim may belong in core/mechanisms/ rather than domains/internet-finance/ since it's a general coordination design pattern.

domains/internet-finance/dutch-auction dynamic bonding curves solve the token launch pricing problem by combining descending price discovery with ascending supply curves eliminating the instantaneous arbitrage that has cost token deployers over 100 million dollars on Ethereum.md

@@ -0,0 +1,57 @@
+---
+type: claim
+domain: internet-finance
+description: "Doppler protocol's hybrid mechanism blends dutch auctions (descending, shill-proof price discovery) with dynamic bonding curves (ascending on supply) to create two-phase token launches: rapid price decline finds market clearing price, then bonding curve ramps up — solving the initial pricing problem that has cost $100M+ in instantaneous arbitrage on Ethereum and that static bonding curves (pump.fun, friend.tech) cannot address"
+confidence: experimental
+source: "Adams, Czernik, Lakhal, Zipfel — 'Doppler: A liquidity bootstrapping ecosystem' (Whetstone Research, Jan 2024); Doppler docs (docs.doppler.lol); $100M+ arbitrage loss data from Dune Analytics"
+created: 2026-03-07
+related_to:
+  - "[[internet capital markets compress fundraising from months to days because permissionless raises eliminate gatekeepers while futarchy replaces due diligence bottlenecks with real-time market pricing]]"
+  - "[[cryptos primary use case is capital formation not payments or store of value because permissionless token issuance solves the fundraising bottleneck that solo founders and small teams face]]"
+---
+
+# dutch-auction dynamic bonding curves solve the token launch pricing problem by combining descending price discovery with ascending supply curves eliminating the instantaneous arbitrage that has cost token deployers over 100 million dollars on Ethereum
+
+Token launches face a fundamental pricing problem that no existing mechanism fully solves. The problem is two-sided: set the initial price too low and programmatic bots extract the difference instantly ($100M+ lost on Ethereum mainnet, $400M+ including MEV); set it too high and nobody buys. Static bonding curves (pump.fun, friend.tech) don't solve this because their ascending price structure guarantees that the first buyer gets the best deal — which is why bots dominate first-mover advantage.
+
+**This is an auction design problem, not an engineering problem.** The core issue is incentive compatibility: static bonding curves reward speed over information. The first buyer captures the most value regardless of how informed they are. This creates a race condition where bots with latency advantages extract value that should accrue to the project and its informed supporters. The mechanism design question is how to create conditions where participants reveal their true valuations — analogous to how Vickrey (second-price sealed-bid) auctions make truthful bidding a dominant strategy.
+
+**The mechanism: dutch auction + bonding curve hybrid.**
+
+Doppler (Whetstone Research, built on Uniswap v4 hooks) combines two well-studied primitives into a two-phase price discovery system:
+
+1. **Phase 1 — Dutch auction (descending).** Token price starts high and decays until buyers emerge. Dutch auctions are "shill-proof" (Komo et al 2024) — the descending price structure incentivizes truthful valuation revelation because the cost of bidding above your true value is directly borne by you. Buyers who enter early overpay; buyers who wait risk missing the clearing price. This creates a tension that converges on true valuation — similar in spirit to the revelation principle, where the mechanism makes honest participation individually rational. The descending structure also mitigates information asymmetry because bid revelation carries explicit costs through gas fees.
+
+2. **Phase 2 — Dynamic bonding curve (ascending).** Once a clearing price is established, the bonding curve takes over, ramping price upward as supply is absorbed. The curve's position shifts via a `tickAccumulator` that integrates adjustments from both the auction and supply-side dynamics. This phase functions as a standard bonding curve but *starting from a market-discovered price* rather than an arbitrary initial value — the key improvement over static implementations.
+
+**Epoch-based rebalancing creates adaptive price adjustment.** The protocol tracks expected vs actual token sales on a predetermined schedule and adjusts in three states: (a) severely undersold → maximum price reduction per epoch, (b) moderately undersold → proportional discount, (c) oversold → price increase toward expected clearing point. This creates a continuous feedback loop between supply schedule and market demand — the price doesn't just follow a predetermined curve, it adapts to actual buyer behavior.
+
+**Three-slug liquidity structure provides exit depth.** Liquidity is positioned in three contiguous zones: a lower slug absorbing all proceeds (enabling redemption), an upper slug supplying near-term demand, and price discovery slugs provisioning future epochs. This means buyers always have exit liquidity — a structural improvement over bonding curves where selling into thin lower positions creates high slippage.
+
+**MEV protection through hook architecture.** Bonding curve rebalances execute in the `beforeSwap` hook — meaning the curve shifts *during* transaction execution, not between blocks. Manipulators lose funds from curve movement that functions as limit orders against them. Multi-block MEV attacks would need to censor transactions across blocks *and* epochs — impractical on chains with censorship resistance.
+
+**Why this matters for the internet finance thesis:** The existing knowledge base captures the *governance* layer of permissionless launches (futarchy, conditional markets, brand separation) and the *capital formation* layer (compressed fundraising, solo founders). Doppler operates at the *price discovery* layer — the infrastructure beneath governance that determines how tokens find their initial price and generate sustainable liquidity. If futarchy governs *whether* a project should launch, dutch-auction bonding curves govern *how* it prices. The two are complementary, not competing.
+
+**Critical challenge: dutch auctions penalize true believers.** In traditional auctions (art, spectrum), making the highest-value bidder pay the most is allocatively efficient. But token launches aren't traditional auctions — the early buyers who value the token most are typically the project's most committed supporters, the ones who will hold, build community, and evangelize. A dutch auction makes these true believers pay the highest price while latecomers who waited (less conviction, less community alignment) get better deals. This inverts the community-building incentive: the mechanism optimizes for price discovery accuracy at the expense of rewarding early conviction.
+
+Static bonding curves have the *opposite* problem — they reward early participation but are exploitable by bots who aren't genuine supporters. The unsolved mechanism design question is: **how do you reward genuine early conviction while protecting against bot extraction?** Neither dutch auctions nor static bonding curves solve both simultaneously. Possible approaches that haven't been fully explored:
+- Futarchy as a pre-filter (governance decides *whether* to launch, then a community-friendly pricing mechanism handles *how*)
+- Identity-gated or reputation-weighted participation that distinguishes bots from genuine community
+- Hybrid mechanisms that offer early-supporter pricing to verified community members while using dutch-auction dynamics for the open market
+- Conviction-weighted pricing where holding duration or governance participation earns retroactive discounts
+
+**The best price discovery mechanism for token launches remains an open problem.** Doppler solves the arbitrage/MEV problem but may create a community alignment problem. The ideal mechanism would be shill-proof (no bot advantage), community-aligned (true believers get rewarded), and price-discovering (finds the right clearing price). No existing implementation achieves all three.
+
+**Deployment limitation:** Doppler is live on Base/EVM and building for Solana (native SVM implementation, not a port). No on-chain data yet for Solana deployment. The $100M+ arbitrage figure is Ethereum-specific and may not directly translate to Solana where transaction ordering works differently.
+
+---
+
+Relevant Notes:
+- [[internet capital markets compress fundraising from months to days because permissionless raises eliminate gatekeepers while futarchy replaces due diligence bottlenecks with real-time market pricing]] — Doppler provides the price discovery infrastructure that makes compressed fundraising possible without sacrificing value to arbitrage
+- [[cryptos primary use case is capital formation not payments or store of value because permissionless token issuance solves the fundraising bottleneck that solo founders and small teams face]] — better launch mechanics lower the cost of capital formation, strengthening the capital formation thesis
+- [[futarchy-governed permissionless launches require brand separation to manage reputational liability because failed projects on a curated platform damage the platforms credibility]] — Doppler could serve as the price discovery layer beneath futard.io's governance layer
+- [[permissionless leverage on metaDAO ecosystem tokens catalyzes trading volume and price discovery that strengthens governance by making futarchy markets more liquid]] — Doppler's liquidity bootstrapping could feed into the leverage → liquidity → governance accuracy loop
+- [[speculative markets aggregate information through incentive and selection effects not wisdom of crowds]] — dutch auctions use the same mechanism: descending prices create clear decision boundaries that incentivize informed participation
+
+Topics:
+- [[internet finance and decision markets]]

inbox/archive/2024-01-doppler-whitepaper-liquidity-bootstrapping.md

@@ -0,0 +1,95 @@
+---
+type: source
+title: "Doppler: A liquidity bootstrapping ecosystem"
+author: Austin Adams, Matt Czernik, Clement Lakhal, Kaden Zipfel (Whetstone Research)
+date: 2024-01
+url: https://www.doppler.lol/whitepaper.pdf
+domain: internet-finance
+processed_by: rio
+status: processed
+claims_extracted:
+  - "dutch-auction dynamic bonding curves solve the token launch pricing problem by combining descending price discovery with ascending supply curves eliminating the instantaneous arbitrage that has cost token deployers over 100 million dollars on Ethereum"
+notes: "Whitepaper dated Jan 2024 but protocol is expanding to Solana in March 2026. Built on Uniswap v4 hooks. Companion announcement article (Paragraph/@whetstone, March 2026) was marketing-only — no technical content."
+---
+
+# Doppler: A liquidity bootstrapping ecosystem
+
+## Protocol Overview
+
+Doppler is a liquidity bootstrapping protocol built on Uniswap v4 hooks. It automates token launch price discovery and liquidity formation inside a single hook contract, progressing from initial auction through to migration into a generalized AMM (Uniswap v2/v4) without user intervention.
+
+## Core Mechanism: Dutch-Auction Dynamic Bonding Curves
+
+Blends two well-studied primitives:
+
+**Dutch auctions:** Descending price, shill-proof (Frankie 2022, Moallemi 2024). Starts high, decays until buyers emerge. Mitigates information asymmetry because bid revelation carries explicit costs through gas fees.
+
+**Bonding curves:** Ascending price based on supply. Static bonding curves (pump.fun, friend.tech) have a critical flaw: setting the initial price. Too low = immediate arbitrage ($100M+ lost on Ethereum mainnet). Too high = no trades.
+
+**The hybrid:** Two-phase price discovery:
+1. **Phase 1:** Rapid price decrease (dutch auction) until market clearing price found
+2. **Phase 2:** Price ramps up via dynamic bonding curve
+
+The bonding curve's origin tick shifts via a `tickAccumulator` that aggregates adjustments from both the dutch auction and bonding curve rebalancing.
+
+## Epoch-Based Rebalancing
+
+Protocol establishes a predetermined sales schedule: `expected tokens sold = (elapsed time / total duration) × numTokensToSell`
+
+Rebalancing triggers on first swap of each epoch. Three states:
+
+| State | Condition | Action |
+|-------|-----------|--------|
+| Max dutch auction | Net sales ≤ 0 | Maximum price reduction per epoch |
+| Relative dutch auction | 0 < sales < target | Proportional reduction (e.g., 80% of target = 20% discount) |
+| Oversold | Sales ≥ target | Price increase toward expected clearing point |
+
+Key formula: `maxDelta = (maxTick - minTick) / (endingTime - startingTime) × epochLength`
+
+## Three-Slug Liquidity Position Structure
+
+| Slug | Position | Purpose |
+|------|----------|---------|
+| Lower | Global min → current tick | Absorbs all proceeds; enables exit/redemption |
+| Upper | Current tick → expected next-epoch price | Supplies delta between expected and actual sales |
+| Price Discovery (0-N) | Upper ceiling → tickUpper | Tokens for future epochs; count set at deployment |
+
+## MEV Protection
+
+- Bonding curve set in `beforeSwap` hook — rebalances happen during execution, not between blocks
+- Manipulators lose funds from curve shifting (functions as limit orders against manipulation)
+- Multi-block MEV attack requires censoring transactions across blocks and epochs — impractical on chains with censorship resistance
+
+## Airlock Architecture (Modular Factory System)
+
+Four factory modules:
+1. **Token Factory** — deploys ERC20s with known bytecode (eliminates malicious implementations)
+2. **Liquidity Factory** — creates and manages LBP, seeds with user-defined token supply
+3. **Migration Factory** — generates AMM position post-auction, minimizing MEV
+4. **Timelock Factory** — time-locks LP tokens (vs burning — preserves revenue-generating asset)
+
+## Fee Structure
+
+- Maximum combined fee ceiling: 250 bps
+- Protocol fee: 10 bps or 10% of interface fee (whichever higher)
+- Interface fee: up to 225 bps (creates consolidation incentives — reduces market fragmentation)
+- Migration/liquidity fee: additional 5% on swap activity, directed to timelock contract
+- **Fee rehypothecation:** fees can be programmatically redirected to grow liquidity, perform buybacks, or consolidate into one side of the market
+
+## Vesting Modules
+
+Developer tokens not distributed until token is fully liquid (post-bonding curve). Prevents developer dumps during price discovery.
+
+## Solana Expansion (March 2026)
+
+Not a port or fork — native implementation designed for SVM constraints (different accounting model, economic challenges). Announced via Paragraph/@whetstone.
+
+## Key Data Points
+
+- 910,000+ unique traded onchain assets as of writing
+- $100M+ lost to instantaneous arbitrage on Ethereum mainnet by token deployers
+- $400M+ lost to instantaneous arbitrage and MEV on Ethereum
+
+## Assessment
+
+The dutch-auction dynamic bonding curve is a genuinely novel price discovery primitive. It solves a real problem (initial pricing) that static bonding curves cannot. The modular factory architecture and fee rehypothecation are strong engineering but not new mechanism-level insights. The protocol is infrastructure-layer — it doesn't compete with futarchy governance (MetaDAO/futard.io) but could complement it as the price discovery layer beneath governance.