The Greenwood field guide.

Greenwood is a meme-token launchpad on Robinhood Chain, an Arbitrum Orbit L2 where the gas token is ETH. One transaction (GreenwoodLaunchpad.launch()) deploys a fixed-supply ERC-20, opens a TOKEN / ETH Uniswap v4 pool with the Greenwood hook, puts 100 % of the supply in it and mints the LP position to 0x…dEaD. Nobody can ever pull the liquidity.

There is no configurable tax: every swap pays a fixed 1 % hook fee. FEE_BPS = 100 is a constant and the hook has no owner, so the rate can never change. The fee is split 80 % to the launch’s fees recipient (the creator by default) and 20 % to the protocol.

$WOOD is Greenwood’s official platform token, pinned on the board.

Greenwood runs on Robinhood Chain, an EVM-compatible Arbitrum Orbit L2. Any wallet that supports custom networks works, and gas is paid in ETH.

Every Greenwood token trades against a single quote: ETH. Nothing is chosen at launch, and there are no other quote assets.

From Create, fill in a name, ticker, description and logo, choose a starting market cap, optionally add a first buy, and sign once. The app calls GreenwoodLaunchpad.launch(LaunchParams) (payable). One atomic transaction does everything:

1. 1Deploy a full GreenwoodToken contract (not a clone) via CREATE2. Its constructor mints the whole supply to the launchpad and renounces ownership.
2. 2Initialise the Uniswap v4 pool: ETH / token, LP fee 0, tick spacing 200, hooks = LaunchHook, at the start tick of the chosen market cap. A pool that is already initialised makes the launch revert.
3. 3Hand the pool’s fees-recipient role in the hook to your feesRecipient (address(0) = you), before any swap can pay a fee.
4. 4Mint a single-sided, token-only position over [minUsableTick, startTick] holding 100 % of the supply, straight to 0x…dEaD: burned.
5. 5Optional first buy with msg.value through the UniversalRouter, tokens sent to your wallet.
6. 6Refund the rounding dust, record the Launch and emit Launched.

Starting market cap

The starting market cap sets the pool’s opening price. The start tick is the multiple of 200 closest to that price, so the real figure lands within about 1 % of the preset.

// token = currency1, ETH = currency0 (both 18 decimals)
tokensPerUsdc(tick) = 1.0001 ^ tick
startTick           = round(log(supply / marketCapUsd) / log(1.0001) / 200) * 200
marketCap(tick)     = supply / 1.0001 ^ tick
marketCap(sqrtP)    = supply / (sqrtPriceX96 / 2^96)^2

The token contract

Every launch deploys the same contract, GreenwoodToken: an OpenZeppelin ERC-20 whose supply is minted once, in its constructor. It is a real contract at the token address, not a proxy: there is no implementation to swap and nothing that can mint.

Greenwood has no configurable tax and no allocation buckets. Every pool carries LaunchHook, which takes a fixed 1 % on every swap and books it for the pool. The rate is a constant in the hook’s code and the hook has no owner.

What the hook does

Greenwood has no anti-snipe machinery. The only thing it guarantees is ordering: the creator’s optional first buy runs inside the launch transaction, right after the pool is created, so nobody can buy before it.

That first buy has no cap. A creator can buy any share of the supply at the launch price, before anyone else, and sell it to later buyers. Burned liquidity does not prevent that: before you buy, look at the launch transaction and the creator’s balance.

Each token page has a swap panel that routes through Uniswap’s UniversalRouter and quotes with the V4Quoter. The pool is a standard Uniswap v4 pool, so any v4-aware wallet, aggregator or bot can trade it too.

Fees accumulate per pool in LaunchHook: fees(poolId) returns the recipient and what is owed in ETH (owed0) and in the token (owed1). They are split when LaunchHook.collectFees(poolKey) is called, by anyone: from the token page’s Collect fees button or directly on the contract.

Example: 1 % hook fee (FEE_BPS = 100), split 80 / 20 on collect

Buy, exact-in: 1 ETH in → the pool outputs X tokens
  fee              = 1 % of X        (in tokens, booked as owed1)
    creator  (80 %) = 0.8 % of X     → fees recipient
    protocol (20 %) = 0.2 % of X     → TREASURY       (token side)
  trader receives  = 99 % of X

Sell, exact-in: tokens in → the pool outputs 1 ETH
  fee              = 0.01 ETH          (native ETH, booked as owed0)
    creator  (80 %) = 0.008 ETH      → fees recipient
    protocol (20 %) = 0.002 ETH      → TREASURY       (ETH side)
  trader receives  = 0.99 ETH

Payout rules

Every launch has a fees recipient: your wallet by default, or any address chosen at launch. It earns 80 % of every swap fee on the pool, for as long as the pool exists.

Every token is in its final Uniswap v4 pool from the moment it launches: the LP is burned to 0x…dEaD in the launch transaction. There is no bonding curve and nothing to graduate to.

All Greenwood contracts are immutable: no proxies, no upgrade path. GreenwoodLaunchpad, LaunchHook and every GreenwoodToken have no owner: nobody can pause trading, change the fee or redirect a creator’s 80 %.

