CanonicalHook

A trading tax hook. It takes a cut of every trade, charges more right after launch and keeps rewards to claim.

• Takes a cut of every trade

  On top of the normal pool fee, it keeps a share of each trade.

  The code that does this (beforeSwap):

  function _beforeSwap(address sender, PoolKey calldata key, SwapParams calldata params, bytes calldata)
      internal
      override
      returns (bytes4, BeforeSwapDelta, uint24)
  {
      if (!params.zeroForOne || params.amountSpecified >= 0) {
          return (BaseHook.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, 0);
      }
  
      int256 amountIn = -params.amountSpecified; // positive (exact-in)
      // Out of the pool's encodable range: pass through, the pool reverts downstream.
      if (uint256(amountIn) > type(uint128).max) {
          return (BaseHook.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, 0);
      }
  
      PoolId id = key.toId();
      uint128 ethIn = uint128(uint256(amountIn));
      uint24 feeBps = currentFeeBps(id);
      uint128 fee = _ceilMulBps(ethIn, feeBps);
  
      // Keep at least 1 wei of input for the pool (prevents amountToSwap == 0 on
      // 1-wei swaps, which the PoolManager rejects with SwapAmountCannotBeZero).
      if (fee >= ethIn) {
          fee = ethIn - 1;
      }
  
      if (fee > 0) {
          // Take the fee out of the specified native ETH input, in raw native ETH.
          poolManager.take(CurrencyLibrary.ADDRESS_ZERO, treasury, fee);
          emit FeeTaken(key.toId(), sender, true, fee, feeBps);
      // …

• Higher at launch

  The fee starts higher right after launch and comes down over time, which makes it costly for bots to buy first.

  The code that does this (currentFeeBps):

  function currentFeeBps(PoolId id) public view returns (uint24) {
      uint256 launch = poolLaunchTime[id];
      if (launch == 0 || block.timestamp < launch + RAMP_DURATION) {
          return PHASE1_FEE_BPS;
      }
      uint256 elapsedSinceRamp = block.timestamp - (launch + RAMP_DURATION);
      if (elapsedSinceRamp >= LINEAR_RAMP_DURATION) {
          return PHASE2_FEE_BPS;
      }
      return uint24(
          uint256(PHASE1_FEE_BPS) +
              ((uint256(PHASE2_FEE_BPS - PHASE1_FEE_BPS) * elapsedSinceRamp) / LINEAR_RAMP_DURATION)
      );
  }

• Rewards to claim

  It keeps track of what people have earned, and they claim it themselves.

  The code that does this (claimJackpot):

  function claimJackpot() public {
      uint256 amount = pendingJackpot[msg.sender];
      if (amount == 0) revert NothingToClaim();
      pendingJackpot[msg.sender] = 0;
      emit JackpotClaimed(msg.sender, amount);
      (bool ok, ) = msg.sender.call{value: amount}("");
      if (!ok) revert EthTransferFailed();
  }

• Only approved callers create pools

  New pools with this hook can only be created by approved callers, for example its own factory or launcher.

  The code that does this (beforeInitialize):

  function _beforeInitialize(address, PoolKey calldata key, uint160)
      internal
      override
      returns (bytes4)
  {
      if (!key.currency0.isAddressZero()) revert NativeETHRequired();
  
      PoolId id = key.toId();
      if (poolLaunchTime[id] == 0) {
          uint256 timestamp = block.timestamp;
          poolLaunchTime[id] = timestamp;
          emit PoolInitialized(id, timestamp);
      }
  
      return BaseHook.beforeInitialize.selector;
  }

• Simple trades only

  Trades must state the amount going in, not the amount coming out.

  The code that does this (afterSwap):

  function _afterSwap(
      address sender,
      PoolKey calldata key,
      SwapParams calldata params,
      BalanceDelta delta,
      bytes calldata hookData
  ) internal override returns (bytes4, int128) {
      PoolId id = key.toId();
      _settleExpiredKing(id);
  
      if (params.zeroForOne || params.amountSpecified == 0) {
          if (params.zeroForOne && delta.amount0() < 0 && sender != flashArb) {
              uint256 ethSpent = uint256(int256(-delta.amount0()));
              if (ethSpent >= MIN_KING_BUY_WEI) {
                  address buyer = _resolveBuyer(hookData);
                  qualifiedBuyEth[id][buyer] += ethSpent;
                  lastKing[id] = buyer;
                  uint256 deadline = block.timestamp + KING_TIMER_DURATION;
                  kingDeadline[id] = deadline;
                  emit NewKing(id, buyer, ethSpent, deadline, jackpotPot[id]);
              }
          }
          return (BaseHook.afterSwap.selector, 0);
      }
      if (sender == flashArb && sender != address(0)) {
          return (BaseHook.afterSwap.selector, 0);
      }
      if (params.amountSpecified > 0) {
          revert ExactOutputNotAllowed();
      }
      // …

Who controls it: Nobody. The hook has no admin functions, and the code cannot be changed.

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