Launch a token

What you choose#

Choosing a pair#

Every token trades against one asset from CAST's approved pair list. Buyers pay with it, sellers receive it, and fees, holder rewards and your creator share are all paid in it. You choose it at launch and it can't change afterwards.

You can pick ETH, USDG (Paxos's dollar stablecoin) or one of these stock tokens: AAPL, NVDA, TSLA and SPY. Each pair has its own graduation target, set so that every token graduates at about the same dollar value: about $10,000 raised. The targets are 4.2 ETH, 10,000 USDG, 28.9 AAPL, 46.2 NVDA, 28.4 TSLA and 13.1 SPY.

The Launch page only lets you pick pairs that are open. CAST can close a pair to new launches, but tokens already paired with it keep trading as before.

Bonding curve and graduation#

Your token doesn't go straight into a pool. It starts on a bonding curve that the Fee Hook runs inside its Uniswap v4 pool: buyers buy from the curve, sellers sell back to it, and the price follows a fixed formula that rises as people buy. About 79.3% of the tokens for sale are sold this way.

When the curve has raised its graduation target, your token graduates in the same transaction as the buy that gets it there. Everything the curve raised and the remaining tokens go into one Uniswap v4 position at the curve's final price, locked forever, and from then on the token trades in its pool. There is nothing for you to do: it happens on its own.

With no creator allocation, 1 billion tokens open at about a third of the target, about $3,300 or 1.381 ETH on an ETH pair. They graduate at about 4.83 times the target, about $48,000 or 20.3 ETH. Your sealed rules apply on the curve exactly as in the pool. A tight max wallet means it takes more wallets to graduate. See Bonding curve and graduation for how it looks to buyers.

Three steps#

1. Pick a pair and a template

   Choose what your token trades against, and start from one of four templates or a blank rule set. Every rule can be edited.

2. Seal the rules

   Adjust each schedule. The fairness grade updates as you type, and every value is checked against the on-chain safety limits as you go, so you find out about a problem before you sign.

3. Launch

   One transaction creates the token, opens its bonding curve and creates its Uniswap v4 pool. Trading opens in that same transaction: your first buy, if you make one, is the curve's first trade, and anyone can trade right after. Once the curve has raised its target the token graduates into the pool, with its liquidity locked forever.

Start on the Launch page.

The creator's first buy#

You can buy your own token in the same transaction that launches it, paying in the paired asset. That buy goes through the bonding curve like any other: it pays Bot Tax and the buy fee at the launch block's rates, and counts toward max wallet. You also set the fewest tokens you'll accept, so the launch reverts instead of buying at a worse price.

If your first buy is big enough to raise the whole graduation target, your token graduates in the launch transaction and the rest of the buy is made in the new pool.

• ETH is sent with the launch transaction.
• USDG or a test stock: your wallet first asks you to sign a permit. It's a free signature that lets the Launcher take exactly that amount in the launch transaction. An asset without permit support needs an approval transaction first instead.

Keeping tokens for yourself#

A creator can reserve up to 10% of the supply. Those tokens are minted into the token contract itself and stay there until the lock you chose ends (at most 10 years). After that you can release them to any wallet, and max wallet still applies to whoever receives them.

Your allocation isn't sold on the bonding curve: the curve and the pool share the rest of the supply. The curve only buys back as many tokens as it has sold, so if you release your tokens before your token graduates, a sell bigger than that reverts with SellExceedsCurve.

The length of the lock affects the fairness grade:

What the creator earns#

CAST keeps 20% of every fee. You decide how the other 80% is split between holders, a token burn and yourself, and that split can change over time on a schedule. Bot Tax has its own split between holders and you. Your share is paid in your token's paired asset and builds up in the Fee Hook until you collect it from the Creator fees tab on your profile. Where fees go has the details.

If a paired asset's issuer freezes your wallet, as USDG's issuer can, collecting fails until the wallet is unfrozen. Your share stays recorded until then.

Image and links#

On the last step you can add a picture for your token and links to its X, Telegram and website. They appear on the token page, on cards and lists across CAST, and in the CAST token list that wallets and apps can import. Any square-ish PNG, JPEG, WebP or GIF works; it's cropped to a square and resized to 256 pixels in your browser.

The image and links aren't stored in the token contract, so adding them doesn't change the contract or cost gas. CAST only accepts them from the wallet that launched the token, so nobody else can set or change them. If you're signed in with that wallet, that sign-in is enough. If not, your wallet signs a short message listing them. Signing is free and sends no transaction.

When you launch with an image or links while signed in, your wallet only asks you to confirm the launch. If you're not signed in, it first asks you to sign the image and links. A first buy paid in USDG or a test stock can add a permit signature before the launch too. Either way, the image and links are saved as soon as the launch confirms. To change them later, open the token page or the Launches tab on your profile and choose Edit image and links. Signed in, saving needs no new signature.

After launch#

There is nothing left to manage. You can't change the rules, add liquidity, remove liquidity, pause trading or mint more, and neither can CAST. Only the image and links can still change. Share your token page: it shows every rule, the grade and the live Fee Clock to anyone who visits.

Launching from code#

You can call the Launcher directly. Its address is on Network and contracts.

struct LaunchParams {
    string name;
    string symbol;
    RuleSet rules;
    bytes32 salt; // mixed with your address; must put the token's address above pairAsset
    address referrer; // may be zero
    address pairAsset; // address(0) for ETH, or an open ERC-20 from CastPairs
    uint256 creatorBuyIn; // optional first buy, in the paired asset's smallest unit
    uint256 minCreatorTokens; // the fewest tokens the first buy may return
}

// ETH pair: send msg.value == creatorBuyIn. ERC-20 pair: send no value and approve the Launcher first.
function launch(LaunchParams calldata p) external payable returns (address token);
// The same, with an EIP-2612 permit for creatorBuyIn in the same transaction.
function launchWithPermit(LaunchParams calldata p, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (address token);

function tokenInitCodeHash(address creator, LaunchParams calldata p) external view returns (bytes32);
function predictTokenAddress(address creator, LaunchParams calldata p) external view returns (address);

error WrongValue(uint256 sent, uint256 expected);
error TokenBelowPairAsset(address token, address pairAsset);
error CreatorBuyTooSmall(uint256 received, uint256 minimum);
error PairNotOpen(address asset); // from CastPairs

The paired asset is always currency0 in the token's pool, so the token's address has to sort above the paired asset's. If it doesn't, the launch reverts with TokenBelowPairAsset. The Launcher deploys tokens with CREATE2, so you pick a salt off-chain that gives a high enough address:

• tokenInitCodeHash(creator, params) returns the init code hash.
• The CREATE2 salt is keccak256(abi.encode(creator, params.salt)), and the deployer is the Launcher.
• predictTokenAddress(creator, params) returns the address for one salt.
• For ETH, which is address zero, any salt works.

import { concat, encodeAbiParameters, getAddress, keccak256, toHex, type Hex } from "viem";

// `launcherAbi` includes tokenInitCodeHash, `creator` is the wallet that will send the launch and
// `params` is the LaunchParams it will send. The salt doesn't change the init code hash, so read it once.
const initCodeHash = await client.readContract({
  address: CAST.launcher,
  abi: launcherAbi,
  functionName: "tokenInitCodeHash",
  args: [creator, params],
});

// CREATE2 from the Launcher, with salt keccak256(abi.encode(creator, params.salt)).
function tokenAddress(salt: Hex) {
  const create2Salt = keccak256(encodeAbiParameters([{ type: "address" }, { type: "bytes32" }], [creator, salt]));
  return getAddress(`0x${keccak256(concat(["0xff", CAST.launcher, create2Salt, initCodeHash])).slice(26)}`);
}

// Try random salts until the token sorts above its paired asset. For ETH (address 0) the first one works.
let salt: Hex;
do salt = toHex(crypto.getRandomValues(new Uint8Array(32)));
while (BigInt(tokenAddress(salt)) <= BigInt(params.pairAsset));

const launchParams = { ...params, salt };

For an ERC-20 first buy, either approve the Launcher for creatorBuyIn and call launch with no value, or sign an EIP-2612 permit for the Launcher and call launchWithPermit. If the permit fails, for example because it was already used, the launch still goes ahead when an approval is in place. Sign the permit as for a buy, with the Launcher as spender and creatorBuyIn as the value: see Buy with a permit. Launching with a pair that isn't open reverts with PairNotOpen.