Launch it. Lock it. Let it Stank.

Trade the token. Stake when you want rewards.

Rewards are paid in the paired asset. Unstaking returns principal; claiming only withdraws earned rewards.

How staking to earn rewards works.

When a token launches with a holder share (its holderRewardBps is above zero), part of every trade's 1% fee is set aside for the people who hold and stake it — paid in the token's paired asset (e.g. TSLAB, WBNB, or a stablecoin), never in the launch token itself. Each launch gets its own HolderRewardsDistributor; holders stake there directly from the token page.

A token launched with holderRewardBps = 0 shares nothing with holders, so there is nothing to stake for — the token page says so plainly.

Your launch, your split, a market that stays open.

Creator and holder basis points must add up to 8,000. A common split is 3,000 creator / 5,000 holders. The reward recipient can be a separate creator wallet, but the holder distributor is wired automatically.

One-sided liquidity, permanently held.

• The launched token is minted once; there is no owner mint path.
• The pool position cannot be transferred, approved, or decreased.
• Fees are collected separately from principal. The lock stays in place while rewards are paid.
• There is no graduation threshold, migration event, or second “official” pool.

Build on the same primitives Stank uses.

Builders can index launches from events, resolve a launch with getLaunch(token), quote swaps through the configured V3 router, and link users to the token page with the token address. Treat the factory events as the source of truth rather than scraping UI cards.

interface IStankLaunchFactory {
  struct LaunchParams {
    string name;
    string symbol;
    uint256 totalSupply;
    address pairedAsset;
    uint256 initialMarketCapPaired;
    uint16 creatorRewardBps;
    uint16 holderRewardBps;
    address rewardRecipient;
    uint256 initialBuyAmount;
    address buyRecipient;
    string metadataURI;
    bytes32 userSalt;
  }

  struct Launch {
    address token;
    address pairedAsset;
    address creator;
    address rewardRecipient;
    address pool;
    address permanentLocker;
    address rewardVault;
    address holderRewardsDistributor;
    uint256 positionId;
    uint256 totalSupply;
    uint256 launchTokenLiquidityAmount;
    uint256 permanentlyLockedDust;
    int24 tickLower;
    int24 tickUpper;
    uint16 creatorRewardBps;
    uint16 holderRewardBps;
    uint64 launchedAt;
  }

  function launch(LaunchParams calldata params)
    external payable returns (Launch memory created);

  function predictNextTokenAddress(
    address creator, bytes32 userSalt, string calldata name,
    string calldata symbol, uint256 totalSupply
  ) external view returns (address);

  function getLaunch(address token)
    external view returns (Launch memory);
}

const tx = await factory.launch({
  name: "Example Token",
  symbol: "EXAMPLE",
  totalSupply: ethers.parseUnits("1000000000", 18),
  pairedAsset: pairAddress,
  initialMarketCapPaired: openingMarketCap,
  creatorRewardBps: 3000, // 30% of total fees
  holderRewardBps: 5000,  // 50% of total fees
  rewardRecipient: creator,
  initialBuyAmount: 0,
  buyRecipient: creator,
  metadataURI: "ipfs://...",
  userSalt: ethers.keccak256(ethers.toUtf8Bytes("my-launch")),
});

const receipt = await tx.wait();
// Index LaunchCreated and LaunchEconomicsConfigured.
// Route users to /token?address=<created.token>.

Read the source. Verify every address.

These are the contracts a builder may integrate with. The source links below are the exact files bundled with the app; always compare deployed bytecode and constructor arguments on BscScan before sending a transaction.

What protocol operators can change.

The public Admin page is an operations console, not a replacement for multisig controls. Confirm the connected wallet and chain before signing.