EtherealFactory

Ethereal is a one-contract token launchpad: the same contract creates the token, puts in its liquidity and acts as its hook. Every trade pays a fee in ETH, shared between the token creator and the platform.

• Launch in one step

  One call creates the token, sets up its pool with the launch liquidity and, if the token creator wants, makes their first buy, all at once.

  The code that does this (launch):

  function launch(LaunchParams calldata p) external payable returns (address token) {
      if (
          p.startTick <= 0 || p.startTick % TICK_SPACING != 0 || p.startTick > TickMath.maxUsableTick(TICK_SPACING)
              || p.feeBps > MAX_FEE_BPS || bytes(p.name).length == 0 || bytes(p.symbol).length == 0
              || msg.value < launchFee
      ) revert BadParams();
      uint256 devBuy = msg.value - launchFee;
      if (devBuy != 0 && p.buyRecipient == address(0)) revert BadParams();
  
      token = _deployToken(p);
      if (uint160(token) & VANITY_MASK != VANITY) revert BadVanity();
      allTokens.push(token);
  
      PoolKey memory key = _key(token);
      uint256 positionId = _seed(token, key, p.startTick);
  
      launches[token] = LaunchInfo({
          feeRecipient: msg.sender,
          feeBps: p.feeBps,
          startTick: p.startTick,
          openedAt: uint32(block.timestamp),
          migrateTick: _migrateTick(p.startTick),
          creator: msg.sender,
          positionId: positionId
      });
  
      uint256 bought;
      if (msg.value != 0) bought = _launchPayments(token, key, devBuy, p.feeBps, p.buyRecipient);
      if (bought < p.minTokensOut) revert TooLittleReceived();
      if (bought != 0) _checkMigrate(token, key, launches[token]);   // dev buy alone may cross the milestone
      // …

• Fee on every trade in ETH

  Each buy and sell pays a fee from the ETH side. The token creator gets the base fee part, minus the platform’s share, and can claim it whenever they like.

  The code that does this (_distribute):

  function _distribute(address token, address recipient, bool isBuy, uint256 gross, uint256 fee, uint256 basePart) private {
      if (basePart > fee) basePart = fee;
      uint256 toCreator = basePart - basePart * platformShareBps / BPS;
      uint256 toPlatform = fee - toCreator;
      if (toCreator != 0) pendingFees[recipient] += toCreator;
      if (toPlatform != 0) pendingFees[platformWallet] += toPlatform;
      emit Fee(token, isBuy, gross, fee, toCreator, toPlatform);
  }

• Higher fee right after launch

  For a short time after launch the fee is much higher, to make sniping by bots expensive. Then it drops to the token’s normal rate.

  The code that does this (_rate):

  function _rate(uint256 baseBps, uint32 openedAt) private view returns (uint256) {
      uint256 elapsed = block.timestamp - openedAt;
      if (elapsed >= SNIPE_DURATION || SNIPE_START_BPS <= baseBps) return baseBps;
      return SNIPE_START_BPS;
  }

• Milestone tracking

  The hook notes when a token’s price passes its launch range and records its market value at that point.

  The code that does this (_checkMigrate):

  function _checkMigrate(address token, PoolKey memory key, LaunchInfo storage l) private {
      int24 mt = l.migrateTick;
      if (mt == MIGRATED) return;
      PoolId id = key.toId();
      (uint160 sqrtC, int24 tick,,) = poolManager.getSlot0(id);
      if (tick > mt) return;
      l.migrateTick = MIGRATED;
      uint160 sqrtU = TickMath.getSqrtPriceAtTick(l.startTick);
      uint256 ethInLp = sqrtC < sqrtU ? SqrtPriceMath.getAmount0Delta(sqrtC, sqrtU, _launchLiquidity(l.startTick), false) : 0;
      uint256 mc = FullMath.mulDiv(FullMath.mulDiv(TOTAL_SUPPLY, 1 << 96, sqrtC), 1 << 96, sqrtC);   // ETH per token * supply
      emit Migrate(token, id, ethInLp, mc, tick);
  }

Who controls it: Each token’s base fee is set at launch. The token creator can change where their share is paid. The code itself can’t be changed.

Based on the hook’s published code.What do these labels mean?