HappiUniswapV4Hook

The hook for Happi meme coin launches. It takes a fee (and the token’s tax, if set) from every trade, turns any part paid in the meme coin into the main currency, and splits it between the platform, the token creator and a market-making vault.

• Fee and tax on every trade

  Each trade pays the hook’s fee plus, if the token has one, its tax. It’s taken from whichever side comes out of the trade.

  The code that does this (_computeAndTakeFee):

  function _computeAndTakeFee(bytes32 poolId, address feeCurrency, uint256 unspecified)
      internal
      returns (uint256 totalAmount)
  {
      LaunchInfo memory info = launches[poolId];
      if (!info.registered) return 0;
      if (info.hookFeeBps == 0 && info.creatorTaxBps == 0) return 0;
      if (unspecified == 0) return 0;
  
      uint256 feeAmount = (unspecified * info.hookFeeBps) / BASIS_POINTS;
      uint256 taxAmount = (unspecified * info.creatorTaxBps) / BASIS_POINTS;
      totalAmount = feeAmount + taxAmount;
      if (totalAmount == 0) return 0;
  
      _takeFromManager(feeCurrency, totalAmount);
      if (feeAmount != 0) pendingFees[poolId][feeCurrency] += feeAmount;
      if (taxAmount != 0) pendingCreatorTax[poolId][feeCurrency] += taxAmount;
  
      emit HookFeeCollected(poolId, feeCurrency, feeAmount, taxAmount);
  }

• Converted to the main currency

  Fees collected in the meme coin are sold inside the pool for the main currency (like ETH), with a limit on how much that can move the price.

  The code that does this (_convertPendingMemecoin):

  function _convertPendingMemecoin(bytes32 poolId, LaunchInfo memory info, uint256 minConversionQuoteOut)
      private
      returns (uint256 feeQuoteOut, uint256 taxQuoteOut, bool converted)
  {
      uint256 feePending = pendingFees[poolId][info.memecoin];
      uint256 taxPending = pendingCreatorTax[poolId][info.memecoin];
      uint256 totalPending = feePending + taxPending;
      if (totalPending == 0) return (0, 0, false);
      if (minConversionQuoteOut == 0) revert MinimumOutputRequired();
  
      pendingFees[poolId][info.memecoin] = 0;
      pendingCreatorTax[poolId][info.memecoin] = 0;
      (uint256 consumed, uint256 quoteOut) = _executeInternalSwap(poolId, totalPending);
      if (consumed == 0) {
          pendingFees[poolId][info.memecoin] += feePending;
          pendingCreatorTax[poolId][info.memecoin] += taxPending;
          emit PoolConversionSkipped(poolId, totalPending);
          return (0, 0, false);
      }
      converted = true;
  
      uint256 feeConsumed = FullMath.mulDiv(consumed, feePending, totalPending);
      uint256 taxConsumed = consumed - feeConsumed;
      feeQuoteOut = FullMath.mulDiv(quoteOut, feeConsumed, consumed);
      taxQuoteOut = quoteOut - feeQuoteOut;
  
      pendingFees[poolId][info.memecoin] += feePending - feeConsumed;
      pendingCreatorTax[poolId][info.memecoin] += taxPending - taxConsumed;
  }

• Split three ways

  The money is shared between the platform, the token creator and, where set up, a market-making vault that supports trading in the token.

  The code that does this (_distribute):

  function _distribute(bytes32 poolId, LaunchInfo memory info, uint256 totalQuote, uint256 taxQuote) private {
      uint256 protocolAmount = (totalQuote * info.protocolFeeShareBps) / BASIS_POINTS;
      uint256 mmAmount = info.mmVault == address(0) ? 0 : (totalQuote * info.mmFeeShareBps) / BASIS_POINTS;
      // The MM cut and protocol cut are bounded below BASIS_POINTS together
      // at registration, so this never underflows. The creator tax still
      // bypasses the split and is paid in full.
      uint256 creatorAmount = totalQuote - protocolAmount - mmAmount + taxQuote;
  
      _payOut(info.creator, info.quoteToken, creatorAmount);
      _payOut(info.protocolFeeRecipient, info.quoteToken, protocolAmount);
      // The vault needs liquid funds to trade, so route its share directly to
      // it rather than crediting the claim-based escrow.
      if (mmAmount != 0) _payToVault(info.mmVault, info.quoteToken, mmAmount);
  
      emit PoolFeesSwept(poolId, protocolAmount, creatorAmount);
      if (mmAmount != 0) emit PoolMMFeeRouted(poolId, info.mmVault, mmAmount);
  }

Who controls it: The hook developer (Happi) can change the hook fee, the platform’s share and wallet, and the price-impact limit, and can’t give up ownership. The launch factory can change a token creator’s payout wallet. The code itself can’t be changed.

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