Launch

Launch or migrate to give your token better quotes, liquidity rewards, and DeFi superpowers.

Baseline supports two launch paths:

  1. Create: deploy a new token with its own Baseline liquidity pool.
  2. Migrate: keep the existing token, and migrate liquidity into a Baseline liquidity pool.

Need help or want to brainstorm what's possible with Baseline? Reach out to us in Discord or fill out this form and we'll get back to you.

Developers and agents can use the Baseline CLI to build unsigned launch calls, execute with an explicit signer, install agent skills, and inspect deployed tokens. App developers can use the Baseline SDK to create tokens, approve assets, and create pools with viem clients.

Create a token

For agent-assisted launches, install the Baseline skills and ask your agent to prepare a Baseline launch:

npx @baseline-markets/cli@latest skills add

The agent can prepare unsigned calls with the CLI, validate the artifact, and hand the calls to the approval path you choose. If you use Base MCP, the agent can submit through send_calls and give you the Base Account approval link.

For direct CLI usage, build a zero-reserve pool launch artifact:

npx @baseline-markets/cli@latest launch \
  --mode zrp \
  --chain-id 84532 \
  --account 0x0000000000000000000000000000000000000001 \
  --name "Example Baseline Token" \
  --symbol EBT \
  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
  --total-supply 1000000000 \
  --output .context/launches/example-launch.json

See the CLI docs for Base MCP submission, mainnet chain IDs, fee flags, local execution, and token inspection.

At the contract level, deploying a token can be done in three steps. If you're not a developer, a frontend to launch bTokens will be available in the near future.

  1. Call createBToken on the BFactory contract to deploy the token. The total supply is minted to the caller, and only that caller will be able to create the pool in step 3.
BFactory relay = BFactory(0xc81Fd894C0acE037d133aF4886550aC8133568E8);

// Deploys "Test Token" with ticker "TT" and a total supply of 1M.
// The full supply is minted to msg.sender, and only msg.sender can create its pool.
BToken bToken = relay.createBToken(
    "Test Token",
    "TT",
    1_000_000 ether,
    bytes32(0)
);
  1. Approve the Relay contract to transfer the quote asset and bToken. When createPool is called, this allows the contract to transfer liquidity from the caller into the Baseline pool.
BFactory relay = BFactory(0xc81Fd894C0acE037d133aF4886550aC8133568E8);

// Assumes the caller wants to seed the pool with their available balances.
uint256 initialPoolBTokens = bToken.balanceOf(msg.sender);
uint256 initialPoolReserves = reserve.balanceOf(msg.sender);

bToken.approve(address(relay), initialPoolBTokens);
reserve.approve(address(relay), initialPoolReserves);
  1. Call createPool on the BFactory contract to initialize the Baseline pool and launch the token live.
BFactory relay = BFactory(0xc81Fd894C0acE037d133aF4886550aC8133568E8);
address creator = msg.sender;

// 0.5e18 = 50% of post-protocol fees go to the creator, the rest goes to stakers.
uint256 constant STANDARD_CREATOR_FEE = 0.5e18;
// Total swap fee charged by the pool. 0.01 ether = 1%.
uint256 constant STANDARD_SWAP_FEE = 0.01 ether;

// Assumes the caller wants to seed the pool with their available balances.
uint256 initialPoolBTokens = bToken.balanceOf(msg.sender);
uint256 initialPoolReserves = reserve.balanceOf(msg.sender);

// Set non-zero if you want to have Baseline Options. These options start with
// collateralized supply that can be unlocked by repayment, or through
// increases in floor value.
uint256 initialCollateral = 0;
uint256 initialDebt = 0;

// The market price can be any number above BLV, but we recommend setting it
// relative to a premium of net asset value. Here, we set it to a 5% premium
// to backed circulating supply.
uint256 reserves = initialPoolReserves + initialDebt;
uint256 circ = bToken.totalSupply() - initialPoolBTokens;
uint256 bookPrice = reserves * 1e18 / circ; // WAD
uint256 initialActivePrice = bookPrice * 105 / 100;

// Pass initialBLV as 0 so the protocol auto-calculates the starting floor.
BFactory.CreateParams memory poolParams = BFactory.CreateParams({
    bToken: bToken,
    initialPoolBTokens: initialPoolBTokens,
    reserve: address(reserve),
    initialPoolReserves: initialPoolReserves,
    initialActivePrice: initialActivePrice,
    initialBLV: 0, // use zero to autocalculate BLV
    creator: creator,
    feeRecipient: creator,
    creatorFeePct: STANDARD_CREATOR_FEE,
    swapFeePct: STANDARD_SWAP_FEE,
    createHook: false,
    claimMerkleRoot: bytes32(0),
    initialCollateral: initialCollateral,
    initialDebt: initialDebt
});

relay.createPool(poolParams);

Congratulations! Your bToken is live. You can now:

Routers (e.g. KyberSwap) and indexers (e.g. CoinGecko and Defined) automatically route and index trades within seconds. The token will also appear under Baseline DEX on CoinGecko and GeckoTerminal.

Migrate a token

Existing tokens can migrate their liquidity to a Baseline pool to unlock better quoting, a guaranteed floor value, and DeFi features such as staking, borrowing and leveraging native to the token itself. Backtested simulations show that tokens on Baseline DEX have better price performance, liquidity growth, supply control and fee accrual than traditional DEX pools.

Migration is possible from any liquidity pool, including Uniswap (V2, V3 and V4), Aerodrome, and other pool designs. At a high level, the project withdraws or migrates liquidity from the existing pool and initializes the Baseline pool with the chosen quote asset and launch parameters. The process takes less than an hour.

Interested in migrating a token? Reach out to us in Discord or fill out this form and we'll get back to you.