Smart Contracts

Solidity 0.8.24/0.8.26, Cancun EVM, viaIR optimizer, Hardhat + OpenZeppelin UUPS proxies.

Architecture

  ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
  │ PlatformConfig│◄────│   Factory    │────►│   Registry   │
  │  (RBAC hub)  │     │ (deployer)   │     │  (tracking)  │
  └──────┬───────┘     └──────┬───────┘     └──────────────┘
         │                    │
         │  fees, treasury,   │  deploys
         │  version, paused   │
         │                    ▼
         │            ┌──────────────┐     ┌──────────────┐
         └───────────►│    Launch    │────►│  MemeToken   │
                      │(BondingCurve)│     │   (ERC-20)   │
                      └──────┬───────┘     └──────────────┘
                             │
                             │  graduation
                             ▼
                      ┌──────────────┐
                      │LiquidityMgr  │
                      │  → Adapter   │
                      │   (Uni v4)   │
                      └──────────────┘
    

PlatformConfig is the central RBAC hub. Factory deploys MemeToken + Launch pairs and snapshots platform config. BondingCurve (via Launch) is the AMM. Registry tracks all launches. LiquidityManager delegates graduation to registered adapters.

Contract Addresses

Import programmatically:

import { CONTRACT_ADDRESSES, getAddressesForChain } from "robin-launch/constants";
const addr = getAddressesForChain(46630);

Factory.sol

Core deployer for meme tokens. UUPS upgradeable, initialized with PlatformConfig, reserve target, and curve supply defaults.

State Variables

createToken

function createToken(
    bytes32 platformId,
    string name, string symbol, string description, string imageUri,
    string website, string twitter, string telegram, string discord,
    uint256 minTokensOut,   // 0 = no initial buy
    uint256 deadline,        // block.timestamp + N
    uint256 reserveTarget    // 0 = use defaultReserveTarget
) external payable returns (address token, address launch)

Deploys MemeToken → deploys Launch → transfers supply to Launch → registers in Registry → forwards creation fee. If minTokensOut > 0 and msg.value > TOKEN_CREATION_FEE, the excess buys tokens atomically and forwards them to the creator.

Modifiers: signupRequired(platformId) checks global + platform pause state. nonReentrant.

registerPlatform

Delegates to PlatformConfig.registerPlatform (with value: msg.value). Cost: 0.0005 ETH.

BondingCurve.sol

Constant-product bonding curve. Each token launch deploys a Launch contract that inherits from BondingCurve. All immutable state is set at construction from the Factory.

Immutables

Virtual Reserves

// Initialised in constructor
virtualEthReserves = reserveTarget / 4;
virtualTokenReserves = (curveSupply * 5) / 4;
k = virtualTokenReserves * virtualEthReserves;

The 25% virtual ETH and 125% virtual token reserves create a smooth price curve from the start — no infinite initial price.

buy

function buy(uint256 minTokensOut, uint256 deadline)
    external payable whenNotPaused nonReentrant

Deducts fee from msg.value, computes tokens via constant product, transfers tokens to buyer. If tokens would exceed remaining supply, caps the buy, refunds excess ETH, and triggers graduation.

sell

function sell(uint256 tokensIn, uint256 minEthOut, uint256 deadline)
    external whenNotPaused nonReentrant

Fee Distribution Per Trade

Trade Amount
├── Net (after fee deduction)
└── Fee
    ├── Protocol Fee (0.25%) → protocolTreasury
    ├── Creator Share (%) of platformFee → creator
    └── Platform Remainder → platformTreasury

Graduation

When realEthReserves ≥ reserveTarget or the buy exhausts remaining supply, the curve graduates:

PlatformConfig.sol

Central RBAC and configuration hub. UUPS upgradeable, inherits OpenZeppelin AccessControlUpgradeable.

Structures

Fee Limits (global)

LP fee tier must be exactly 5000 (0.5%), 10000 (1.0%), or 25000 (2.5%).

Fee Vaults (Pull Model)

protocolFeesAccrued;                    // global
platformFeesAccrued[platformId];         // per platform
creatorFeesAccrued[creatorAddress];      // per creator
// Plus token-level accumulators for DEX fees

Registry.sol

Central on-chain registry tracking all launches, bonding curves, graduation status, and trade history.

MemeToken.sol

Standard ERC-20 (OpenZeppelin) with extended metadata and fixed 1 billion token supply.

uint256 public constant TOTAL_SUPPLY = 1_000_000_000 * 10**18;
address public immutable creator;
uint256 public immutable creationTimestamp;
// Plus: description, imageUri, website, twitter, telegram, discord

Deployed by Factory with msg.sender as initial owner. Full supply minted to Factory, then transferred to Launch.

LiquidityManager.sol

Decoupled coordinator that delegates liquidity provisioning to registered ILiquidityAdapter implementations. New DEX integrations only need a new adapter — no core contract changes.

UniswapV4Adapter

Implements ILiquidityAdapter. Creates Uniswap v4 pools with the configured LP fee tier and adds full-range liquidity on graduation. No LP withdrawal function exists — liquidity is permanently locked (anti-rug mechanism).

Roles & Access Control

Platform roles are derived: keccak256(abi.encodePacked("ROLE_NAME", platformId))

Events

Custom Errors

Configuration Versioning

When a platform owner updates fees or treasury, the platform's version increments. The Factory snapshots the current version into each new Launch contract, so active bonding curves are immutable regardless of later config changes. Changing platform fees never affects existing launches.