Everything about BaseStocks, in one place.

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

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

Creating a launch deploys the token and its trading 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 in its own pool, against the asset chosen at launch: ETH, USDC, or a tokenised equity. There is no bonding curve and no migration later. Buys and sells happen in that same pool from the moment it launches.

1. 01

   Create

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

2. 02

   Trade

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

3. 03

   Graduate

   The launch graduates once enough of the paired asset is held in the position, and trading continues in the same pool.

Each launch uses a fixed supply of one billion tokens and a small 0.0005 ETH launch fee. The pool fee is set by the DEX configuration the launch uses, and the interface shows it on every token.

Every token trades against its paired asset 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.

Market cap

Price multiplied by circulating supply.

FDV

Price multiplied by the full token supply.

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.

A launch graduates once the paired principal held in its locked position reaches the threshold. Both the principal and the threshold are read from the factory, and the progress line tracks how close a launch is.

Once reached, graduation is kept. The contract answers for the current price, so a token that graduates and then sells off would read as not graduated again; the interface derives the milestone from price history instead, so it does not flicker.

Graduation only confirms the threshold was reached. It is not a quality signal and does not guarantee future liquidity, price, or an exit.

Trading continues in the same pool after graduation. Nothing moves or migrates.

Trading generates liquidity fees in both the token and its paired asset. The protocol keeps a share and the creator keeps the rest. The creator can claim their share from the BaseStocks interface at any time.

The split is snapshotted for each token when it launches and never changes afterward. Read the snapshotted share from the locker rather than assuming a number: see Pricing and graduation for the call.

Creator rewards accrue in the token's locked position. When they are available, the creator can claim them at any time.

Tokens launched through BaseStocks 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 tokenised equity used as a pair is a separate asset with its own risks.

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

Never share a private key or seed phrase. BaseStocks will never ask you to send funds.

BaseStocks runs on Base. Tokens launch directly into Uniswap V3 and are quoted against the asset chosen at launch.

Network

Base

Chain ID

8453

Native asset

ETH

Public RPC

https://mainnet.base.org

Explorer

basescan.org

Launch fee

0.0005 ETH

Supply

1,000,000,000 (1e9)

Deploy block

50,408,769

Pair assets are ETH, USDC, and the tokenised equities listed in the launch form. Decimals differ between them: the tokenised equities use 8 and USDC uses 6, so read decimals() rather than assuming 18.

Deployed addresses on Base. All three protocol contracts were deployed at block 50,408,769 and are owned by the treasury Safe.

For a trust-minimized integration, index the factory's TokenLaunched event, register each emitted pool, and index its Swap events. Onchain events are the authoritative source of truth.

The factory emits two events per launch. TokenCreated carries the name, symbol and supply; TokenLaunched carries the pool and position. Index TokenLaunched: it is the one that tells you where trading happens.

TokenLaunched (topic0)

0x056750b7ad87c34c55227529064fa70a3a9907c1b28107cdec1d3c82392d4f08

Swap (topic0)

0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67

import { createPublicClient, http, parseAbiItem } from "viem";
import { base } from "viem/chains";

const client = createPublicClient({ chain: base, transport: http() });

const launches = await client.getLogs({
  address: "0xccfe8333587536AA6B45232B179d144ba69cf7b3",
  event: parseAbiItem(
    "event TokenLaunched(address indexed token, address indexed deployer, address indexed dexFactory, address pool, uint256 positionId, uint256 restrictionsEndBlock, uint256 initialBuyAmount)",
  ),
  fromBlock: 50_408_769n,
  toBlock: "latest",
});

Derive trade direction from the swap amounts and the token ordering in the pool:

tokenIsToken0 = token < pairToken
pairSigned    = tokenIsToken0 ? amount1 : amount0
side          = pairSigned > 0 ? "buy" : "sell"

There is no migration event. Read graduationStatus(token) for graduation, and optionally index token Transfer events for holder balances.

Public RPCs time out on wide eth_getLogs ranges. Backfill in bounded block chunks from block 50,408,769.

Every launch token is self-describing onchain. Read its metadata and canonical pool directly from the token contract, with no off-chain source required.

import { parseAbi } from "viem";

const tokenAbi = parseAbi([
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function decimals() view returns (uint8)",
  "function totalSupply() view returns (uint256)",
  "function logo() view returns (string)",
  "function description() view returns (string)",
  "function liquidityPool() view returns (address)",
]);

Launch-level parameters live on the factory that deployed the token. isToken0 is required for pricing and trade direction, and pairedToken tells you which asset the pool is quoted in.

Price comes from the pool's slot0. Square the sqrtPriceX96 ratio, invert it when the token is not token0, then scale for the decimals of both sides.

Do not skip the decimal scaling. The launch token uses 18 decimals, but a tokenised equity pair uses 8 and USDC uses 6. Assuming 18 on both sides puts the price off by ten orders of magnitude.

const [sqrtPriceX96] = await client.readContract({
  address: pool,
  abi: [parseAbiItem("function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)")],
  functionName: "slot0",
});

const ratio = Number(sqrtPriceX96) / 2 ** 96;
const token1PerToken0 = ratio * ratio;
const raw = isToken0 ? token1PerToken0 : 1 / token1PerToken0;

// Scale for both sides. Never assume 18 decimals on the pair.
const pricePaired = raw * 10 ** (tokenDecimals - pairDecimals);

Graduation is a single call. Progress is the paired principal over the threshold, and trading continues in the same pool after it graduates.

const [pairedPrincipal, threshold, graduated] = await client.readContract({
  address: "0xccfe8333587536AA6B45232B179d144ba69cf7b3",
  abi: [parseAbiItem("function graduationStatus(address token) view returns (uint256 pairedPrincipal, uint256 threshold, bool graduated)")],
  functionName: "graduationStatus",
  args: [token],
});

const progress = Number(pairedPrincipal) / Number(threshold); // 0 through 1

To show the creator and protocol split for a token, read the snapshotted share and payout wallet from the locker rather than hardcoding a percentage.

We offer hands-on support for teams integrating BaseStocks. If you are indexing launches, deriving prices, wiring trades, or verifying onchain state, the team can help you get it right.

Reach us at contact@basestocks.fi for integration questions, technical support, and partnership requests.

Onchain data is public and free to read. You are responsible for how you use it. BaseStocks is provided as is, without warranties, and the team is not liable for losses arising from integrations, interfaces, RPCs, or indexers.

• Do not present third-party services as operated by BaseStocks.
• Do not use the BaseStocks name or marks in a way that misleads users.
• Availability of interfaces and public infrastructure is not guaranteed.