Launching programmatically

Create coins from your own product through FlaunchZap, the same one-transaction entry point the app uses.

If your product launches coins on behalf of users (a bot, a terminal, another launchpad frontend), call the same contract our app calls: FlaunchZap. One transaction creates the token, its Uniswap v4 pool, locked liquidity, the fair launch, and the creator’s revenue stream. Launches at the minimum $10,000 initial market cap are currently fee-free; larger market caps can owe a flaunch fee as msg.value.

The call

function flaunch(
  FlaunchParams calldata _flaunchParams,
  address _trustedFeeSigner,
  bytes calldata _premineSwapHookData,
  WhitelistParams calldata _whitelistParams,
  AirdropParams calldata _airdropParams,
  TreasuryManagerParams calldata _treasuryManagerParams
) payable returns (address memecoin_, uint256 ethSpent_, address deployedManager_);

with

struct FlaunchParams {
  string  name;
  string  symbol;
  string  tokenUri;                // token metadata (name, description, image); see below
  uint256 initialTokenFairLaunch;  // supply sold in the fair launch phase
  uint256 fairLaunchDuration;      // seconds
  uint256 premineAmount;           // must be 0 on Arc (premine is not supported); buy after the launch instead
  address creator;                 // receives the Flaunch NFT and the creator revenue
  uint24  creatorFeeAllocation;    // creator vs floor-bid split of the creator share, in hundredths of a percent (9000 = 90/10)
  uint256 flaunchAt;               // 0 for now, or a future start timestamp
  bytes   initialPriceParams;      // pricing config consumed by UsdcMarketCappedPrice
  bytes   feeCalculatorParams;
}

struct WhitelistParams {
  bytes32 merkleRoot;              // zero for an open launch
  string  merkleIPFSHash;
  uint256 maxTokens;
}

struct AirdropParams {                 // zero values for no launch airdrop
  uint256 airdropIndex;
  uint256 airdropAmount;
  uint256 airdropEndTime;
  bytes32 merkleRoot;
  string  merkleIPFSHash;
}

struct TreasuryManagerParams {         // the creator vault, required since block 24248448, see below
  address manager;
  address permissions;
  bytes   initializeData;
  bytes   depositData;
}

Premine is not supported on Arc: always pass premineAmount 0 (the zap’s premine path wraps the native token in a way Arc’s USDC does not support, so a premine launch reverts) and buy after the launch through PoolSwap instead. Compute the transaction value with calculateFee(0, 0, initialPriceParams): it returns the flaunch fee, zero at the $10,000 minimum market cap and owed at or above the on-chain threshold. Sending less reverts with InsufficientFlaunchFee.

Supply is fixed at 100 billion per coin (a v3 coin mints 1 billion); the Flaunch NFT is the revenue claim itself, and the zap deposits it into the coin’s creator vault (below). Simulate before sending (the app does) so a launch that would revert never costs gas, and read the coin address from the simulated memecoin_ return value.

Creator vaults (required since block 24248448)

Since creator vaults went live (October 4, 2026, 16 UTC, Arc block 24248448), every launch must attach a creator vault; a coin launched without one cannot trade (the fee calculator checks the vault on every swap). Pass:

• TreasuryManagerParams.manager: the DividendVault implementation 0xA9E566b548D5D0203e4d00bc3dFdB4BC38883514. The zap clones it, initializes the clone and deposits the creator’s Flaunch NFT into it in the same transaction.
• TreasuryManagerParams.initializeData: abi.encode(uint256 holderShare, address[] recipients, uint256[] shares). holderShare is the holders’ part of the creator side in hundredths of a percent, 1667 to 10000. Up to 5 distinct recipients (the app uses the creator plus up to 4 others) with shares that sum to exactly 10000; they divide what remains after holders. permissions and depositData stay empty.
• FlaunchParams.feeCalculatorParams: abi.encode(uint256 feeBps), 150 to 500 (1.5% to 5%); out of range reverts the launch, and empty bytes mean 1.5%.
• creatorFeeAllocation of 9000 or more (the auto buyback takes at most 10% of the creator stream).

The SDK (0.2.0 and later) builds all of this for you with flaunchWithVault / flaunchIPFSWithVault, and refuses a plain launch while vaults are live. Background: Creator vaults and holder dividends.

Token images and metadata

tokenUri should resolve to standard token metadata JSON. Our API exposes the same upload path the app uses: POST https://api.ubi.fun/upload takes a multipart image file plus the metadata text fields (including optional website, twitter, telegram, discord links, which surface on the market APIs), pins both, and returns { tokenUri, image } as ipfs:// URIs; pass that tokenUri straight into FlaunchParams. IP rate limited. You are equally welcome to host metadata yourself on IPFS.

After the launch

Watch for your PoolCreated event to get the coin address, pool id, and treasury (see Contracts and events); the coin is tradeable immediately at the fair launch price. The REST data API picks it up within seconds.

For the parts of launching that are product decisions rather than contract mechanics (fair launch sizing, anti-sniper behavior, revenue splits, X handle claims), the creator docs cover them: Launch a token, Anti-sniper protection, Revenue splits.