Developers

Load is a fair-launch token platform on Robinhood Chain. Launch an ERC-20 onto a Load bonding curve (~$2.50 creation fee), trade with live charts on load.fun, earn creator fees, and graduate into a locked Uniswap V3 LP at ~$35k FDV. Advanced launches can graduate into Uniswap V4 with a tax hook.

Introduction

• Non-custodial — every action is signed by the user's wallet.
• Fair launches — no presale, no team allocation; full supply minted to the bonding curve.
• LP locked — after graduation the V3 position NFT sits in LoadLPFeeVault (principal locked).
• Creator earnings — 0.60% of curve volume + 60% of post-grad LP fees.

Network

Deployed contracts

Load core

Load V4 tax

Uniswap & WETH (Robinhood Chain Testnet)

Each launch gets its own token and bonding curve. Look them up from TokenCreated events or factory.curveOf(token).

How it works

1. Launch — call LoadRouter.createToken with ~$2.50 creation fee (plus optional initial buy). Factory deploys the ERC-20 + bonding curve, mints supply to the curve, prepares Uniswap migration path, and emits TokenCreated.
2. Trade — buys/sells go through the router → curve (1% fee: 0.60% creator / 0.40% protocol). Optional anti-snipe window caps early non-creator buys.
3. Graduate — when the ~$35k FDV ETH threshold is met, graduate() migrates inventory into a full-range Uniswap V3 position locked in LoadLPFeeVault (Simple path). Advanced path uses createTokenV4 → Uniswap V4 + tax hook.

Setup

Examples use ethers v6 on Robinhood Chain Testnet (46630).

import { ethers } from "ethers";

const RPC = "https://rpc.testnet.chain.robinhood.com";
const CHAIN_ID = 46630;
const provider = new ethers.JsonRpcProvider(RPC, CHAIN_ID);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);

const A = {
  factory: "0x96855Ca3a0Ca29797FeD8BfE0c5a343Fa60510AD",
  vault:   "0x606942073e361f09b01f3c3f039fdcB9840410AD",
  router:  "0x983f7c6a14042456aF526Af25397238738F010AD",
  weth:    "0x7943e237c7F95DA44E0301572D358911207852Fa",
};

Launch a token

Use LoadRouter.createToken (handles the creation fee and an optional initial buy). Load launches use the ~$35k graduation cap. Post-grad creator LP share is factory-locked — read it on-chain; a mismatched value reverts with InvalidLaunchConfig.

const ROUTER_ABI = [
  "function createToken(string name,string symbol,bytes32 metadataHash,string metadataUri,(uint8 graduationCap,uint16 postGradCreatorShareBps,bool antiSnipe) launch,uint256 minTokensOut,uint256 deadline) payable returns (address token,address curve,uint256 tokensOut)",
];
const FACTORY_ABI = [
  "function creationFee() view returns (uint256)",
  "function POST_GRAD_CREATOR_SHARE_BPS() view returns (uint16)",
  "event TokenCreated(address indexed token,address indexed curve,address indexed creator,string name,string symbol,bytes32 metadataHash,string metadataUri,address pool,uint8 graduationCap,uint16 postGradCreatorShareBps)",
];

const router = new ethers.Contract(A.router, ROUTER_ABI, wallet);
const factory = new ethers.Contract(A.factory, FACTORY_ABI, provider);

const fee = await factory.creationFee(); // ~$2.50 in ETH at spot
const postGradCreatorShareBps = await factory.POST_GRAD_CREATOR_SHARE_BPS();
const launch = {
  graduationCap: 2, // ~$35k FDV design
  postGradCreatorShareBps,
  antiSnipe: true,
};
const metadataHash = ethers.id("ipfs://your-meta");
const deadline = Math.floor(Date.now() / 1000) + 600;

const tx = await router.createToken(
  "My Token",
  "MTK",
  metadataHash,
  "ipfs://your-meta",
  launch,
  0n,            // minTokensOut for optional initial buy
  deadline,
  { value: fee } // add ETH above fee for an initial buy
);
const rc = await tx.wait();

const ev = rc.logs
  .map((l) => { try { return factory.interface.parseLog(l); } catch { return null; } })
  .find((e) => e && e.name === "TokenCreated");
console.log("token:", ev.args.token, "curve:", ev.args.curve);

Buy (bonding curve)

Native ETH → tokens via the router while the token is still on the curve.

const ROUTER_ABI = [
  "function buy(address token,address recipient,uint256 minTokensOut,uint256 deadline) payable returns (uint256)",
];
const router = new ethers.Contract(A.router, ROUTER_ABI, wallet);

