Forge — The Conviction Launchpad

Solidity License Build Tests

"Stop rewarding speed. Start rewarding belief."

Mid-2024. Pump.fun was eating crypto — hundreds of millions in volume, a new token every few seconds. I watched the same loop play out a thousand times a day: launch, bundle, pump, rug, dead in two hours. I was tired of it. I wanted to see projects that actually worked, communities that actually stayed — and an ecosystem that didn't treat its users as exit liquidity. So I built the launchpad I wished existed.

This protocol is not deployed. Forge is an open-source reference implementation — there is no official deployment, no token, no presale, no fee going to me. It exists for builders who want to study it, take inspiration from it, fork it, or deploy their own. The code is the product, freely. Read it, ship it, improve it.

The Problem With Pump.fun

Pump.fun is a brilliant piece of engineering. In its first year it processed hundreds of millions in volume and proved permissionless token creation had massive demand.

But it's structurally broken in one fundamental way: it rewards speed, not conviction.

• Any wallet launches anything in 30 seconds — zero signal on quality
• Insiders bundle dozens of wallets at block 0 to capture supply
• The bonding curve rewards whoever clicks fastest, not whoever believes hardest
• When a token migrates, early buyers dump immediately — liquidity collapses
• Result: 99% of tokens are dead within the hour

The problem isn't technical. It's a misalignment of incentives baked into the core mechanic.

The Forge Thesis

Replace speed with conviction.

Instead of rewarding whoever buys first, Forge rewards whoever commits longest. One shift in the core mechanic changes everything downstream — bundle attacks become pointless, rugs become structurally harder, and genuine communities get a natural advantage over mercenary capital.

(Forge is implemented on EVM / Solidity — ETH for capital, Uniswap V2 for the post-graduation pool. The Pump.fun and Raydium references below are the problem it answers.)

Core Mechanism 1 — Conviction Bonding Curve

In Pump.fun, you buy tokens on a price curve. In Forge, you bid time alongside capital. Your effective price depends on how long you're willing to lock:

• Insiders who want to dump immediately pay full price
• True believers accumulate dramatically more tokens for the same capital
• A bundle of 50 wallets buying at 1.0x loses structurally to one wallet locking 90 days
• The holder base is filtered toward conviction from day one

→ curve/ConvictionBondingCurve.sol, vault/LockVault.sol

Core Mechanism 2 — Liquidity Commitment Pool

The migration-dump problem: when a token graduates, liquidity is fixed and early buyers exit instantly. Floor collapses. Token dies.

Forge solves this with progressive liquidity unlocking:

At migration:
40%  →  available immediately
60%  →  unlocks linearly over 12 weeks (5% per week)

Result: the floor is structurally defended for 3 months. No single actor can drain liquidity in one transaction; the window gives a real community time to grow.

→ liquidity/CommitmentPool.sol

Core Mechanism 3 — Pre-Conviction Phase

Before a token launches, a 48-hour signal window opens:

• Wallets sign an on-chain commitment: "I intend to buy X ETH at launch"
• Zero ETH spent — pure social signaling, public and wallet-attributed
• The token only opens its curve if the minimum conviction threshold is met

PRE-CONVICTION — $TOKEN
Threshold   : 50 commitments / 30 ETH
Current     : 34 commitments / 22.4 ETH
Remaining   : 18h 24min

If the threshold isn't reached in 48h, the token never launches. No community → no launch.

→ commit() / activate() / abort() in ForgeToken.sol

Core Mechanism 4 — Forge Reputation Score

Every deployer carries a public, immutable Forge Score (0–1000):

Forge Score — 0xabc…def
Tokens launched       : 8
Survivors (>30 days)  : 5/8 (62.5%)
Avg lock chosen       : 47 days
FORGE SCORE           : 847 / 1000  ✅  Verified Builder

• Score > 500 → deployer earns the fee's deployer slice, reduced launch fee (1.0% → 0.2%)
• Score < 500 → new tokens are flagged with a risk warning, deployer slice withheld
• Serial ruggers watch their score fall toward zero; their tokens stay marked

→ reputation/ReputationOracle.sol

Core Mechanism 5 — Anti-Bundle Protection

Bundle attacks were the defining launchpad exploit of 2024. Forge makes them economically irrational at the contract level:

uint256 public maxBuyPerBlock;     // global ETH cap per block (e.g. 0.5 ether)
uint256 public blocksBetweenBuys;  // per-wallet cooldown (e.g. 3 blocks)

• Velocity cap: the whole market can only absorb so much ETH per block — a swarm can't sweep the launch block.
• Per-wallet cooldown: a single wallet must wait between buys.
• Same-block surcharge: piling into a block that already has buys costs extra, and that surcharge is redistributed to locked holders.

A bundler with 50 wallets at full price loses to one wallet with a 90-day lock.

→ _enforceAndAccount() in ForgeToken.sol

Fee Distribution — Aligned, Not Extractive

1% fee on every trade, split:
30%  →  Locked holders (by lock weight)
25%  →  The token's LP
20%  →  Deployer (only if Forge Score > 500, else to treasury)
15%  →  Forge treasury
10%  →  Burn

A holder who locked 180 days collects fee income for 6 months — a marketing force multiplier wired into the protocol.

Contract Architecture

ForgeFactory.sol              — deploys tokens, stamps Forge Score, authorizes reporting
ForgeToken.sol                — phases · conviction curve · anti-bundle · fees · migration
 ├─ curve/ConvictionBondingCurve.sol   — lock-weighted pricing (library)
 ├─ liquidity/CommitmentPool.sol        — progressive LP unlock post-migration
 ├─ vault/LockVault.sol                 — per-wallet locks + locked-holder fee stream
 └─ reputation/ReputationOracle.sol     — Forge Score storage & computation
governance/ForgeGovernance.sol — params voted by locked holders
                                 (voting power = tokens × lock duration)
lib/  · interfaces/

Forge vs Pump.fun

Why This Works

The single insight: mercenary capital and conviction capital need different pricing. Pump.fun prices them identically, so the faster one always wins. Forge makes conviction capital cheaper — through one honest question at purchase time:

"How long are you willing to stay?"

The answer sets your price. Everything else follows.

Build & test

forge build  --via-ir
forge test   --via-ir

--via-ir is required (the curve + fee + anti-bundle logic in buy() is past the legacy stack limit).

Implementation notes

Honest about what is and isn't fully trustless on-chain:

• Velocity cap, cooldown and same-block surcharge are enforced on-chain. The deeper wallet-fingerprinting by funding source described for a full product (clustering wallets funded from one address) needs an off-chain indexer feeding a flag — out of scope for these contracts; the economic rails above already make bundling irrational.
• Forge Score is computed on-chain from recorded stats; "survival >30 days" is reported by the token once it has lived a month with liquidity intact (a fully trustless version would derive it from pool state via a keeper).
• Locked-holder fee weight uses the chosen lock duration (fixed), not a continuously-decaying remaining duration — a deliberate gas/fairness trade.

Status — open source, not deployed

This repository is the full smart-contract implementation of the Forge protocol, published purely as open source. To be unambiguous:

• It is NOT deployed anywhere. There is no canonical Forge contract, no front-end I run, no token, no presale, no fee routed to me.
• It exists for anyone who wants to learn from it, take inspiration from the mechanism design, fork it, or deploy their own version under their own terms.
• Provided as-is and unaudited — if you deploy it with real value, audit it first and own the outcome.

The code is the product — and it's yours to take.

Built during the Pump.fun era — because the problem deserved a real answer.

MIT © 2024 c0llback