Who controls what

Previous deployment (retired)

Everything an explorer, a bot or an aggregator needs is on-chain: no API key, no indexer. The launchpad keeps a registry you can page through, and every pool is a standard Uniswap v4 pool.

1 · Reading token metadata

There is no contractURI() / EIP-7572: the metadata lives in the launch record, as a JSON string of at most 2,048 bytes stored on-chain, logo included.

import { createPublicClient, http } from "viem";

const client = createPublicClient({ transport: http("https://rpc.mainnet.chain.robinhood.com") });

// reverts BadArgs if the token was not launched by this launchpad
const launch = await client.readContract({
  address: LAUNCHPAD, abi: launchpadAbi, functionName: "launchOf", args: [token],
});

const meta = JSON.parse(launch.metadata);
// {
//   "description": "What this token is about",
//   "image":       "data:image/webp;base64,UklGR…",   // square logo ≤ 96 px, on-chain
//   "socials":     ["https://x.com/yourtoken"],
//   "website":     "https://yourtoken.xyz"
// }

2 · Discovering all launches

event Launched(
  address indexed creator,
  address indexed token,
  bytes32 poolId,
  uint256 nftId,       // burned LP position
  uint256 supply,
  int24   initTick,
  string  name,
  string  symbol
);                     // metadata is not in the event: read launchOf(token)

totalLaunches()                → uint256
getLaunches(start, stop)       → Launch[]    // [start, stop), clamped
launchesByCreator(creator)     → address[]
launchIndexByToken(token)      → index + 1   // 0 = not a Greenwood launch

3 · Reading the v4 pool

// PoolKey of every Greenwood launch: ETH always sorts first
const key = {
  currency0:   "0x0000000000000000000000000000000000000000", // ETH
  currency1:   token,
  fee:         0,
  tickSpacing: 200,
  hooks:       GREENWOOD_HOOK,
};
poolId = keccak256(abi.encode(key))           // also stored in launch.poolId

StateView.getSlot0(poolId) → (sqrtPriceX96, tick, protocolFee, lpFee)
tokensPerUsdc = (sqrtPriceX96 / 2^96)^2       // both sides 18 decimals: no 10^12 factor
priceUsd      = 1 / tokensPerUsdc
marketCapUsd  = supply / tokensPerUsdc

PositionManager.ownerOf(launch.nftId) == 0x…dEaD   // the LP is burned

4 · Swapping

Call UniversalRouter.execute(commands, inputs, deadline) with command V4_SWAP (0x10) and the actions SWAP_EXACT_IN_SINGLE, SETTLE_ALL, TAKE_ALL. A buy, as the app sends it:

import { encodeAbiParameters, encodePacked } from "viem";

const actions = encodePacked(["uint8", "uint8", "uint8"], [0x06, 0x0c, 0x0f]);
const params = [
  encodeAbiParameters([exactInputSingleParams], [{
    poolKey: key, zeroForOne: true, amountIn, amountOutMinimum: minOut, hookData: "0x",
  }]),
  encodeAbiParameters([{ type: "address" }, { type: "uint256" }], [key.currency0, amountIn]), // SETTLE_ALL
  encodeAbiParameters([{ type: "address" }, { type: "uint256" }], [key.currency1, minOut]),   // TAKE_ALL
];
const input = encodeAbiParameters([{ type: "bytes" }, { type: "bytes[]" }], [actions, params]);

await walletClient.writeContract({
  address: UNIVERSAL_ROUTER, abi: universalRouterAbi, functionName: "execute",
  args: ["0x10", [input], deadline],
  value: amountIn, // native ETH, 18 decimals: no approval
});

Where to find what

Greenwood has no public REST API: the app’s own server routes (RPC relay, analytics, source verification) are internal. Everything below is a contract call on Robinhood Chain, readable through any RPC.

Base

rpc        https://rpc.mainnet.chain.robinhood.com   // Robinhood Chain, chain ID 4663
launchpad  0x5710Fb3E6E9654D220ea3F3e495b7D376B2bD81B
hook       0x7D4963d6ADFD22350e1556c6b43897BcbFaad0c4

GreenwoodLaunchpad

LaunchHook

Errors

Launch record

struct Launch {
  address token;
  bytes32 poolId;         // Uniswap v4 pool id
  uint256 nftId;          // LP position, owned by 0x…dEaD
  address creator;
  address feesRecipient;  // at launch; live: LaunchHook.fees(poolId).recipient
  uint64  timestamp;
  int24   initTick;       // start price
  uint256 supply;         // 18 decimals
  string  name;
  string  symbol;
  string  metadata;       // JSON: description, image, socials, website
}

Price history

getCheckpoints(poolId, start, stop) → Observation[]   // ≤ 1 per clock minute, the pool's whole life
struct Observation { uint48 timestamp; int64 tickCumulative; }

// exact TWAP between two consecutive checkpoints a and b:
meanTick      = (b.tickCumulative - a.tickCumulative) / (b.timestamp - a.timestamp)
tokensPerUsdc = 1.0001 ^ meanTick
priceUsd      = 1 / tokensPerUsdc
// live end of the series: observe(poolId, [0])