const ethIn = ethers.parseEther("0.05");
const deadline = Math.floor(Date.now() / 1000) + 600;
const tx = await router.buy(token, wallet.address, 0n, deadline, { value: ethIn });
await tx.wait();

Sell (bonding curve)

Approve the router (or use sellWithPermit), then sell tokens back to the curve for ETH.

const ERC20_ABI = [
  "function approve(address,uint256) returns (bool)",
  "function allowance(address,address) view returns (uint256)",
];
const ROUTER_ABI = [
  "function sell(address token,uint256 tokenAmount,address recipient,uint256 minEthOut,uint256 deadline) returns (uint256)",
];
const tokenC = new ethers.Contract(token, ERC20_ABI, wallet);
const router = new ethers.Contract(A.router, ROUTER_ABI, wallet);

const amountIn = ethers.parseEther("1000000");
if ((await tokenC.allowance(wallet.address, A.router)) < amountIn) {
  await (await tokenC.approve(A.router, ethers.MaxUint256)).wait();
}
const deadline = Math.floor(Date.now() / 1000) + 600;
await (await router.sell(token, amountIn, wallet.address, 0n, deadline)).wait();

After graduation, trade on Uniswap V3 (LoadV3SwapRouter or SwapRouter02) — the curve no longer accepts swaps.

Fees & claims

• Creation: ~$2.50 (creationFee()) / ~$5 V4 (creationFeeV4()) → treasury.
• Curve trades: 1% total — 0.60% creator (claimable) / 0.40% protocol.
• Post-grad LP: 1% Uniswap pool fee — 60% creator / 40% protocol via the vault.
• Load V3 router swaps may also take a 0.25% platform swap fee to treasury.

// Creator curve fees
const CURVE_ABI = ["function claimCreatorFees() returns (uint256)"];
const curve = new ethers.Contract(curveAddress, CURVE_ABI, wallet);
await (await curve.claimCreatorFees()).wait();

// Collect V3 LP fees into the vault, then claim creator share
const VAULT_ABI = [
  "function collectForToken(address launchToken) returns (uint256,uint256)",
  "function claimCreatorLpFees(address launchToken) returns (uint256,uint256)",
];
const vault = new ethers.Contract(A.vault, VAULT_ABI, wallet);
await (await vault.collectForToken(token)).wait(); // permissionless
await (await vault.claimCreatorLpFees(token)).wait(); // creator only

Graduation

When reserves hit the design cap, anyone can call graduate() on the curve (router buys may also auto-trigger). Migrator seeds the V3 pool and locks the LP NFT in the vault.

const CURVE_ABI = ["function graduate()"];
const curve = new ethers.Contract(curveAddress, CURVE_ABI, wallet);
await (await curve.graduate()).wait();
// Listen for Graduated(token, pool, tokenId, ...) from the migrator / curve flow

Read state

const FACTORY_ABI = [
  "function curveOf(address token) view returns (address)",
  "function tokenOf(address curve) view returns (address)",
  "function isCurve(address) view returns (bool)",
  "function creationFee() view returns (uint256)",
];
const CURVE_ABI = [
  "function token() view returns (address)",
  "function creator() view returns (address)",
  "function phase() view returns (uint8)", // 0 trading, 1 ready, 2 graduated
  "function GRADUATION_ETH() view returns (uint256)",
];
const factory = new ethers.Contract(A.factory, FACTORY_ABI, provider);
const curveAddr = await factory.curveOf(token);
const curve = new ethers.Contract(curveAddr, CURVE_ABI, provider);
console.log("phase:", await curve.phase());

// Stream new launches
const TOPIC = ethers.id(
  "TokenCreated(address,address,address,string,string,bytes32,string,address,uint8,uint16)"
);
// wsProvider.on({ address: A.factory, topics: [TOPIC] }, log => { ... })

Gotchas

• Always create through LoadRouter and send at least creationFee() (V3) or creationFeeV4() (V4) wei.
• postGradCreatorShareBps must equal factory.POST_GRAD_CREATOR_SHARE_BPS() or create reverts with InvalidLaunchConfig — never hardcode the share.
• Load launches use a ~$35k graduation cap; creator post-grad LP share is the factory constant above.
• Create may require a second wallet confirmation if the first attempt reverts (vanity tip race) — stay on the page and approve the retry.
• Curve fee split (0.60% / 0.40%) is frozen per token at create — not changeable later on that curve.
• After graduation, use Uniswap / LoadV3SwapRouter — curve buys/sells revert.
• Graduated LP is full-range and locked in the vault; collect then claim for creator LP fees.
• Metadata URI should match the metadataHash commitment (IPFS JSON).
• Advanced (V4 tax) launches use createTokenV4 with the V4 contracts listed above.