Launch, lock, and earn.

GoLaunch is a launchpad on Robinhood Chain. Launch an ERC-20 into a Uniswap V3 pool with liquidity locked forever, and earn 75% of the 1% trading fee your coin generates. Every action is signed by your own wallet — the platform never holds your funds.

Introduction

• Non-custodial— every action (launch, buy, sell, claim) is signed by the user’s own wallet.
• Immutable tokens — each coin is a plain ERC-20 with no owner, no mint, no tax, and no blacklist. A 2% max-wallet applies only during a short anti-snipe window at launch.
• LP locked by contract— the pool’s liquidity NFT is custodied by the LockVault, which has no withdraw / decreaseLiquidity path. It can never be pulled.
• Single-sided launch — the full 1,000,000,000 supply is placed into the pool as liquidity; price discovery starts from the first buy. No presale, no bonding curve.

Network

Deployed contracts

How it works

1. Launch (one transaction). The factory deploys an immutable ERC-20, creates and initializes its 1% Uniswap V3 pool, and mints a single-sided all-token liquidity position straight into the LockVault. The launch fee (0.0005 ETH) is sent to the protocol treasury; any ETH you send beyond the fee is used as your optional initial buy.

2. Liquidity locked forever. The position NFT lives in the LockVault, which has no function to withdraw or reduce liquidity — so the LP can never be pulled by anyone.

3. Trade. Every buy and sell routes through the pool and pays a 1% fee, which accrues inside the locked position.

4. Earn. Calling LockVault.collectFees(positionId) harvests the accrued fees: 75% of the ETH goes to the coin’s creator, 25% to the protocol treasury, and the token side is burned. It’s permissionless — anyone can trigger the harvest, and the funds always route to the creator + treasury.

Setup

Point any EVM library at the Robinhood Chain RPC and use a wallet funded with ETH. Examples below use viem.

import { createPublicClient, createWalletClient, custom, http, defineChain } from "viem";

export const robinhood = defineChain({
  id: 4663,
  name: "Robinhood Chain",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } },
});

const pub = createPublicClient({ chain: robinhood, transport: http() });
const wallet = createWalletClient({ chain: robinhood, transport: custom(window.ethereum) });

Launch a token

Call launchToken(params) on the factory with value = launchFee + initialBuy. Set image to a data:URI or URL (it’s stored on-chain and shown on the feed). Leave the initial buy at 0 to launch for the fee only (~0.0005 ETH).

const FACTORY = "0x1d0Ac54dA58422Fa9135554A4DeD2914b83B8754";
const ABI = [{
  type: "function", name: "launchToken", stateMutability: "payable",
  inputs: [{ type: "tuple", name: "p", components: [
    { name: "name", type: "string" }, { name: "symbol", type: "string" },
    { name: "image", type: "string" }, { name: "metadataURI", type: "string" },
    { name: "initialBuyMinTokensOut", type: "uint256" }, { name: "salt", type: "bytes32" },
  ]}],
  outputs: [{ name: "token", type: "address" }, { name: "pool", type: "address" }, { name: "positionId", type: "uint256" }],
}];

const launchFee = await pub.readContract({ address: FACTORY, abi: FEE_ABI, functionName: "launchFee" });
const hash = await wallet.writeContract({
  address: FACTORY, abi: ABI, functionName: "launchToken",
  args: [{ name: "Deep Whale", symbol: "WHALE", image: "", metadataURI: "",
           initialBuyMinTokensOut: 0n, salt: "0x" + "0".repeat(64) }],
  value: launchFee, // + parseEther("0.05") for an initial buy
});

Buy

Buying is a single exactInputSingle on the router: ETH in, token out. Pass the ETH as value — the router wraps it.

const ROUTER = "0xCaf681a66D020601342297493863E78C959E5cb2";
const WETH = "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73";
await wallet.writeContract({
  address: ROUTER, abi: ROUTER_ABI, functionName: "exactInputSingle",
  args: [{ tokenIn: WETH, tokenOut: token, fee: 10000, recipient: me,
           amountIn: parseEther("0.05"), amountOutMinimum: minOut, sqrtPriceLimitX96: 0n }],
  value: parseEther("0.05"),
});

Sell

Selling is the reverse — token in, WETH out. Approve the router for your token first, then swap (no value).

await wallet.writeContract({ address: token, abi: ERC20_ABI, functionName: "approve", args: [ROUTER, amountIn] });
await wallet.writeContract({
  address: ROUTER, abi: ROUTER_ABI, functionName: "exactInputSingle",
  args: [{ tokenIn: token, tokenOut: WETH, fee: 10000, recipient: me,
           amountIn, amountOutMinimum: minOut, sqrtPriceLimitX96: 0n }],
});

Quoting & slippage

All pools use the 1% fee tier. Always pass a real amountOutMinimum (minOut) — a swap that would return less reverts with “Too little received”. On thin, brand-new pools, price impact is large; size buys accordingly.

Collect fees

collectFees(positionId) on the LockVault harvests the accrued swap fees and splits them: 75% of the WETH to the creator, 25% to the treasury, token side burned. It’s permissionless — the creator’s share always goes to the address that launched the coin, no matter who calls it.

const VAULT = "0x5CC32edafDE447Dd4CC78F259598aC03373706AB";
await wallet.writeContract({
  address: VAULT,
  abi: [{ type: "function", name: "collectFees", stateMutability: "nonpayable",
          inputs: [{ name: "positionId", type: "uint256" }], outputs: [] }],
  functionName: "collectFees", args: [positionId],
});

Read state

// factory config
await pub.readContract({ address: FACTORY, abi: ABI, functionName: "launchFee" });   // 0.0005 ETH
await pub.readContract({ address: FACTORY, abi: ABI, functionName: "feeTier" });     // 10000 (1%)
await pub.readContract({ address: FACTORY, abi: ABI, functionName: "lockVault" });   // vault address

// vault: who owns a position's fees
await pub.readContract({ address: VAULT, abi: VAULT_ABI, functionName: "creatorOf", args: [positionId] });
await pub.readContract({ address: VAULT, abi: VAULT_ABI, functionName: "tokenOf",   args: [positionId] });

// discover launches from TokenLaunched(token, creator, pool, positionId, ...) event logs

Gotchas

• Immutable token — no owner, mint, tax, pause, or blacklist. The 2% max-wallet is enforced only during the ~60-block anti-snipe window, then lifts automatically.
• Every pool is the 1% fee tier (fee: 10000). Passing any other tier finds no pool.
• Launch cost is fee-only by default — sending exactly launchFee (~0.0005 ETH) launches with no initial buy. Extra ETH becomes your buy.
• collectFees is permissionless — anyone can trigger a harvest; funds always route to the creator (75%) and treasury (25%).
• Charts appear after the first trade — DEXScreener indexes a pool only once it has a swap, so a brand-new coin shows a placeholder until then.
• Slippage revertssurface as “Too little received” — raise amountOutMinimum headroom on volatile pools.