Developer Documentation

What is Klik?

Klik lets anyone launch tokens with on-chain liquidity. This guide covers the current Ethereum ETH, Stock and Custom launch flow: direct Uniswap v4 pools against native ETH or an allowed ERC-20, with optional holder dividends.

New direct-pair pools use the actual pairing asset. Other networks, Reserves and older tokens keep their own deployed contracts and fee rules.

The KLIK Token

KLIK is the platform's own token, launched on Klik. Its original deployed contracts and fee rules remain separate from the current direct-pair release below.

Supply only ever goes down. Buybacks burn what they buy, sototalSupply() is the live number and the figure above is the starting one.

Distribution

80% of supply is held in the Safe multisig and is not circulating. It splits two ways:

• 70% - community reserve. Held in the Safe and not circulating. Nothing from it is sold on the market; how it is distributed is announced round by round (see Airdrop Rounds).
• 10% - team, vesting. Released on a schedule rather than at once.

The entire 80% allocation has been burned, including the 70% community reserve and the 10% team allocation. Neither allocation remains available for distribution or vesting.

The remaining 20% went into the Uniswap V4 pool at launch and is what trades today. There was no presale, no private round and no allocation to anyone outside the two lines above.

What the revenue does

Klik earns a share of every swap on every token launched through it, across all chains (see Fee Schedule). That revenue funds three things and nothing else:

• Buybacks and burns of KLIK, which permanently reduce supply
• Airdrop rounds - a share of revenue paid out to the traders and creators who generated it (see Airdrop Rounds)
• Operational costs - infrastructure, indexers, RPC and audits

Both sides scale with usage: every launch and every trade on any Klik chain feeds the same pool of revenue. Burns are visible on chain in the token's fallingtotalSupply().

Airdrop Rounds

Klik pays rewards in rounds, straight out of platform revenue.

• Where the money comes from. Klik earns a share of every swap on every token launched through it, on every chain (see Fee Schedule). A slice of that revenue is set aside for each round.
• Who gets it. Traders, by the volume they traded through Klik during the round, and creators, by the volume the tokens they launched brought. The more you traded or launched, the larger the share.
• How it is paid. Directly to the wallet that earned it, on chain. Nothing to buy, stake, lock or claim.
• When. Each round is announced ahead of time with its dates and the amount on the table. When it closes, shares are computed from on-chain volume and the payout follows.

Trading Fees (Latest version)

After the launch block, current Ethereum direct-pair pools charge 1% on buys and sells, collected by the hook in the pairing currency. The pool itself has a 0% LP fee.

The creator's opening buy in the launch block is exempt from the hook fee.

The fee split is 80% to holders or the creator / 20% to KLIK. On a swap with a 1% fee, those shares are 0.8% and 0.2% of the fee-bearing pair amount.

The controller can change this split for future fees across all pools using that hook. Already-accrued fees keep their original allocation. There is no per-token split override.

This schedule applies to the latest Ethereum direct-pair release. Older tokens and other deployments retain their own fee rules. The hook's protocolFeeBps() is the authoritative setting; KLIK's share is capped at 50% of collected fees.

Current Ethereum Contracts

Chain ID: 1. These addresses identify the deployed direct-pair release. Before a new launch, resolve activeEngine() from the gateway. For an existing token, resolve engineOf(token) instead.

The gateway can select a new engine for future launches. Existing tokens remain bound to their original engine and hook. Changing the gateway selection does not upgrade an existing pool.

Launch Sequence

1. Choose ETH, Stock or Custom and an allowed pair. ETH profiles shown in the app open at 1, 2, 5 or 10 ETH market cap. Stock and Custom use the factory'stargetMcapUsdE8() setting, initialized to $5,000.
2. Upload an optional image with POST /api/uploadImage, then metadata withPOST /api/uploadMetadata. External image and metadata URLs are also supported.
3. Resolve and validate the active engine, then request its signed pair-price quote usingGET /api/anypair/price?chain=1&token=PAIR&launcher=ENGINE. Native ETH uses the zero address. The quote must be unexpired and signed for that engine.
4. Mine a CREATE2 salt using that engine's token deployer. The resulting token address must sort above the pair address. The app's mineAnySalt helper handles this; a legacy factory salt is not interchangeable.
5. Choose whether to enable dividends and set an optional creator buy. Approve the correct funding spender when paying with ERC-20s. A routed ETH buy requires a valid same-chain route.
6. Build and simulate gateway.launch(request) with the actual funding and current engine. Review the expected token amount, then sign.

