MileStone.fun

Unlike traditional fundraising mechanisms that distribute capital up front or rely on subjective grant allocation, milestone.fun enforces on-chain escrow semantics where SPL-USDC is held in vaults until predefined milestones are achieved and verified. Funds are only released when milestone conditions are met and verified by a curated ReviewerSet, and verified progress is anchored on-chain using receipts and proofs.

To safeguard early token distribution and community participation in project fundraising, milestone.fun integrates with Meteora's Alpha Vault — a Solana launch-oriented vault primitive designed to provide fair, anti-bot participation prior to pool activation. Alpha Vault's configurable pro-rata and FCFS modes give genuine supporters early access while maintaining uniform pricing and configurable caps, serving as a trust-aligned bootstrap mechanism for fundraising rounds that include token allocations.

Protocol Principles

The protocol is built with the following principles:

By integrating Meteora's Alpha Vault for fair launch participation and combining on-chain milestone enforcement with protocol-appointed verification, milestone.fun creates a progress-indexed capital market on Solana where backers fund actual work and builders ship actual deliverables.

Problem Statement & Motivation

Founder-grade, Solana-native, technical & opinionated

Problem — capital is broken for builders

Solana has an enormous supply of technical talent and small teams building real infra. Yet the funding primitives available to them are hostile to incremental progress:

• VCs want scale, not completion. They fund narratives and runway, not discrete features. Small, targeted needs ($5k–$25k) are invisible to them.
• Grants are slow and political. Approval cycles, opaque criteria, and non-standard deliverables make grants unreliable for shipping fast.
• Presales and ICOs optimize for speculation. They encourage over-raising, token velocity hacks, and marketing-first behavior that misalign incentives versus shipping.
• Bot-driven launches & sniper dynamics distort early distribution. Even when token allocation is appropriate, anti-bot mismatches create winners who are not builders.
• Custody and verification are fragmented. Off-chain "escrows," manual disbursements, or discretionary review processes reintroduce centralization risk and make audits painful.

Result: builders either dilute too early, sit on ideas, or ship half-finished features. The ecosystem loses iterated product velocity.

Why existing fixes fail

• Smaller raises get cannibalized by tooling designed for large rounds. Token mechanics, liquidity bootstraps, and automated market makers push projects toward scale to make incentives "work."
• Permissionless presales attract rent-seeking. No real gating for delivery means backers are buying promises, not progress.
• Grant and DAO systems trade speed for oversight. They lock teams into slow cycles and high coordination costs—bad for engineers shipping product.
• Anti-bot tech (Alpha Vaults, whitelists) helps distribution but doesn't solve post-raise accountability. They protect pricing at launch but say nothing about whether the funded feature ever ships.

Threat model (who can break funding)

• Toxic teams: raise small capital, ghost, and never deliver.
• Colluding reviewers: false verifications to unlock funds.
• Oracles/metrics fakery: forged or gamed metrics used as "proof" of completion.
• Bots & speculators: capture early allocations even when product delivery is the objective.
• Protocol bugs / admin keys: any off-chain admin path that can move funds away from programmed intents.

Any viable solution must minimize these vectors or constrain them into bounded, auditable surfaces.

Design goals — what milestone.fun must achieve

1. Capital follows execution. Tranches only release against verifiable artifacts (commits, tx receipts, deploy hashes).
2. On-chain custody. SPL-USDC lives in PDA vaults (MilestoneVault) controlled by program logic, not off-chain gatekeepers.
3. Minimal trusted surface. Trust limited to two bounded roles: Developer and ReviewerSet. Both are auditable and replaceable.
4. Verifiable receipts. Milestone completion must anchor to immutable artifacts (Git commit CIDs, on-chain deploy txs, IPFS snapshots).
5. Anti-bot fair distribution. Integrate launch protection (Alpha Vault) where token allocation is part of the round.
6. Dispute resilience. Timelocks, emergency windows, slashing/replacement for reviewers, and transparent dispute records.
7. Composability. Anchor as lightweight Solana programs (Anchor/CPI friendly) so other protocols and frontends can reuse primitives.

How milestone.fun fixes it — core primitives & flow

1. RoundConfig (on-chain): parameters (target amount, tranche sizes, milestone definitions, reviewer multisig, timelocks, Alpha Vault integration flag).
2. MilestoneVault (PDA): holds SPL-USDC; each tranche is encoded on-chain. Funds cannot be moved except by the milestone release instruction.
3. ReviewerSet (multisig): protocol-appointed or project-curated multisig that submits ExecutionReceipts. Reviewers are slashed/replaced on proven misbehavior.
4. ExecutionReceipt: an on-chain record with metadata — Git commit CID, IPFS artifacts, deploy txs, testnet/mainnet tx hashes, and optional metrics snapshot CID. Receipts are verifiable by anyone.
5. Release logic: when N-of-M reviewers submit receipts passing validation, the MilestoneVault automatically releases the tranche to the developer PDA. Releases are atomic and logged.
6. Alpha Vault integration: for rounds that include token allocations, the Alpha Vault manages pre-launch deposits and uniform pricing/anti-bot distribution. Token releases to participants are conditioned on milestone completion (token unlock = milestone pass).
7. Safety rails: timelocked release windows, refund paths if milestones fail within dispute windows, and reviewer rotation mechanics.

Why this is Solana-native (not generic)

• Low latency, low fee micro-tranches: Solana's throughput and cheap SPL-USDC transfers make $5k–$25k rounds operationally cheap and frictionless.
• PDA custody & CPI composability: MilestoneVaults as PDAs allow safe, auditable custody without custodial accounts. Anchor/CPI integration makes the primitive usable by existing Solana infra (launchpads, wallets, frontends).
• Native integration with Meteora Alpha Vault: use the proven anti-bot primitives for fair on-chain distribution while keeping post-raise accountability on the milestone protocol.

Concrete behavioral changes in the market

• Less over-raising: projects only take what they can credibly ship, limiting dilution and hype cycles.
• Faster product iteration: small funded tranches enable continuous shipping instead of stalled, large-round planning.
• Reputation ≠ narrative: on-chain receipts and history create machine-readable delivery records that compound trust.
• Cleaner token mechanics: token allocations can be gated by delivery, reducing immediate sell pressure.

Metrics of success (what we measure)

• Delivery rate: percent of rounds that successfully complete all milestones.
• Time-to-feature: median time between tranche release and proof anchor.
• Refund rate: percent of funds returned due to failed milestones/disputes.
• Alpha Vault fairness metric: fraction of deposits that were non-bot (measured via participation patterns + whitelists).
• Reputation growth: repeat-applicant success and backer retention.

Closing

We are not building another launchpad or another grant UI. We are building a funding primitive: execution-gated capital for Solana. Integrating Alpha Vault solves fair distribution at launch; milestone.fun enforces delivery after funding. Together they turn early capital from a one-time bet into a stream of accountable, composable, on-chain commitments.