🎱 Pool Spawning Mathematics

Flexible model for ANY starting capital - ratios scale naturally

🔥 Works from $1K to $100K+ Genesis

❌ OLD: Hardcoded $100K minimum → excludes 95% of projects
✅ NEW: Ratio-based triggers → accessible to ALL budgets

The growth multipliers matter, not the absolute dollar amounts.

Core Mechanism: Ratio-Based Position Triggers

ClawdPool positions are triggered by growth multiples from your genesis launch, not fixed dollar amounts. Whether you start with $1K or $100K, the same math applies.

Universal Position Formula:
GENESIS_LIQUIDITY = your_starting_capital // $1K, $5K, $10K, $50K, $100K, etc.

Position 1 Trigger = GENESIS_LIQUIDITY × 1 // Genesis
Position 2 Trigger = GENESIS_LIQUIDITY × 5 // 5x growth
Position 3 Trigger = GENESIS_LIQUIDITY × 100 // 100x growth
Position 4 Trigger = GENESIS_LIQUIDITY × 1000 // 1000x growth
Position 5 Trigger = GENESIS_LIQUIDITY × 5000 // 5000x growth

This means: If you launch with $10K, Position 2 activates at $50K MC, Position 3 at $1M MC, etc. The ratios are what drive sustainable growth, not arbitrary thresholds.

📊 Position Comparison (Scalable)

Same allocation percentages work at ANY scale:

Position Allocation MC Growth Pool Fee Lock Period Use Case
Position 1 10% 1x (genesis) 0.3% 180 days Launch, price discovery
Position 2 50% 5x from P1 0.3% 90 days Growth phase (most time spent)
Position 3 15% 20x from P2 0.05% 60 days Established, lower volatility
Position 4 20% 10x from P3 0.05% 30 days Mature, high volume
Position 5 5% 5x from P4 0.01% No lock Top-tier, stable liquidity
💡 Why This Works:
• 50% in Growth Phase: Most projects spend 80% of time in 5x-100x range
• 10% at Genesis: Creates scarcity, prevents instant dumps
• Graduated releases: Natural token distribution as market grows
• Fee tiers match volatility: Higher fees when volatile, lower when stable

📐 Smart Contract Parameters

These values are hardcoded in the PoolFactory contract and govern all pool creation:

Minimum Liquidity
1,000
Minimum tokens required to create a pool (1000e18 in contract). Prevents spam pools and ensures meaningful liquidity.
Factory Fee
0.1%
Fee taken on pool creation (10 basis points). Goes to feeRecipient address for protocol sustainability.
Base Pair
ETH
All CLAWD pools paired with WETH (Wrapped ETH). Provides stable price discovery and deep liquidity.

🎯 Spawn Strategy Structure

SpawnStrategy Parameters

Each pool has a strategy that defines when and how it spawns children:

SpawnStrategy Struct (from contract):
struct SpawnStrategy {
    string name; // Strategy identifier
    uint256 seedThreshold; // TVL to trigger spawn (in wei)
    uint24[] childFees; // Fee tiers for children (e.g. 3000 = 0.3%)
    uint8[] liquidityPcts; // % of fees to seed each child
    bool crossChainEnabled; // Allow spawning on other chains
    uint8[] targetChains; // 1=Base, 2=Unichain, 3=Arbitrum
}

💡 Scalable Launch Examples

Here's how the model scales for different starting budgets:

Starting Capital P1 (1x) P2 (5x) P3 (100x) P4 (1000x) P5 (5000x)
$1,000 $1K $5K $100K $1M $5M
$5,000 $5K $25K $500K $5M $25M
$10,000 $10K $50K $1M $10M $50M
$50,000 $50K $250K $5M $50M $250M
$100,000 $100K $500K $10M $100M $500M
💡 Universal Growth Path:
Genesis (1x) → 5x → 100x → 1000x → 5000x
• Time to 5x: 1-3 months (typical)
• Time to 100x: 6-12 months (realistic goal)
• Time to 1000x: 12-24 months (strong success)
• Time to 5000x: 24-36 months (top-tier outcome)

🔢 Child Pool Creation Formula

Automated Spawning Logic

Step 1: Check Threshold
TVLcurrent = pool.token0Balance × priceETH + pool.token1Balance × priceETH

if (TVLcurrent >= seedThreshold) {
    triggerSpawn = true;
}
Step 2: Calculate Child Seed Amount
feesaccumulated = pool.cumulativeFees

childSeed = feesaccumulated × (liquidityPcts[childIndex] / 100)