// Outer gateway request. launchData encodes the active engine's V2 payload.
{
  expectedEngine, fundingAsset, expectedVault,
  assetsIn, minSharesOut, deadline, launchData
}

// V2 launchData fields, ABI-encoded as one tuple:
{
  name, symbol, metadata, salt, pair, liquidityProfile,
  withDividends,
  quote: { priceUsdE8, deadline, signature },
  router, minPairOut, swapData
}

Use the ABI and buildGatewayLaunchCall helper insrc/lib/anypairGateway.ts. Native funding sends ETH as transaction value; ERC-20 funding uses the gateway's funding flow. Direct-pair format 2 settles in the raw currency; do not substitute wrapper shares. A changed engine or expired quote requires a fresh preview.

Holder Dividends

Dividends direct the non-platform fee share to eligible token holders in the pairing currency. Creators can enable them at launch or later through enableDividends(token) on the token's engine. Activation is irreversible. Earlier creator fees remain claimable.

Automatic payouts are processed in bounded batches during supported token activity; they are not a promise of an immediate payout after every trade. Assigned rewards can also be claimed manually. Sell-generated rewards wait for a buy in a later block before allocation.

Read withdrawableDividendOf(holder) on the token for assigned pending rewards. The holder can call claimDividend(recipient) to receive their own entitlement. Parked sell rewards are separate from claimable balances.

Claim Fees

Creator claims attempt to flush pending fees before paying the engine's recorded balance. Reading a token contract's ETH balance is not a creator-fee quote for this release. The KLIK admin Treasury tab separates fees ready to pull from fees still waiting to flush.

Indexing

Discover new tokens using tokenCount() and deployedTokens(index) on the engine. Keep previous engines indexed after upgrades; resolve each token through its gateway binding.

getMarketCapInPair(token) reads the pool price and supply in raw pair units. Divide by the pair's decimal unit and multiply by a current pair/USD price for dollar market cap.getMarketCapUsdE8(token) uses a saved pair-price quote and is not a live USD oracle.

Metadata & Price APIs

Upload image

POST /api/uploadImage: multipart form with a file field. Response: { "cid": "...", "url": "..." }.

Upload metadata

POST /api/uploadMetadata: JSON metadata, returning a CID.

{
  "name": "My Token",
  "symbol": "MYT",
  "description": "Your token description",
  "image": "ipfs://IMAGE_CID",
  "website": "https://example.com",
  "twitter": "https://x.com/example",
  "telegram": "https://t.me/example"
}

Pair-price quote

GET /api/anypair/price?chain=1&token=PAIR&launcher=ENGINE returns the engine address, priceUsdE8, deadline and signature alongside pair information. Always supply and verify the selected engine; omitting it can select a legacy quote domain.

nosign=1 is for display only: its empty signature and zero deadline cannot launch a token. Pair availability, quote expiry and simulation must all pass before submission.

Legacy /api/uploadTokenMetadata and /api/generate-saltintegrations do not replace the current gateway preparation flow.

Read Current Settings

This read-only example discovers the active factory and fee split. It does not sign or send a transaction.

import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://ethereum-rpc.publicnode.com');
const gateway = new ethers.Contract(
  '0xCA7aF38b09c49a87d8a3936F47972365Bf41531C',
  ['function activeEngine() view returns (address)',
   'function engineOf(address) view returns (address)'], provider
);
const engineAddress = await gateway.activeEngine();
// For existing tokens, use await gateway.engineOf(tokenAddress) instead.
const engine = new ethers.Contract(engineAddress,
  ['function hook() view returns (address)'], provider);
const hook = new ethers.Contract(await engine.hook(), [
  'function FEE_BPS() view returns (uint256)',
  'function protocolFeeBps() view returns (uint256)'
], provider);
const share = await hook.protocolFeeBps();
console.log('Trading fee:', Number(await hook.FEE_BPS()) / 100, '%');
console.log('KLIK share:', Number(share) / 100, '%');
console.log('Creator / holders share:', Number(10000n - share) / 100, '%');

Older pools and other networks remain accessible in the app. Their original contracts determine their fees; this guide's current Ethereum schedule does not overwrite them.