coins.fun STABLE · 988 Open app

Stable · Chain ID 988

Read this before you make one.

one makes it.

fixed supply · locked liquidity · priced in USDT

Overview

coins.fun is a place to launch and trade tokens on Stable. You can browse launches, open any token to see its details, and trade straight from your wallet.

coins.fun never holds your funds. Every launch and trade is a transaction your wallet asks you to approve.

Key facts

  • Names and symbols can be copied. Always check the token address.
  • Prices come from each token's live USDT pool, so every figure is in USDT.

How launches work

Creating a launch deploys the token and its USDT pool in a single transaction, and the pool's liquidity is locked automatically. The creator sets the name, symbol, image, description, links, and fee wallet at creation.

Every token trades against USDT in its own pool. There is no bonding curve and no graduation. Buys and sells happen in that same pool from the moment it launches.

01

Create

The token is minted with a fixed supply and its USDT pool goes live in the same transaction.

02

Trade

Buys and sells run against USDT in the locked pool and move the price.

03

Earn

Fees accrue in the locked position and the creator can claim their share at any time.

Each launch uses a fixed supply of one billion tokens, a 1% pool fee, and a $2 launch fee.

Single-sided liquidity

You post tokens, not USDT. The full supply goes into the pool as single-sided liquidity above the starting price, so no quote asset is required to open a market. Buyers bring USDT when they trade.

Supply is spread across concentrated bands rather than one flat range. The layout is fixed at deployment and identical for every token, so no launch can be shaped to favour whoever set it up.

NO BUYERS, NO USDT A token that has not traded has no USDT in its pool. That is expected rather than broken. Market cap at launch reflects the price supply is offered at, not capital anyone has committed.

Trading and pricing

Every token trades against USDT in its own liquidity pool. The price you see is the live pool price, and it moves with each trade. The amount you actually receive can differ slightly from the quote. Slippage sets how much of that movement you accept.

Price
The current pool price for one token, in USDT.
Market cap
Price multiplied by circulating supply, in USDT.
FDV
Supply is fixed, so FDV equals market cap.
Price impact
The pool movement caused by the size of your trade.
Slippage
The maximum execution movement your transaction accepts.
Liquidity
Assets available in the pool around the current price.

Because the quote asset is USDT, a market cap on coins.fun is a figure in USDT. It does not move when a volatile base asset moves.

The liquidity lock

The position is transferred to the locker contract at deployment. The locker has no withdrawal method and is not upgradeable. The creator cannot pull the liquidity, and neither can the coins.fun team.

Fees accrued by the position are claimable. The principal is not, by anyone.

Anyone can add their own liquidity or open another pool later. Those positions are not locked, and creator rewards accrue only from the initial locked position.

A lock prevents the pool being withdrawn. It does not make a token safe, and price can still fall to near zero through ordinary selling.

Fees and rewards

Trading generates fees in both the token and USDT. The creator keeps 70% and the protocol keeps 30%. The creator can claim their share from the coins.fun interface at any time.

The split is snapshotted for each token when it launches and never changes afterward.

Trading fee split 1% POOL FEE 70% 30%
  • 70% · CREATOR Paid in USDT, claimable at any time, for as long as the token trades.
  • 30% · PROTOCOL Divided between the team, the community pool, and $COINS buybacks.
The protocol share is divided between
  • Team and infrastructure
  • Community pool
  • $COINS buybacks

The allocation between those three is not final and will be published here once it is set.

Pool fee1% of every trade
Creator share70%
Protocol share30%
Launch fee$2 in USDT
Supply1,000,000,000 (1e9)

Protocol revenue

Protocol revenue comes from the 30% fee share and the $2 launch fee. Both accrue in USDT, so revenue is denominated in USDT at the moment it is earned.

It funds the team and infrastructure, the community pool, and an automated buyback of $COINS. Buying $COINS with protocol fees does not guarantee a higher price and is not a claim on protocol revenue.

ONE OFFICIAL TOKEN $COINS is the only official coins.fun token. Tokens launched through the interface are user-created and are not affiliated with or endorsed by coins.fun. Never take a contract address from a direct message.

$COINS

$COINS supply distribution SUPPLY DISTRIBUTION 54.5% 25.5% 20% public liquidity 54.5% liquid at launch burned forever 25.5% removed from supply ecosystem growth 20% locked for 12 months
Token0xfa0a8ea31f65eebfe31b83d2b9759a36396a98dd
Pool0x0EF60Ea3Ec4496ed52d790ce0343Da14e2C991e8
Expected registrydeploymentInfoForToken(COINS).token = COINS

Risk disclosures

Tokens launched through coins.fun are user-created and experimental. Review the token address, creator, liquidity, holder concentration, and transaction preview before signing.

  • Prices can move quickly and liquidity can be thin.
  • Similar names and images can represent unrelated tokens.
  • Smart contracts, wallets, RPCs, and indexers can fail.
  • Displayed values are estimates, not execution guarantees.
  • A creator's initial buy can be sold at any time.
  • USDT denomination removes base-asset volatility, not the risk that a token goes to zero.

coins.fun is an interface, not investment advice or a representation of token quality.

Integration

A minimal, verifiable integration surface.

Network

NetworkStable Mainnet
Chain ID988
Gas assetNative USDT · 18 decimals
Quote and feesERC-20 USDT · 6 decimals
Public RPChttps://rpc.stable.xyz
Explorerstablescan.xyz
Pool fee10000 · 1%
Launch fee2 USDT
Supply1,000,000,000 · 1e9