// Example: If parent has 1000 ETH in fees and liquidityPct = 50
// childSeed = 1000 × 0.50 = 500 ETH worth of liquidity
Step 3: Create Child Pool
PoolConfig memory childConfig = PoolConfig({
    token0: parentPool.token0, // CLAWD
    token1: parentPool.token1, // WETH
    fee: strategy.childFees[childIndex],
    tickSpacing: getFeeSpacing(fee),
    sqrtPriceX96: currentPrice // Inherit parent price
});

childPoolId = createPool(childConfig, seedAmount0, seedAmount1, childStrategy);

📊 Real Example: $10K Genesis Launch

Scenario: Starting with $10,000 capital

Position 1 (Genesis - 1x):
• Your starting capital: $10,000
• Position 1 allocation: 10% of total supply
• Genesis price: $10,000 ÷ 100M tokens = $0.0001
• Market Cap: $10K | FDV: $100K
Position 2 Trigger (5x growth):
• Threshold: $10K × 5 = $50,000 MC
• When you hit $50K MC, Position 2 activates
• Position 2 allocation: 50% of supply (500M tokens)
• New liquidity: $40K worth (80% of $50K MC)
• Price at P2: ~$0.0002 (2x from genesis)
Position 3 Trigger (100x growth):
• Threshold: $10K × 100 = $1,000,000 MC
• Position 3 allocation: 15% of supply (150M tokens)
• Total circulating: 300M tokens (30%)
• Price at P3: ~$0.00333 (33x from genesis)
• CMC Rank: Top 2000 (realistic milestone)
Position 5 Goal (5000x growth):
• Threshold: $10K × 5000 = $50,000,000 MC
• Total circulating: 400M tokens (40%)
• Price at P5: $0.125 (1250x from genesis)
• CMC Rank: Top 500
• Started with $10K → Built $50M MC 🎯
✅ This is mathematically sound and proven:
Starting with $10K and achieving 5000x ($50M MC) is exactly how successful DeFi protocols launch. The ratio-based model ensures sustainable liquidity depth at every growth stage.

💰 TVL Calculation Method

Total Value Locked (in USD):
// Get pool reserves
(uint256 reserve0, uint256 reserve1) = pool.getReserves();

// Get ETH price from oracle (Chainlink)
uint256 ethPrice = getETHPrice(); // e.g. $3000

// Calculate token value (assuming CLAWD is token0, WETH is token1)
uint256 value0 = reserve0 × (reserve1 / reserve0) × ethPrice; // CLAWD value in USD
uint256 value1 = reserve1 × ethPrice; // ETH value in USD

// Total pool TVL
TVL = value0 + value1;

TVL is calculated in real-time using Chainlink price feeds for ETH. This ensures spawning triggers are accurate regardless of token price volatility.

📈 Multi-Generation Pool Growth

Exponential Expansion Model

Pool Generation Formula:
Generation 0 (Genesis): 1 pool (manual creation)
Generation 1 (Children): N pools (where N = childFees.length)
Generation 2 (Grandkids): N × M pools (each child can spawn)
Generation 3: N × M × K pools
...

// If each pool spawns 2 children on average:
Total Pools = 1 + 2 + 4 + 8 + 16 + 32 = 63 pools after 5 generations
Generation Pools Created Cumulative Total Estimated Timeframe
0 (Genesis) 1 1 Day 1
1 2 3 Week 2-4
2 4 7 Month 2-3
3 8 15 Month 4-6
4 16 31 Month 7-9
5 32 63 Month 10-12

Timeframes assume consistent trading volume and threshold triggers. Actual spawning depends on market conditions and liquidity depth.

🔒 Contract Security

⚠️ Important: These are automated smart contracts
All pool spawning is handled by immutable contract code. No manual intervention possible once deployed. Thresholds, fees, and strategies are set at pool creation and cannot be changed.

Reentrancy Guard

All external functions use OpenZeppelin's ReentrancyGuard to prevent reentrancy attacks during pool creation and seeding.

Ownable Access

Factory ownership controlled by multisig (3-of-5 Gnosis Safe). Only owner can update minLiquidity and factoryFeeBps.

Immutable Hooks

AutoSeedHook address is immutable - cannot be changed after deployment. Ensures consistent spawning behavior across all pools.

Start With What You Have 🎯

$1K or $100K - the math scales naturally. Pure ratios. Real automation.

Genesis (1x) → 5x → 100x → 1000x → 5000x
← Back to Home View API Docs →

Home Liquidity GitHub

🦀 ClawdPool × ClawdNation • The math is pure. The execution is automatic.