F0rge Whitepaper
The Fair Launch Infrastructure for DeFi
Abstract
F0rge is a token launch infrastructure protocol built natively on Uniswap V4 hooks. It combines three DeFi primitives — a bonding curve for price discovery, an AMM pool for open trading, and a lending market for capital utility — into a single, trustless, automatically sequenced system deployed in one transaction.
When a project deploys a F0rge hook, their token enters a fair bonding curve. Once a configurable ETH threshold is reached, the hook automatically graduates the token to a live Uniswap V4 AMM pool, seeding it with all accumulated capital. The lending layer then activates on the same block, allowing token holders to borrow ETH against their holdings without moving the spot price.
F0rge eliminates the fragmentation of DeFi token launches. Capital raised never leaves the protocol. There are no pre-sales, no VC allocations, no manual migrations, and no multisig interventions. The entire lifecycle — from first purchase to mature lending market — is handled on-chain, atomically, by a single hook.
Introduction
The promise of DeFi is permissionless financial infrastructure. Anyone should be able to launch a token, establish fair price discovery, and build a liquid market without gatekeepers. Yet in practice, launching a token in DeFi today requires coordinating across multiple protocols, each with its own deployment process, liquidity requirements, and trust assumptions.
Uniswap V4 introduced hooks — custom logic that executes before and after pool interactions. Hooks make it possible to embed complex financial behavior directly into the AMM layer, without routing through external protocols or introducing additional trust assumptions.
F0rge is built on this foundation. By encoding the entire token launch lifecycle as a V4 hook, F0rge delivers a launch experience that is simpler for project teams, fairer for participants, and more capital-efficient than anything previously possible.
Problem Statement
Fragmented Infrastructure
A typical DeFi token launch today involves a bonding curve protocol for initial price discovery, a DEX deployment for open trading, and a separate lending market application for borrowing. Each step requires separate deployment, separate liquidity, and separate trust assumptions. The transition between phases — particularly from bonding curve to AMM — is a manual process that introduces meaningful risk.
Capital Inefficiency
In most launch flows, ETH raised during the bonding curve phase is extracted from the protocol at graduation. It may go to the team, to a treasury, or to seed a pool — but it leaves the system that participants trusted when they bought in. Liquidity provided to the AMM pool is often minimal and easily manipulated.
Structural Rug Risk
Because capital leaves the protocol at graduation, and because graduation often requires manual action by the project team, there are multiple points at which a bad actor can extract value and disappear. This is not a people problem. It is an architecture problem.
No Built-in Utility for Holders
Existing launchpads provide no mechanism for token holders to access liquidity without selling. A holder who wants to borrow against their position must bridge to a separate lending protocol, if a market for their token exists at all. For newly launched tokens, it rarely does.
Solution Overview
F0rge solves all four problems with a single architectural decision: encode the entire launch lifecycle as a Uniswap V4 hook.
One Deploy
A project team deploys a F0rge hook in a single transaction. They set the token parameters — name, supply, graduation threshold, and optional team allocation. From that point, the protocol takes over.
Capital Stays In
ETH collected during the bonding curve phase never leaves the F0rge hook. It becomes the seed capital for the AMM pool at graduation. There is no extraction point.
Automatic Graduation
When the ETH threshold is reached, the hook migrates the token to an AMM pool automatically. No governance vote. No multisig. No team action required.
Built-in Lending
The lending layer activates on the same block as graduation. Token holders can immediately borrow ETH against their holdings, with zero price impact on the market.
Architecture
F0rge is implemented as a Uniswap V4 hook — a smart contract that registers callback functions executed by the V4 PoolManager at defined points in the swap and liquidity lifecycle.
Hook Callbacks
| Callback | Trigger | F0rge Action |
|---|---|---|
| beforeInitialize | Pool creation | Set initial curve parameters |
| beforeSwap | Pre-swap | Check graduation state, route to curve if pre-graduation |
| afterSwap | Post-swap | Recalculate idle ETH reserve |
| beforeAddLiquidity | LP deposit | Validate post-graduation state |
| afterAddLiquidity | LP deposit | Update lending reserve |
| beforeRemoveLiquidity | LP withdraw | Check borrow utilization |
State Machine
The F0rge hook operates as a three-state machine. State transitions are one-directional and triggered automatically by on-chain conditions. There is no admin function to force or prevent a transition.
Three Phases, One Hook
Phase 1 — Forge (Bonding Curve)
Upon deployment, the token enters the Forge phase. All token purchases and sales are routed through a bonding curve implemented inside the hook.
Where P(s) is the token price at supply s and k is the slope constant set at deployment.
- ◆Every participant buys from the same curve at the same rules
- ◆No preferred allocations, no private rounds, no insider pricing
- ◆All ETH collected is held inside the hook — it cannot be withdrawn
- ◆Sells are permitted; the curve is bidirectional
Phase 2 — Pool (AMM Graduation)
When the graduation threshold is reached, the hook executes the migration sequence atomically within a single transaction:
- 1.Bonding curve is frozen — no further buys or sells via the curve
- 2.All accumulated ETH is transferred to a new Uniswap V4 pool position
- 3.A corresponding token supply is paired with that ETH as initial liquidity
- 4.The pool opens for trading via the standard V4 swap path
- 5.The lending layer activates
Liquidity depth: The graduation pool is seeded with the full ETH raised during the bonding curve phase. A token that raises 100 ETH on its bonding curve launches with 100 ETH of pool liquidity on day one.
Phase 3 — Lend (Lending Market)
The lending layer activates simultaneously with pool graduation. It operates on the same liquidity that backs the AMM — there is no separate capital pool, no separate protocol, and no governance required to activate it.
Idle ETH: At any point in time, a portion of the pool's ETH is not actively required to back open trades. This idle ETH is tracked by the hook via afterSwap accounting. It forms the lending reserve.
The Graduation Mechanism
Graduation is the core innovation of F0rge. It is fully trustless and atomic.
Proportional Migration
At graduation, the hook calculates the optimal token supply to pair with the accumulated ETH based on the final bonding curve price. This ensures that the opening AMM price exactly matches the bonding curve's closing price — there is no discontinuity, no arbitrage gap, and no price shock at graduation.
No Team Extraction
The graduation mechanism contains no function to send ETH to the project team. The team allocation (if configured) is distributed as tokens, not ETH, and is subject to an on-chain vesting schedule. ETH is a protocol resource — it belongs to the pool.
Atomic Activation
The migration from curve to pool to lending happens within a single Ethereum transaction. There is no window during which the protocol is in an inconsistent state. If any step fails, the entire transaction reverts.
Lending Layer
Proportional Withdrawal
The key property of F0rge's lending layer is that borrowing has zero price impact on the AMM pool. This is achieved via proportional withdrawal.
Traders swapping in the same pool are mathematically unaffected by any borrow or repay activity.
Collateral Ratio
The hook enforces a minimum collateral ratio at borrow time:
Liquidation
Liquidation is permissionless. Any address may liquidate an undercollateralized position by repaying the outstanding debt and receiving the collateral at a discount. The liquidation bonus is configurable at deployment and defaults to 5%.
Interest Rate Model
F0rge uses a utilization-based interest rate model:
Token Distribution Model
F0rge enforces a transparent distribution model at deploy time. All parameters are set in the deployment transaction and cannot be changed.
| Allocation | Description | Constraints |
|---|---|---|
| Bonding curve supply | Sold publicly via curve | Majority of supply; minimum configurable |
| Team allocation | Optional; distributed as tokens | Maximum 10% of total supply |
| Protocol fee | Collected at graduation in ETH | Fixed at 0.5% of graduation pool |
| Ecosystem reserve | Optional; vested on-chain | Maximum 5% of total supply |
Team Vesting
Team tokens are locked in the hook and released linearly over a vesting schedule set at deployment (minimum 6 months, configurable up to 4 years). There is no cliff bypass, no admin override, and no emergency unlock.
LP Economics
Liquidity providers in a graduated F0rge pool earn from two independent sources:
Swap Fees
Standard Uniswap V4 swap fees, collected on every trade. Fee tier is set at deployment and follows V4 conventions (0.05%, 0.30%, 1.00%).
Borrow Interest
Interest paid by borrowers accrues to the pool's LP positions in proportion to their share. Interest is denominated in ETH and accumulates continuously.
Total LP Yield
During periods of high borrowing activity, the borrow interest component can exceed the swap fee component. During low-activity periods, swap fees remain the baseline return. Capital is never fully idle.
Security Considerations
Reentrancy
All state changes in the hook follow the checks-effects-interactions pattern. The hook does not make external calls between state updates.
Oracle Dependency
The lending layer uses on-chain price data derived from the pool's own reserves. This avoids external oracle dependency but requires the pool to have sufficient liquidity depth to resist price manipulation.
Proportional Withdrawal Invariant
The invariant that proportional withdrawal does not change the spot price holds in all cases except when the pool is at zero liquidity. The hook enforces a minimum liquidity floor that prevents this edge case.
Graduation Atomicity
If any step of the graduation sequence fails, the entire transaction reverts. The hook maintains a graduation_attempted flag to prevent partial re-execution.
Collateral Manipulation
Because collateral tokens are the same token traded in the pool, a large borrow could theoretically allow a borrower to manipulate the collateral price. This is mitigated by the interest rate model, the collateral ratio requirement, and the proportional withdrawal invariant.
Comparison with Existing Solutions
| Feature | Pump.fun | Uniswap V3 | Aave | F0rge |
|---|---|---|---|---|
| Bonding curve launch | ✓ | ✕ | ✕ | ✓ |
| Auto AMM graduation | partial | ✕ | ✕ | ✓ |
| Built-in lending market | ✕ | ✕ | ✓ | ✓ |
| Single deploy | ✓ | ✕ | ✕ | ✓ |
| Capital stays in protocol | ✕ | — | — | ✓ |
| Zero price impact borrowing | ✕ | ✕ | ✕ | ✓ |
| Fair launch (no VC alloc) | ✓ | — | — | ✓ |
| Team vesting on-chain | ✕ | ✕ | ✕ | ✓ |
| LP earns swap + interest | ✕ | ✕ | partial | ✓ |
| Built on Uniswap V4 | ✕ | ✕ | ✕ | ✓ |
Roadmap
Phase 0 — Foundation
- ✓Core hook implementation
- ✓Bonding curve module
- ✓Graduation mechanism
- ✓Internal testing and invariant verification
Phase 1 — Testnet
- ◆Public testnet deployment on Ethereum Sepolia
- ◆UI for token deployment and interaction
- ◆Community testing and bug bounty program
- ◆Independent security audit
Phase 2 — Mainnet Launch
- ○Mainnet deployment
- ○First partner token launches
- ○Lending layer activation
- ○LP dashboard and analytics
Phase 3 — Expansion
- ○Multi-curve support (linear, square root, exponential, custom)
- ○Cross-chain deployment (Base, Arbitrum, Optimism)
- ○F0rge SDK for programmatic token launches
- ○Governance module for protocol parameter updates
Phase 4 — Ecosystem
- ○F0rge token launch via F0rge itself
- ○Protocol-owned liquidity strategy
- ○Developer grants program
- ○Integration with major DeFi aggregators
Conclusion
F0rge is not a launchpad. It is launch infrastructure — the base layer that transforms how tokens come into existence in DeFi.
By collapsing bonding curve, AMM graduation, and lending market into a single Uniswap V4 hook, F0rge removes every point of friction, every extraction opportunity, and every manual intervention from the token launch lifecycle. Capital that participants trust to the protocol stays in the protocol, working continuously across swap fees and borrow interest for the benefit of liquidity providers.
A forge is where raw material becomes something useful. F0rge does the same for capital.
This document is for informational purposes only and does not constitute an offer to sell or a solicitation to buy any securities or financial instruments. F0rge is experimental software. Smart contract interaction involves risk of loss.