Everything about tether, in one place.

tether is a place to launch and trade tokens on Stable Testnet. You can browse launches, inspect any token's details, and trade straight from your wallet.

tether is non-custodial and 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. The pool's liquidity is locked automatically.

Every token trades directly against USDT0 in one pool. There is no bonding curve and no later migration. Buys and sells happen in that same pool from the moment the token launches.

1. 01

   Create

   One billion tokens are minted and the USDT0 pool goes live in the same transaction.

2. 02

   Trade

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

3. 03

   Graduate

   The launch graduates once 4.2 USDT0 of paired principal is reached, and trading continues in the same pool.

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

Every token trades against USDT0 in its own liquidity pool. The price shown is the live pool price, and it moves with every trade. The amount you receive can differ from the quote; slippage sets how much movement your transaction accepts.

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 in its locked pool reaches 4.2 USDT0.

Graduation only confirms that 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 USDT0. The creator receives 70% and the protocol receives 30%. This split is snapshotted when the token launches and cannot change afterward.

Current launches

Creator 70% · protocol 30%

Immutable per launch

Split is snapshotted at creation

Creator fees accrue in the token's locked position and can be claimed through the tether interface.

The protocol uses its fee share to buy the platform token TETHER, then sends that TETHER to an explicit burn/sink contract. USDT0 itself is not burned.

An automated TWAP uses 80% of protocol fees for TETHER buybacks. The remaining 20% supports protocol operations.

Buyback

80% of protocol fees, executed as an automated TWAP

Operations

20% of protocol fees for infrastructure and operations

When a token's original creator steps away, its community can request a community takeover, or CTO. A CTO is an administrative transfer of the token's social presence and, where the contracts allow it, the creator fee payout.

The token, its pool, and its locked liquidity are unaffected. A CTO is not an endorsement or a statement about a token's safety, quality, or value.

Tokens launched through tether 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.

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

This build targets Stable Testnet. Tokens pair directly with the six-decimal USDT0 test token, while transaction gas is paid with the network's native USDT0 balance. No WETH-style wrapping step is required.

Network

Stable Testnet

Chain ID

2201

Native gas asset

USDT0 (18 decimals)

Public RPC

https://rpc.testnet.stable.xyz

Explorer

testnet.stablescan.xyz

Block time

~0.7 seconds

Pool fee

10000 (1%)

Launch fee

0.0005 USDT0

Supply

1,000,000,000 (1e9)

USDT0 quote token

0x78Cf24370174180738C5B8E352B6D14c83a6c9A9

The 0.0005 launch fee and 4.2 graduation threshold are literal numeric ports from WETH to USDT0 and require an economics review before deployment. Stable-specific balance and allowance semantics must also be audited, and USDT0 should not be sent to the zero address.

The launch contracts are implemented and pass the Stable Testnet fork suite, but they are not audited or publicly deployed. Public addresses will appear here only after deployment and verification on Stablescan.

Index the launcher's TokenLaunchedevent, register each emitted pool, then index the pool's Swap events. There is no migration event because launches continue trading in the same pool.

import { createPublicClient, http, parseAbiItem } from "viem";

const client = createPublicClient({
  chain: {
    id: 2201,
    name: "Stable Testnet",
    nativeCurrency: { name: "USDT0", symbol: "USDT0", decimals: 18 },
    rpcUrls: { default: { http: ["https://rpc.testnet.stable.xyz"] } },
  },
  transport: http(),
});

const factory = process.env.NEXT_PUBLIC_FACTORY_ADDRESS;
if (!factory) throw new Error("Factory is not deployed");

const launches = await client.getLogs({
  address: factory,
  event: parseAbiItem(
    "event TokenLaunched(address indexed token, address indexed deployer, address indexed dexFactory, address pairToken, address pool, uint256 dexId, uint256 launchConfigId, uint256 positionId, uint256 restrictionsEndBlock, uint256 initialBuyAmount)"
  ),
  fromBlock: "earliest",
  toBlock: "latest",
});

Use token ordering and signed pool amounts to derive buy and sell direction. Backfill logs in bounded block ranges from the launcher's published start block.

Each launch token is self-describing. Read metadata and the canonical pool from the token, then read immutable launch parameters from the factory that created it.

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)",
  "function socials() view returns (string twitter, string telegram, string discord, string website, string farcaster)",
]);

const [name, symbol, decimals, pool] = await Promise.all([
  client.readContract({ address: token, abi: tokenAbi, functionName: "name" }),
  client.readContract({ address: token, abi: tokenAbi, functionName: "symbol" }),
  client.readContract({ address: token, abi: tokenAbi, functionName: "decimals" }),
  client.readContract({ address: token, abi: tokenAbi, functionName: "liquidityPool" }),
]);

Derive price from the pool's slot0. Because USDT0 is the quote asset, the pool ratio is already dollar-denominated. Graduation is the paired principal divided by the 4.2 USDT0 threshold.

const [sqrtPriceX96] = await client.readContract({
  address: pool,
  abi: poolAbi,
  functionName: "slot0",
});

const ratio = Number(sqrtPriceX96) / 2 ** 96;
const token1PerToken0 = ratio * ratio;
const priceInUsdt0 = isToken0 ? token1PerToken0 : 1 / token1PerToken0;
const supplyTokens = Number(supply) / 1e18;
const marketCapUsd = priceInUsdt0 * supplyTokens;

// USDT0 is the quote asset, so no ETH/USD oracle conversion is required.
const [pairedPrincipal, threshold, graduated] = await client.readContract({
  address: factory,
  abi: factoryAbi,
  functionName: "graduationStatus",
  args: [token],
});
const progress = Number(pairedPrincipal) / Number(threshold);

This build is a product and mechanism prototype. Integration support, production contacts, and audited deployment artifacts have not been configured.

Onchain data is public and free to read. This prototype is provided as is, without warranties, and does not imply affiliation with Pons, Stable, Tether, or any deployed protocol.

• Do not present this prototype as an audited or live service.
• Do not imply a partnership, endorsement, or official status.
• Interfaces, RPCs, indexers, and future deployments may fail.