Contracts

UseContractAddress
Launch · registry · claimsCoinsFun
from block 35216402		0x3fc7C27eE52c60aF86D76aC131eC18837cCd8938
TokenCoinsFunTokenPer launch · TokenCreated.tokenAddress
Vested allocationCoinsFunVault0x62d2172512774DDCD188461Af1821b8B1d0d2934
LP reward settingsLpLockerV20xD7bc75eF967540fa0d81fe927a1aD8EaE3993b84
Launch fee · initial buyUSDT0x779Ded0c9e1022225f8E0630b35a9b54bE713736

Onchain events

Index TokenCreated from block 35216402 to discover coins.fun launches.

EmitterCoinsFun
From block35216402
topic00xb76b0d93bddd588eb0dc08ad47d4109d66c17665c21b090ed945aff29ce24e76
Launch discovery viem · parseAbiItem
import { parseAbiItem } from "viem";

const tokenCreated = parseAbiItem(
  `
  event TokenCreated(
    address indexed tokenAddress,
    address indexed creatorAdmin,
    address indexed interfaceAdmin,
    address creatorRewardRecipient,
    address interfaceRewardRecipient,
    uint256 positionId,
    string name,
    string symbol,
    string image,
    int24 startingTickIfToken0IsNewToken,
    string metadata,
    uint256 amountTokensBought,
    uint256 amountUsdt0Spent,
    uint256 vaultDuration,
    uint8 vaultPercentage,
    address msgSender
  )
`
    .replace(/\s+/g, " ")
    .trim(),
);

const launches = await client.getLogs({
  address: "0x3fc7C27eE52c60aF86D76aC131eC18837cCd8938",
  event: tokenCreated,
  fromBlock: 35216402n,
  toBlock: "latest",
});

msgSender, creatorAdmin, and interfaceAdmin are separate roles. Use the event fields rather than inferring ownership from the transaction sender.

Reading token state

Launch recordCoinsFun.deploymentInfoForToken(token)
TokenIdentity · metadata · supply · balance
VestingCoinsFunVault.allocation(token)
LP rewardslocker.tokenRewards(positionId)
Direct state reads viem · parseAbi
import { parseAbi } from "viem";

const tokenRewards = `
  function tokenRewards(uint256 tokenId) view returns (
    uint256 lpTokenId,
    uint256 creatorReward,
    (address admin, address recipient) creator,
    (address admin, address recipient) interfacer
  )
`
  .replace(/\s+/g, " ")
  .trim();

const coinsFunStateAbi = parseAbi([
  "function deploymentInfoForToken(address token) view returns (address token,uint256 positionId,address locker)",
  "function getTokensDeployedByUser(address user) view returns ((address token,uint256 positionId,address locker)[])",
]);

const coinStateAbi = parseAbi([
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function decimals() view returns (uint8)",
  "function totalSupply() view returns (uint256)",
  "function balanceOf(address account) view returns (uint256)",
  "function admin() view returns (address)",
  "function imageUrl() view returns (string)",
  "function metadata() view returns (string)",
  "function context() view returns (string)",
]);

const vaultStateAbi = parseAbi([
  "function allocation(address token) view returns (address token,uint256 amount,uint256 endTime,address admin)",
]);

const lockerStateAbi = parseAbi([tokenRewards]);

A zero token from deploymentInfoForToken means it is not a registered coins.fun launch. Use the returned locker and positionId to read its reward settings.

Pricing

VerifydeploymentInfoForToken(token).token === token
Resolve configuniswapV3Factory() · usdt0() · POOL_FEE()
Resolve poolfactory.getPool(token, usdt0, fee)
Read pricepool.slot0().sqrtPriceX96
Pricing read ABI viem · parseAbi
import { parseAbi } from "viem";

const coinsFunPricingAbi = parseAbi([
  "function deploymentInfoForToken(address token) view returns (address token,uint256 positionId,address locker)",
  "function uniswapV3Factory() view returns (address)",
  "function usdt0() view returns (address)",
  "function POOL_FEE() view returns (uint24)",
]);

const factoryAbi = parseAbi([
  "function getPool(address tokenA,address tokenB,uint24 fee) view returns (address pool)",
]);

const poolAbi = parseAbi([
  "function slot0() view returns (uint160 sqrtPriceX96,int24 tick,uint16 observationIndex,uint16 observationCardinality,uint16 observationCardinalityNext,uint8 feeProtocol,bool unlocked)",
]);
USDT spot price BigInt · 18-decimal fixed point
const Q192 = 1n << 192n;
const square = sqrtPriceX96 * sqrtPriceX96;
const tokenIsToken0 = BigInt(token) < BigInt(usdt0);

const numerator = tokenIsToken0
  ? square * 10n ** BigInt(tokenDecimals)
  : Q192 * 10n ** BigInt(tokenDecimals);

const denominator = tokenIsToken0
  ? Q192 * 10n ** BigInt(usdt0Decimals)
  : square * 10n ** BigInt(usdt0Decimals);

const priceUsdt0X18 = (numerator * 10n ** 18n) / denominator;
const currentSupplyValueUsdt0X18 =
  (priceUsdt0X18 * totalSupplyRaw) / 10n ** BigInt(tokenDecimals);

Both result values use 18 decimals. Use ERC-20 USDT decimals, not native gas-token decimals. This is an immediate spot price, not a trade quote or oracle price; do not display a price for a zero pool or zero sqrtPriceX96.

Support

For support, contact contact@coins.fun.