0x9cee…e8c4

Vorta runs pools for its VORTA token and for pre-IPO markets, where traders get price exposure to private companies. This hook controls when each pool opens, charges a launch fee that drops over time, sends a cut of every trade to Vorta, and keeps a daily price record used to settle markets.

• Trading opens on Vorta's schedule

  A pool only works once Vorta has enrolled it and switched trading on, at a set launch time. Vorta can pause a pool, and trading stops for good once its linked market has settled.

  The code that does this (_beforeSwap):

  function _beforeSwap(address sender, PoolKey calldata key, SwapParams calldata, bytes calldata hookData)
      internal
      view
      override
      returns (bytes4, BeforeSwapDelta, uint24)
  {
      PoolId poolId = key.toId();
      Gate storage gate = _gates[poolId];
      FeeSchedule storage schedule = _schedules[poolId];
      if (!_launched(gate)) revert TradingNotOpen();
      if (!_marketOpen(gate)) revert MarketClosed();
  
      if (schedule.earlyAccessSeconds != 0 && block.timestamp < uint256(gate.launchTime) + schedule.earlyAccessSeconds) {
          _requireAllowlisted(sender, schedule.allowlistRoot, hookData);
      }
  
      uint24 fee = _feeNow(gate, schedule) | LPFeeLibrary.OVERRIDE_FEE_FLAG;
      return (IHooks.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, fee);
  }

• High launch fee that fades

  Right after launch the trading fee can start high and slide down to a normal fee over a set time. This makes it costly for bots to grab tokens in the first moments.

  The code that does this (_feeNow):

  function _feeNow(Gate storage gate, FeeSchedule storage s) internal view returns (uint24) {
      if (s.launchFee <= s.baseFee || !gate.tradingEnabled) return s.baseFee;
      uint256 elapsed = block.timestamp > gate.launchTime ? block.timestamp - gate.launchTime : 0;
      if (elapsed >= s.decaySeconds) return s.baseFee;
      uint256 remaining = s.decaySeconds - elapsed;
      return uint24(s.baseFee + uint256(s.launchFee - s.baseFee) * remaining / s.decaySeconds);
  }

• Early access for an allowlist

  Pools can have a short early window where only addresses on an approved list can trade, and only through routers Vorta trusts. Before launch, only approved addresses can add liquidity.

  The code that does this (_requireAllowlisted):

  function _requireAllowlisted(address sender, bytes32 root, bytes calldata hookData) internal view {
      if (!isTrustedRouter[sender]) revert UntrustedRouter();
      address user = IMsgSender(sender).msgSender();
      bytes32[] memory proof = hookData.length == 0 ? new bytes32[](0) : abi.decode(hookData, (bytes32[]));
      bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(user))));
      if (!MerkleProof.verify(proof, root, leaf)) revert NotAllowlisted();
  }

• Cut for Vorta and a price record

  After each trade the hook takes a small fee (up to 10%) and sends it to Vorta's fee address. It also saves a daily price checkpoint, so markets can settle on an average price instead of one moment's price.

  The code that does this (_afterSwap):

  function _afterSwap(address, PoolKey calldata key, SwapParams calldata params, BalanceDelta delta, bytes calldata)
      internal
      override
      returns (bytes4, int128)
  {
      PoolId poolId = key.toId();
      uint256 feeAmount = _takeHookFee(poolId, key, params, delta);
      _touchOracle(poolId);
      return (IHooks.afterSwap.selector, feeAmount.toInt128());
  }

Who controls it: The hook developer (Vorta) and the helpers it approves can enroll pools, change their fee settings within fixed limits, open trading and let addresses add liquidity early. Only Vorta can pause a pool, pick trusted routers, approve helpers and change where fees go. The code cannot be upgraded.

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