// SPDX-License-Identifier: MIT pragma solidity ^0.8.26; import {PoolId} from "@uniswap/v4-core/src/types/PoolId.sol"; /// @notice Minimal post-bond fee helper interface used by Robinhood launchers. interface IArenaFeeHelperMinimal { struct Fee { address recipient; uint16 feePpm; } function getFeesForPool(PoolId poolId) external view returns (Fee[] memory feeRecipients); function getTotalFeePpm(PoolId poolId) external view returns (uint256); function initializeFeesForPool(PoolId poolId, Fee[] calldata fees) external; }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol"; import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol"; import {Currency} from "@uniswap/v4-core/src/types/Currency.sol"; import {Actions} from "@uniswap/v4-periphery/src/libraries/Actions.sol"; import { IRobinhoodHelperPermit2, IRobinhoodHelperUniversalRouter } from "./RobinhoodHelperInterfaces.sol"; /// @notice Shared Universal Router plumbing for the Robinhood helper suite. /// @dev The extra minHopPriceX36 field matches Robinhood's deployed Universal /// Router encoding, which is also exercised by CreationFeeBuybackAdapter. abstract contract RobinhoodV4SwapExecutor { using SafeERC20 for IERC20; bytes1 internal constant V4_SWAP_COMMAND = 0x10; /// @dev Robinhood's deployed Universal Router extends the upstream v4 /// ExactInputSingleParams with a per-hop price guard. Because hookData is /// dynamic, the router expects this struct to be ABI-encoded as one tuple, /// including its leading offset word. struct RobinhoodExactInputSingleParams { PoolKey poolKey; bool zeroForOne; uint128 amountIn; uint128 amountOutMinimum; uint256 minHopPriceX36; bytes hookData; } struct RobinhoodExactOutputSingleParams { PoolKey poolKey; bool zeroForOne; uint128 amountOut; uint128 amountInMaximum; uint256 minHopPriceX36; bytes hookData; } IRobinhoodHelperUniversalRouter public immutable UNIVERSAL_ROUTER; IRobinhoodHelperPermit2 public immutable PERMIT2; IPoolManager public immutable POOL_MANAGER; error InvalidSwapDependency(); error InvalidSwapAmount(); error InvalidMinimumOutput(); error InvalidPoolKey(); error SwapOutputTooLow(uint256 minimum, uint256 actual); error SwapInputTooHigh(uint256 maximum, uint256 actual); constructor( IRobinhoodHelperUniversalRouter universalRouter_, IRobinhoodHelperPermit2 permit2_ ) { if ( address(universalRouter_) == address(0) || address(universalRouter_).code.length == 0 || address(permit2_) == address(0) || address(permit2_).code.length == 0 ) revert InvalidSwapDependency(); address poolManager = universalRouter_.poolManager(); if (poolManager == address(0)) revert InvalidSwapDependency(); UNIVERSAL_ROUTER = universalRouter_; PERMIT2 = permit2_; POOL_MANAGER = IPoolManager(poolManager); } function _swapExactInputSingle( PoolKey memory key, bool zeroForOne, uint256 amountIn, uint256 minAmountOut, uint256 deadline ) internal returns (uint256 amountOut) { return _swapExactInputSingle( key, zeroForOne, amountIn, minAmountOut, 0, bytes(""), deadline ); } function _swapExactInputSingle( PoolKey memory key, bool zeroForOne, uint256 amountIn, uint256 minAmountOut, uint256 minHopPriceX36, bytes memory hookData, uint256 deadline ) internal returns (uint256 amountOut) { if (amountIn == 0 || amountIn > type(uint128).max) revert InvalidSwapAmount(); if (minAmountOut == 0 || minAmountOut > type(uint128).max) { revert InvalidMinimumOutput(); } address currency0 = Currency.unwrap(key.currency0); address currency1 = Currency.unwrap(key.currency1); if (currency0 == currency1) revert InvalidPoolKey(); address input = zeroForOne ? currency0 : currency1; address output = zeroForOne ? currency1 : currency0; uint256 outputBefore = _currencyBalance(output); if (input != address(0)) _ensureRouterApproval(input, amountIn); bytes[] memory actionParams = new bytes[](4); actionParams[0] = abi.encode( RobinhoodExactInputSingleParams({ poolKey: key, zeroForOne: zeroForOne, amountIn: uint128(amountIn), amountOutMinimum: uint128(minAmountOut), minHopPriceX36: minHopPriceX36, hookData: hookData }) ); actionParams[1] = abi.encode(input, amountIn, true); actionParams[2] = abi.encode(output, minAmountOut); actionParams[3] = abi.encode(input, uint256(0)); bytes memory actions = abi.encodePacked( uint8(Actions.SWAP_EXACT_IN_SINGLE), uint8(Actions.SETTLE), uint8(Actions.TAKE_ALL), uint8(Actions.TAKE_ALL) ); bytes[] memory inputs = new bytes[](1); inputs[0] = abi.encode(actions, actionParams); UNIVERSAL_ROUTER.execute{value: input == address(0) ? amountIn : 0}( abi.encodePacked(V4_SWAP_COMMAND), inputs, deadline ); amountOut = _currencyBalance(output) - outputBefore; if (amountOut < minAmountOut) revert SwapOutputTooLow(minAmountOut, amountOut); } function _swapExactOutputSingle( RobinhoodExactOutputSingleParams memory params, uint256 deadline ) internal returns (uint256 amountIn) { uint256 amountOut = params.amountOut; uint256 maxAmountIn = params.amountInMaximum; if (amountOut == 0 || maxAmountIn == 0) revert InvalidSwapAmount(); address currency0 = Currency.unwrap(params.poolKey.currency0); address currency1 = Currency.unwrap(params.poolKey.currency1); if (currency0 == currency1) revert InvalidPoolKey(); address input = params.zeroForOne ? currency0 : currency1; address output = params.zeroForOne ? currency1 : currency0; uint256 inputBefore = _currencyBalance(input); uint256 outputBefore = _currencyBalance(output); if (input != address(0)) _ensureRouterApproval(input, maxAmountIn); bytes[] memory actionParams = new bytes[](4); actionParams[0] = abi.encode(params); actionParams[1] = abi.encode(input, maxAmountIn); actionParams[2] = abi.encode(output, amountOut); actionParams[3] = abi.encode(input, uint256(0)); bytes memory actions = abi.encodePacked( uint8(Actions.SWAP_EXACT_OUT_SINGLE), uint8(Actions.SETTLE_ALL), uint8(Actions.TAKE_ALL), uint8(Actions.TAKE_ALL) ); bytes[] memory inputs = new bytes[](1); inputs[0] = abi.encode(actions, actionParams); UNIVERSAL_ROUTER.execute{value: input == address(0) ? maxAmountIn : 0}( abi.encodePacked(V4_SWAP_COMMAND), inputs, deadline ); uint256 actualOut = _currencyBalance(output) - outputBefore; if (actualOut < amountOut) revert SwapOutputTooLow(amountOut, actualOut); amountIn = inputBefore - _currencyBalance(input); if (amountIn > maxAmountIn) revert SwapInputTooHigh(maxAmountIn, amountIn); } function _ensureRouterApproval(address token, uint256 required) internal { (uint160 allowance,,) = PERMIT2.allowance(address(this), token, address(UNIVERSAL_ROUTER)); if (uint256(allowance) >= required) return; IERC20(token).forceApprove(address(PERMIT2), type(uint256).max); PERMIT2.approve( token, address(UNIVERSAL_ROUTER), type(uint160).max, type(uint48).max ); } function _currencyBalance(address currency) internal view returns (uint256) { return currency == address(0) ? address(this).balance : IERC20(currency).balanceOf(address(this)); } receive() external payable {} }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /// @title Minimal ERC20 interface for Uniswap /// @notice Contains a subset of the full ERC20 interface that is used in Uniswap V3 interface IERC20Minimal { /// @notice Returns an account's balance in the token /// @param account The account for which to look up the number of tokens it has, i.e. its balance /// @return The number of tokens held by the account function balanceOf(address account) external view returns (uint256); /// @notice Transfers the amount of token from the `msg.sender` to the recipient /// @param recipient The account that will receive the amount transferred /// @param amount The number of tokens to send from the sender to the recipient /// @return Returns true for a successful transfer, false for an unsuccessful transfer function transfer(address recipient, uint256 amount) external returns (bool); /// @notice Returns the current allowance given to a spender by an owner /// @param owner The account of the token owner /// @param spender The account of the token spender /// @return The current allowance granted by `owner` to `spender` function allowance(address owner, address spender) external view returns (uint256); /// @notice Sets the allowance of a spender from the `msg.sender` to the value `amount` /// @param spender The account which will be allowed to spend a given amount of the owners tokens /// @param amount The amount of tokens allowed to be used by `spender` /// @return Returns true for a successful approval, false for unsuccessful function approve(address spender, uint256 amount) external returns (bool); /// @notice Transfers `amount` tokens from `sender` to `recipient` up to the allowance given to the `msg.sender` /// @param sender The account from which the transfer will be initiated /// @param recipient The recipient of the transfer /// @param amount The amount of the transfer /// @return Returns true for a successful transfer, false for unsuccessful function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /// @notice Event emitted when tokens are transferred from one address to another, either via `#transfer` or `#transferFrom`. /// @param from The account from which the tokens were sent, i.e. the balance decreased /// @param to The account to which the tokens were sent, i.e. the balance increased /// @param value The amount of tokens that were transferred event Transfer(address indexed from, address indexed to, uint256 value); /// @notice Event emitted when the approval amount for the spender of a given owner's tokens changes. /// @param owner The account that approved spending of its tokens /// @param spender The account for which the spending allowance was modified /// @param value The new allowance from the owner to the spender event Approval(address indexed owner, address indexed spender, uint256 value); }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {PoolKey} from "../types/PoolKey.sol"; import {BalanceDelta} from "../types/BalanceDelta.sol"; import {ModifyLiquidityParams, SwapParams} from "../types/PoolOperation.sol"; import {BeforeSwapDelta} from "../types/BeforeSwapDelta.sol"; /// @notice V4 decides whether to invoke specific hooks by inspecting the least significant bits /// of the address that the hooks contract is deployed to. /// For example, a hooks contract deployed to address: 0x0000000000000000000000000000000000002400 /// has the lowest bits '10 0100 0000 0000' which would cause the 'before initialize' and 'after add liquidity' hooks to be used. /// See the Hooks library for the full spec. /// @dev Should only be callable by the v4 PoolManager. interface IHooks { /// @notice The hook called before the state of a pool is initialized /// @param sender The initial msg.sender for the initialize call /// @param key The key for the pool being initialized /// @param sqrtPriceX96 The sqrt(price) of the pool as a Q64.96 /// @return bytes4 The function selector for the hook function beforeInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96) external returns (bytes4); /// @notice The hook called after the state of a pool is initialized /// @param sender The initial msg.sender for the initialize call /// @param key The key for the pool being initialized /// @param sqrtPriceX96 The sqrt(price) of the pool as a Q64.96 /// @param tick The current tick after the state of a pool is initialized /// @return bytes4 The function selector for the hook function afterInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96, int24 tick) external returns (bytes4); /// @notice The hook called before liquidity is added /// @param sender The initial msg.sender for the add liquidity call /// @param key The key for the pool /// @param params The parameters for adding liquidity /// @param hookData Arbitrary data handed into the PoolManager by the liquidity provider to be passed on to the hook /// @return bytes4 The function selector for the hook function beforeAddLiquidity( address sender, PoolKey calldata key, ModifyLiquidityParams calldata params, bytes calldata hookData ) external returns (bytes4); /// @notice The hook called after liquidity is added /// @param sender The initial msg.sender for the add liquidity call /// @param key The key for the pool /// @param params The parameters for adding liquidity /// @param delta The caller's balance delta after adding liquidity; the sum of principal delta, fees accrued, and hook delta /// @param feesAccrued The fees accrued since the last time fees were collected from this position /// @param hookData Arbitrary data handed into the PoolManager by the liquidity provider to be passed on to the hook /// @return bytes4 The function selector for the hook /// @return BalanceDelta The hook's delta in token0 and token1. Positive: the hook is owed/took currency, negative: the hook owes/sent currency function afterAddLiquidity( address sender, PoolKey calldata key, ModifyLiquidityParams calldata params, BalanceDelta delta, BalanceDelta feesAccrued, bytes calldata hookData ) external returns (bytes4, BalanceDelta); /// @notice The hook called before liquidity is removed /// @param sender The initial msg.sender for the remove liquidity call /// @param key The key for the pool /// @param params The parameters for removing liquidity /// @param hookData Arbitrary data handed into the PoolManager by the liquidity provider to be be passed on to the hook /// @return bytes4 The function selector for the hook function beforeRemoveLiquidity( address sender, PoolKey calldata key, ModifyLiquidityParams calldata params, bytes calldata hookData ) external returns (bytes4); /// @notice The hook called after liquidity is removed /// @param sender The initial msg.sender for the remove liquidity call /// @param key The key for the pool /// @param params The parameters for removing liquidity /// @param delta The caller's balance delta after removing liquidity; the sum of principal delta, fees accrued, and hook delta /// @param feesAccrued The fees accrued since the last time fees were collected from this position /// @param hookData Arbitrary data handed into the PoolManager by the liquidity provider to be be passed on to the hook /// @return bytes4 The function selector for the hook /// @return BalanceDelta The hook's delta in token0 and token1. Positive: the hook is owed/took currency, negative: the hook owes/sent currency function afterRemoveLiquidity( address sender, PoolKey calldata key, ModifyLiquidityParams calldata params, BalanceDelta delta, BalanceDelta feesAccrued, bytes calldata hookData ) external returns (bytes4, BalanceDelta); /// @notice The hook called before a swap /// @param sender The initial msg.sender for the swap call /// @param key The key for the pool /// @param params The parameters for the swap /// @param hookData Arbitrary data handed into the PoolManager by the swapper to be be passed on to the hook /// @return bytes4 The function selector for the hook /// @return BeforeSwapDelta The hook's delta in specified and unspecified currencies. Positive: the hook is owed/took currency, negative: the hook owes/sent currency /// @return uint24 Optionally override the lp fee, only used if three conditions are met: 1. the Pool has a dynamic fee, 2. the value's 2nd highest bit is set (23rd bit, 0x400000), and 3. the value is less than or equal to the maximum fee (1 million) function beforeSwap(address sender, PoolKey calldata key, SwapParams calldata params, bytes calldata hookData) external returns (bytes4, BeforeSwapDelta, uint24); /// @notice The hook called after a swap /// @param sender The initial msg.sender for the swap call /// @param key The key for the pool /// @param params The parameters for the swap /// @param delta The amount owed to the caller (positive) or owed to the pool (negative) /// @param hookData Arbitrary data handed into the PoolManager by the swapper to be be passed on to the hook /// @return bytes4 The function selector for the hook /// @return int128 The hook's delta in unspecified currency. Positive: the hook is owed/took currency, negative: the hook owes/sent currency function afterSwap( address sender, PoolKey calldata key, SwapParams calldata params, BalanceDelta delta, bytes calldata hookData ) external returns (bytes4, int128); /// @notice The hook called before donate /// @param sender The initial msg.sender for the donate call /// @param key The key for the pool /// @param amount0 The amount of token0 being donated /// @param amount1 The amount of token1 being donated /// @param hookData Arbitrary data handed into the PoolManager by the donor to be be passed on to the hook /// @return bytes4 The function selector for the hook function beforeDonate( address sender, PoolKey calldata key, uint256 amount0, uint256 amount1, bytes calldata hookData ) external returns (bytes4); /// @notice The hook called after donate /// @param sender The initial msg.sender for the donate call /// @param key The key for the pool /// @param amount0 The amount of token0 being donated /// @param amount1 The amount of token1 being donated /// @param hookData Arbitrary data handed into the PoolManager by the donor to be be passed on to the hook /// @return bytes4 The function selector for the hook function afterDonate( address sender, PoolKey calldata key, uint256 amount0, uint256 amount1, bytes calldata hookData ) external returns (bytes4); }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /// @notice Interface for functions to access any storage slot in a contract interface IExtsload { /// @notice Called by external contracts to access granular pool state /// @param slot Key of slot to sload /// @return value The value of the slot as bytes32 function extsload(bytes32 slot) external view returns (bytes32 value); /// @notice Called by external contracts to access granular pool state /// @param startSlot Key of slot to start sloading from /// @param nSlots Number of slots to load into return value /// @return values List of loaded values. function extsload(bytes32 startSlot, uint256 nSlots) external view returns (bytes32[] memory values); /// @notice Called by external contracts to access sparse pool state /// @param slots List of slots to SLOAD from. /// @return values List of loaded values. function extsload(bytes32[] calldata slots) external view returns (bytes32[] memory values); }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol) pragma solidity ^0.8.20; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev The ETH balance of the account is not enough to perform the operation. */ error AddressInsufficientBalance(address account); /** * @dev There's no code at `target` (it is not a contract). */ error AddressEmptyCode(address target); /** * @dev A call to an address target failed. The target may have reverted. */ error FailedInnerCall(); /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { if (address(this).balance < amount) { revert AddressInsufficientBalance(address(this)); } (bool success, ) = recipient.call{value: amount}(""); if (!success) { revert FailedInnerCall(); } } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason or custom error, it is bubbled * up by this function (like regular Solidity function calls). However, if * the call reverted with no returned reason, this function reverts with a * {FailedInnerCall} error. * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { if (address(this).balance < value) { revert AddressInsufficientBalance(address(this)); } (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an * unsuccessful call. */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata ) internal view returns (bytes memory) { if (!success) { _revert(returndata); } else { // only check if target is a contract if the call was successful and the return data is empty // otherwise we already know that it was a contract if (returndata.length == 0 && target.code.length == 0) { revert AddressEmptyCode(target); } return returndata; } } /** * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the * revert reason or with a default {FailedInnerCall} error. */ function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) { if (!success) { _revert(returndata); } else { return returndata; } } /** * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}. */ function _revert(bytes memory returndata) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert FailedInnerCall(); } } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol) pragma solidity ^0.8.20; import {Initializable} from "../proxy/utils/Initializable.sol"; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol) pragma solidity ^0.8.20; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant NOT_ENTERED = 1; uint256 private constant ENTERED = 2; uint256 private _status; /** * @dev Unauthorized reentrant call. */ error ReentrancyGuardReentrantCall(); constructor() { _status = NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be NOT_ENTERED if (_status == ENTERED) { revert ReentrancyGuardReentrantCall(); } // Any calls to nonReentrant after this point will fail _status = ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = NOT_ENTERED; } /** * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a * `nonReentrant` function in the call stack. */ function _reentrancyGuardEntered() internal view returns (bool) { return _status == ENTERED; } }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {IRobinhoodArenaManagerHelper} from "./RobinhoodHelperInterfaces.sol"; /// @notice Read-only inverse curve helper for Robinhood's wARENA-paired launcher. contract RobinhoodArenaPairPriceHelper { uint256 public constant GRANULARITY_SCALER = 1e18; IRobinhoodArenaManagerHelper public immutable TOKEN_MANAGER; error InvalidManager(); error CurveNotConfigured(); constructor(IRobinhoodArenaManagerHelper tokenManager_) { if (address(tokenManager_) == address(0) || address(tokenManager_).code.length == 0) { revert InvalidManager(); } TOKEN_MANAGER = tokenManager_; } function calculatePurchaseAmountAndPrice(uint256 arenaAmount, uint256 tokenId) external view returns (uint256 tokenAmount, uint256 price) { if (arenaAmount == 0) return (0, 0); uint256 maximum = TOKEN_MANAGER.getMaxTokensForSale(tokenId) / GRANULARITY_SCALER; uint256 units = _searchExisting(arenaAmount, tokenId, maximum); tokenAmount = units * GRANULARITY_SCALER; if (units != 0) price = TOKEN_MANAGER.calculateCostWithFees(units, tokenId); } function calculatePurchaseAmountAndPriceParametric( uint256 arenaAmount, uint32 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, uint256 tokenSplit ) external view returns (uint256 tokenAmount, uint256 price) { if (arenaAmount == 0) return (0, 0); uint256 allowedSupply = TOKEN_MANAGER.allowedTotalSupplyWithParameters(a, b, curveScaler, tokenSplit); if (allowedSupply == 0) revert CurveNotConfigured(); uint256 maximum = allowedSupply * tokenSplit / 100 / GRANULARITY_SCALER; uint256 units = _searchParametric( arenaAmount, a, b, curveScaler, creatorFeeBasisPoints, maximum ); tokenAmount = units * GRANULARITY_SCALER; if (units != 0) { price = _initialCost( tokenAmount, a, b, curveScaler, creatorFeeBasisPoints ); } } function calculateRewardWithFeesInArena(uint256 sellAmount, uint256 tokenId) external view returns (uint256) { return TOKEN_MANAGER.calculateRewardWithFees( sellAmount / GRANULARITY_SCALER, tokenId ); } /// @notice Reverses rounded bonding fees and the optional flat creation fee. function invertTotalToRaw( uint256 protocolFeeBasisPoints, uint256 referralFeeBasisPoints, uint256 creatorFeeBasisPoints, uint256 flatFee, uint256 totalPaid ) external pure returns (uint256 rawCost) { if (totalPaid == 0) return 0; require(totalPaid >= flatFee, "total below flat fee"); uint256 sum = protocolFeeBasisPoints + referralFeeBasisPoints + creatorFeeBasisPoints; uint256 approximation = (totalPaid - flatFee) * 10_000 / (10_000 + sum); uint256 computed = approximation + (approximation * protocolFeeBasisPoints + 5_000) / 10_000 + (approximation * referralFeeBasisPoints + 5_000) / 10_000 + (approximation * creatorFeeBasisPoints + 5_000) / 10_000 + flatFee; if (computed < totalPaid) return approximation + (totalPaid - computed); if (computed > totalPaid) return approximation - (computed - totalPaid); return approximation; } function _searchExisting(uint256 budget, uint256 tokenId, uint256 high) internal view returns (uint256 low) { while (low < high) { uint256 mid = (low + high + 1) / 2; uint256 cost = TOKEN_MANAGER.calculateCostWithFees(mid, tokenId); if (cost <= budget) low = mid; else high = mid - 1; } } function _searchParametric( uint256 budget, uint32 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, uint256 high ) internal view returns (uint256 low) { while (low < high) { uint256 mid = (low + high + 1) / 2; uint256 cost = _initialCost( mid * GRANULARITY_SCALER, a, b, curveScaler, creatorFeeBasisPoints ); if (cost <= budget) low = mid; else high = mid - 1; } } function _initialCost( uint256 amount, uint32 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints ) internal view returns (uint256) { return TOKEN_MANAGER.calculateCostScaledParametricWithFees( amount, 0, a, b, curveScaler, creatorFeeBasisPoints ) + TOKEN_MANAGER.tokenCreationBuyFeeAmount(); } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /// @title FixedPoint96 /// @notice A library for handling binary fixed point numbers, see https://en.wikipedia.org/wiki/Q_(number_format) /// @dev Used in SqrtPriceMath.sol library FixedPoint96 { uint8 internal constant RESOLUTION = 96; uint256 internal constant Q96 = 0x1000000000000000000000000; }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; /// @dev Creation-fee buyback support for the Robinhood Chain launch stack. import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol"; import {Pausable} from "@openzeppelin/contracts/utils/Pausable.sol"; import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol"; import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol"; import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol"; import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol"; import {Currency} from "@uniswap/v4-core/src/types/Currency.sol"; import {Actions} from "@uniswap/v4-periphery/src/libraries/Actions.sol"; import {IStateView} from "@uniswap/v4-periphery/src/interfaces/IStateView.sol"; interface ICreationFeeUniversalRouter { function execute(bytes calldata commands, bytes[] calldata inputs, uint256 deadline) external payable; function poolManager() external view returns (address); } /// @notice Queues native-ETH token-creation fees and swaps them into ARENA through /// one immutable, initialized Uniswap v4 pool. /// @dev Deposits remain available while swaps are paused so a DEX outage cannot /// block token launches. Swap execution is keeper-gated and always requires /// an exact ETH input, nonzero minimum output and deadline. ARENA is delivered /// directly to the immutable vault and can never be redirected by a keeper. contract CreationFeeBuybackAdapter is Ownable2Step, Pausable, ReentrancyGuard { using PoolIdLibrary for PoolKey; using SafeERC20 for IERC20; bytes1 private constant V4_SWAP_COMMAND = 0x10; /// @dev Shape required by Robinhood's deployed Universal Router. Encoding /// the fields flat omits the leading tuple offset required by hookData. struct RobinhoodExactInputSingleParams { PoolKey poolKey; bool zeroForOne; uint128 amountIn; uint128 amountOutMinimum; uint256 minHopPriceX36; bytes hookData; } IERC20 public immutable ARENA; address public immutable ARENA_VAULT; ICreationFeeUniversalRouter public immutable UNIVERSAL_ROUTER; IPoolManager public immutable POOL_MANAGER; IStateView public immutable STATE_VIEW; uint24 public immutable POOL_FEE; int24 public immutable TICK_SPACING; address public immutable HOOKS; bytes32 public immutable POOL_ID; uint256 public pendingEth; mapping(address => bool) public isDepositor; mapping(address => bool) public isKeeper; error InvalidAddress(); error InvalidPoolConfiguration(); error PoolNotInitialized(); error UnauthorizedDepositor(); error UnauthorizedKeeper(); error ZeroAmount(); error InvalidMinimumOutput(); error DeadlineExpired(); error AmountExceedsPendingEth(); error InputNotFullyConsumed(); error InsufficientArenaOutput(); error UnsupportedArenaToken(); error UnauthorizedNativeTransfer(); error EthTransferFailed(); error CannotRecoverArena(); event DepositorSet(address indexed depositor, bool authorized); event KeeperSet(address indexed keeper, bool authorized); event CreationFeeDeposited(address indexed depositor, uint256 amount, uint256 pendingEth); event BuybackExecuted( address indexed keeper, uint256 ethIn, uint256 arenaOut, uint256 pendingEth ); event ArenaSweptToVault(uint256 amount); event UnaccountedEthRecovered(address indexed recipient, uint256 amount); event UnsupportedTokenRecovered( address indexed token, address indexed recipient, uint256 amount ); constructor( address owner_, IERC20 arena_, address arenaVault_, ICreationFeeUniversalRouter universalRouter_, IStateView stateView_, uint24 poolFee_, int24 tickSpacing_, address hooks_ ) Ownable(owner_) { if ( owner_ == address(0) || address(arena_) == address(0) || address(arena_).code.length == 0 || arenaVault_ == address(0) || arenaVault_ == address(this) || address(universalRouter_) == address(0) || address(universalRouter_).code.length == 0 || address(stateView_) == address(0) || address(stateView_).code.length == 0 ) revert InvalidAddress(); if (poolFee_ == 0 || tickSpacing_ <= 0) revert InvalidPoolConfiguration(); if (hooks_ != address(0) && hooks_.code.length == 0) revert InvalidAddress(); address poolManager = universalRouter_.poolManager(); if ( poolManager == address(0) || poolManager.code.length == 0 || address(stateView_.poolManager()) != poolManager ) revert InvalidPoolConfiguration(); PoolKey memory key = PoolKey({ currency0: Currency.wrap(address(0)), currency1: Currency.wrap(address(arena_)), fee: poolFee_, tickSpacing: tickSpacing_, hooks: IHooks(hooks_) }); PoolId poolId = key.toId(); (uint160 sqrtPriceX96,,,) = stateView_.getSlot0(poolId); if (sqrtPriceX96 == 0) revert PoolNotInitialized(); ARENA = arena_; ARENA_VAULT = arenaVault_; UNIVERSAL_ROUTER = universalRouter_; POOL_MANAGER = IPoolManager(poolManager); STATE_VIEW = stateView_; POOL_FEE = poolFee_; TICK_SPACING = tickSpacing_; HOOKS = hooks_; POOL_ID = PoolId.unwrap(poolId); } function setDepositor(address depositor, bool authorized) external onlyOwner { if (depositor == address(0)) revert InvalidAddress(); isDepositor[depositor] = authorized; emit DepositorSet(depositor, authorized); } function setKeeper(address keeper, bool authorized) external onlyOwner { if (keeper == address(0)) revert InvalidAddress(); isKeeper[keeper] = authorized; emit KeeperSet(keeper, authorized); } function pause() external onlyOwner { _pause(); } function unpause() external onlyOwner { _unpause(); } function depositCreationFee() external payable { if (!isDepositor[msg.sender]) revert UnauthorizedDepositor(); if (msg.value == 0) revert ZeroAmount(); pendingEth += msg.value; emit CreationFeeDeposited(msg.sender, msg.value, pendingEth); } function executeBuyback(uint256 amountIn, uint256 minArenaOut, uint256 deadline) external whenNotPaused nonReentrant returns (uint256 arenaOut) { if (!isKeeper[msg.sender]) revert UnauthorizedKeeper(); if (amountIn == 0) revert ZeroAmount(); if (minArenaOut == 0) revert InvalidMinimumOutput(); if (block.timestamp > deadline) revert DeadlineExpired(); if (amountIn > pendingEth) revert AmountExceedsPendingEth(); if (amountIn > type(uint128).max) revert InvalidPoolConfiguration(); if (minArenaOut > type(uint128).max) revert InvalidMinimumOutput(); uint256 ethBefore = address(this).balance; uint256 arenaBefore = ARENA.balanceOf(address(this)); pendingEth -= amountIn; PoolKey memory key = PoolKey({ currency0: Currency.wrap(address(0)), currency1: Currency.wrap(address(ARENA)), fee: POOL_FEE, tickSpacing: TICK_SPACING, hooks: IHooks(HOOKS) }); bytes[] memory actionParams = new bytes[](4); actionParams[0] = abi.encode( RobinhoodExactInputSingleParams({ poolKey: key, zeroForOne: true, amountIn: uint128(amountIn), amountOutMinimum: uint128(minArenaOut), minHopPriceX36: 0, hookData: bytes("") }) ); actionParams[1] = abi.encode(address(0), amountIn, true); actionParams[2] = abi.encode(address(ARENA), minArenaOut); actionParams[3] = abi.encode(address(0), uint256(0)); bytes memory actions = abi.encodePacked( uint8(Actions.SWAP_EXACT_IN_SINGLE), uint8(Actions.SETTLE), uint8(Actions.TAKE_ALL), uint8(Actions.TAKE_ALL) ); bytes[] memory inputs = new bytes[](1); inputs[0] = abi.encode(actions, actionParams); UNIVERSAL_ROUTER.execute{value: amountIn}( abi.encodePacked(V4_SWAP_COMMAND), inputs, deadline ); if (address(this).balance != ethBefore - amountIn) revert InputNotFullyConsumed(); arenaOut = ARENA.balanceOf(address(this)) - arenaBefore; if (arenaOut < minArenaOut) revert InsufficientArenaOutput(); _transferArenaToVault(arenaOut); emit BuybackExecuted(msg.sender, amountIn, arenaOut, pendingEth); } /// @notice Sends ARENA transferred to this contract outside a buyback to the /// only permitted ARENA destination. function sweepArenaToVault() external nonReentrant returns (uint256 amount) { amount = ARENA.balanceOf(address(this)); if (amount == 0) revert ZeroAmount(); _transferArenaToVault(amount); emit ArenaSweptToVault(amount); } function recoverUnaccountedEth(address payable recipient) external onlyOwner nonReentrant returns (uint256 amount) { if (recipient == address(0)) revert InvalidAddress(); amount = address(this).balance - pendingEth; if (amount == 0) revert ZeroAmount(); (bool success,) = recipient.call{value: amount}(""); if (!success) revert EthTransferFailed(); emit UnaccountedEthRecovered(recipient, amount); } function recoverUnsupportedToken(address token, address recipient) external onlyOwner nonReentrant returns (uint256 amount) { if (token == address(ARENA)) revert CannotRecoverArena(); if (token == address(0) || recipient == address(0)) revert InvalidAddress(); amount = IERC20(token).balanceOf(address(this)); if (amount == 0) revert ZeroAmount(); IERC20(token).safeTransfer(recipient, amount); emit UnsupportedTokenRecovered(token, recipient, amount); } function _transferArenaToVault(uint256 amount) internal { uint256 beforeBalance = ARENA.balanceOf(ARENA_VAULT); ARENA.safeTransfer(ARENA_VAULT, amount); if (ARENA.balanceOf(ARENA_VAULT) - beforeBalance != amount) { revert UnsupportedArenaToken(); } } receive() external payable { if (msg.sender != address(UNIVERSAL_ROUTER) && msg.sender != address(POOL_MANAGER)) { revert UnauthorizedNativeTransfer(); } } }

// SPDX-License-Identifier: UNLICENSED pragma solidity 0.8.28; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol"; import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol"; import {IArenaPoolDeployer} from "../robinhood/interfaces/IArenaPoolDeployer.sol"; import {IArenaFeeHelperMinimal} from "../robinhood/interfaces/IArenaFeeHelperMinimal.sol"; import {IRobinhoodLaunchTokenFactory} from "../robinhood/interfaces/IRobinhoodLaunchTokenFactory.sol"; import {IRobinhoodLaunchToken} from "../robinhood/interfaces/IRobinhoodLaunchToken.sol"; interface IRobinhoodArenaPairRouter { function factory() external pure returns (address); } interface IRobinhoodArenaPairReferrerRegistry { function getReferrer(address referee) external view returns (address); } /// @notice Robinhood Chain port of Arena's ERC-20 ARENA-pair launcher. /// @dev Curve math, fee math, supply behavior and graduation flow intentionally /// follow Arena's TokenManagerERC20. ARENA_ADDRESS is the canonical wrapped /// ARENA representation selected when this implementation is deployed. contract RobinhoodArenaPairTokenManager is OwnableUpgradeable, UUPSUpgradeable, PausableUpgradeable, ReentrancyGuardUpgradeable { using SafeERC20 for IERC20; uint256 public constant GRANULARITY_SCALER = 1e18; uint8 public constant MAX_FEE_BASIS_POINT = 250; uint256 public constant INITIAL_TOKEN_ID = 100_000_000_000; uint256 public constant MAX_CREATOR_FEE_BASIS_POINT = 250; address public immutable ARENA_ADDRESS; IERC20 public immutable ARENA_CONTRACT; address public immutable STAKER_REWARD_TOKEN_VAULT; address public NATIVE_HELPER; uint256 public tokenIdentifier; address public protocolFeeDestination; uint8 public protocolFeeBasisPoint; uint8 public referralFeeBasisPoint; bool public canDeployLp; IRobinhoodArenaPairRouter public uniswapV2Router02; IRobinhoodLaunchTokenFactory public tokenFactory; address public tokenCreationBuyFeeVault; uint88 public tokenCreationBuyFeeAmount; bool public transferTokenCreationBuyFeeToVault; uint256[99] private __gap; error InvalidFeeSetting(); error InvalidArenaToken(); error InvalidStakerRewardVault(); event TokenCreated(uint256 tokenId, TokenParameters params, uint256 tokenSupply); event Sell( address user, uint256 tokenId, uint256 tokenAmount, uint256 reward, uint256 tokenSupply, address referrerAddress, uint256 referralFee, uint256 creatorFee, uint256 protocolFee ); event Buy( address user, uint256 tokenId, uint256 tokenAmount, uint256 cost, uint256 tokenSupply, address referrerAddress, uint256 referralFee, uint256 creatorFee, uint256 protocolFee ); event TokenLPCreated(uint256 tokenId, uint256 amountToken, uint256 amountARENA, uint256 liquidity); event ProtocolFeeBasisPointSet(uint256 oldBasisPoint, uint256 newBasisPoint); event ReferralFeeBasisPointSet(uint256 oldBasisPoint, uint256 newBasisPoint); event AllowedTokenSupplyForParamsSet( uint256 a, uint256 b, uint256 curveScaler, uint256 tokenSupply, uint256 tokenSplit ); event ProtocolFeeDestinationSet(address oldDestination, address newDestination); event LPDeployPermissionSet(bool value); event TokenFactorySet(address oldTokenFactoryAddress, address newTokenFactory); event TokenCreationBuyFeeParamsSet( address tokenCreationBuyFeeVault, uint88 tokenCreationBuyFeeAmount, bool transferTokenCreationBuyFeeToVault ); event BondingCreatorFeeBasisPointSet(uint256 oldBasisPoint, uint256 newBasisPoint); struct TokenParameters { uint128 curveScaler; uint32 a; uint8 b; bool lpDeployed; uint8 lpPercentage; uint8 salePercentage; uint8 creatorFeeBasisPoints; address creatorAddress; address pairAddress; address tokenContractAddress; } struct FeeData { uint256 protocolFee; uint256 creatorFee; uint256 referralFee; uint256 totalFeeAmount; address tokenCreator; address referrerAddress; } struct TokenInfo { uint8 protocolFee; uint8 creatorFee; uint8 referralFee; uint88 tokenCreationBuyFee; uint128 curveScaler; uint32 a; address tokenAddress; } struct V4PoolInitParams { IArenaPoolDeployer.PoolInitParams poolInitParams; uint16 creatorFeePpm; uint160 invertedStartingPrice; } mapping(uint256 => TokenParameters) public tokenParams; mapping(uint256 => uint256) public tokenBalanceOf; mapping(address => address) public referrers; mapping(bytes32 => uint256) public allowedTokenSupplyWithParameters; mapping(uint256 => uint256) public tokenSupply; address public LP_TOKEN_VAULT; IArenaPoolDeployer public arenaPoolDeployer; V4PoolInitParams public v4PoolInitParams; IRobinhoodArenaPairReferrerRegistry public referrerRegistry; /// @notice Creator fee charged on every bonding-curve buy and sell. /// @dev Appended for UUPS storage compatibility with the deployed proxy. uint8 public bondingCreatorFeeBasisPoint; /// @dev Appended after all existing proxy state for storage compatibility. mapping(uint256 => uint8) private holderRewardsMode; mapping(address => bool) private nextLaunchHolderRewardsDisabled; /// @notice Retained for ABI compatibility. Holder rewards are permanently disabled. function setNextLaunchHolderRewards(bool enabled) external { enabled; delete nextLaunchHolderRewardsDisabled[msg.sender]; } /// @notice Retained for ABI compatibility and always returns false. function holderRewardsEnabled(uint256 tokenId) public view returns (bool) { tokenId; return false; } modifier lpNotDeployed(uint256 tokenId) { require(!tokenParams[tokenId].lpDeployed, "LP already deployed!"); _; } /// @custom:oz-upgrades-unsafe-allow constructor constructor(address arenaAddress_, address stakerRewardTokenVault_) { if (arenaAddress_ == address(0)) revert InvalidArenaToken(); if (stakerRewardTokenVault_ == address(0)) revert InvalidStakerRewardVault(); ARENA_ADDRESS = arenaAddress_; ARENA_CONTRACT = IERC20(arenaAddress_); STAKER_REWARD_TOKEN_VAULT = stakerRewardTokenVault_; _disableInitializers(); } function initialize(address routerAddress, address ownerAddress, address tokenFactoryAddress) public initializer { __Ownable_init(ownerAddress); __UUPSUpgradeable_init(); __Pausable_init(); __ReentrancyGuard_init(); uniswapV2Router02 = IRobinhoodArenaPairRouter(routerAddress); tokenIdentifier = INITIAL_TOKEN_ID; tokenFactory = IRobinhoodLaunchTokenFactory(tokenFactoryAddress); canDeployLp = true; } function _authorizeUpgrade(address) internal override onlyOwner {} function setReferralFeeBasisPoint(uint8 feeBasisPoint) external onlyOwner { if (feeBasisPoint > MAX_FEE_BASIS_POINT) revert InvalidFeeSetting(); uint8 oldFeeBasisPoint = referralFeeBasisPoint; referralFeeBasisPoint = feeBasisPoint; emit ReferralFeeBasisPointSet(oldFeeBasisPoint, feeBasisPoint); } function setBondingCreatorFeeBasisPoint(uint8 feeBasisPoint) external onlyOwner { if (feeBasisPoint > MAX_CREATOR_FEE_BASIS_POINT) revert InvalidFeeSetting(); uint8 oldFeeBasisPoint = bondingCreatorFeeBasisPoint; bondingCreatorFeeBasisPoint = feeBasisPoint; emit BondingCreatorFeeBasisPointSet(oldFeeBasisPoint, feeBasisPoint); } function setAllowedTokenSupplyForParameters( uint32 a, uint8 b, uint128 c, uint256 allowedTokenSupply, uint256 tokenSplit ) external onlyOwner { require(c != 0, "Invalid c coefficient"); require(!(a > 0 && b > 0), "Invalid parameters"); require(!(a == 0 && b == 0), "Both a and b are zero, should revert"); require(tokenSplit <= 80 && tokenSplit >= 60, "Token split must be smaller"); require(allowedTokenSupply % 1e18 == 0, "allowedtokenSupply must be divisible by 1e18"); bytes32 parametersAndSupplyHash = keccak256(abi.encodePacked(a, b, c, tokenSplit)); allowedTokenSupplyWithParameters[parametersAndSupplyHash] = allowedTokenSupply; emit AllowedTokenSupplyForParamsSet(a, b, c, allowedTokenSupply, tokenSplit); } function setLpDeployPermission(bool value) external onlyOwner { canDeployLp = value; emit LPDeployPermissionSet(value); } function setProtocolFeeBasisPoint(uint8 feeBasisPoint) external onlyOwner { if (feeBasisPoint > MAX_FEE_BASIS_POINT) revert InvalidFeeSetting(); uint8 oldFeeBasisPoint = protocolFeeBasisPoint; protocolFeeBasisPoint = feeBasisPoint; emit ProtocolFeeBasisPointSet(oldFeeBasisPoint, feeBasisPoint); } function setFeeDestination(address feeDestination) external onlyOwner { require(feeDestination != address(0), "Invalid fee destination"); address oldDestination = protocolFeeDestination; protocolFeeDestination = feeDestination; emit ProtocolFeeDestinationSet(oldDestination, feeDestination); } function setTokenFactory(address newTokenFactory) external onlyOwner { address oldTokenFactoryAddress = address(tokenFactory); tokenFactory = IRobinhoodLaunchTokenFactory(newTokenFactory); emit TokenFactorySet(oldTokenFactoryAddress, newTokenFactory); } function setNativeHelper(address newNativeHelper) external onlyOwner { NATIVE_HELPER = newNativeHelper; } function pause() public onlyOwner { _pause(); } function unpause() public onlyOwner { _unpause(); } function setLpTokenVault(address lpTokenVault) external onlyOwner { LP_TOKEN_VAULT = lpTokenVault; } function setArenaPoolDeployer(address newArenaPoolDeployer) external onlyOwner { arenaPoolDeployer = IArenaPoolDeployer(newArenaPoolDeployer); } function setReferrerRegistry(address newReferrerRegistry) external onlyOwner { referrerRegistry = IRobinhoodArenaPairReferrerRegistry(newReferrerRegistry); } function setPoolInitParams( IArenaPoolDeployer.PoolInitParams calldata poolInitParams, uint16 creatorFeePpm, uint160 invertedStartingPrice ) external onlyOwner { v4PoolInitParams.poolInitParams = poolInitParams; v4PoolInitParams.creatorFeePpm = creatorFeePpm; v4PoolInitParams.invertedStartingPrice = invertedStartingPrice; require( invertedStartingPrice < v4PoolInitParams.poolInitParams.startingPrice, "Inverted starting price must be greater than starting price" ); } function renounceOwnership() public override onlyOwner {} function setTokenCreationBuyFeeParams( address creationFeeVault, uint88 creationFeeAmount, bool transferCreationFeeToVault ) external onlyOwner { require(creationFeeVault != address(0), "Invalid token creation buy fee vault"); tokenCreationBuyFeeAmount = creationFeeAmount; transferTokenCreationBuyFeeToVault = transferCreationFeeToVault; tokenCreationBuyFeeVault = creationFeeVault; emit TokenCreationBuyFeeParamsSet( creationFeeVault, creationFeeAmount, transferCreationFeeToVault ); } function createToken( uint32 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, address tokenCreatorAddress, uint256 tokenSplit, string memory name, string memory symbol, uint256 amount ) public whenNotPaused nonReentrant { _createToken( a, b, curveScaler, creatorFeeBasisPoints, tokenCreatorAddress, tokenSplit, name, symbol, amount, false ); } function _createToken( uint32 a, uint8 b, uint128 curveScaler, uint8, address tokenCreatorAddress, uint256 tokenSplit, string memory name, string memory symbol, uint256 amount, bool whitelistLaunch ) internal { require(tokenCreatorAddress != address(0), "Token creator address must be set"); uint256 allowedSupply = allowedTotalSupplyWithParameters(a, b, curveScaler, tokenSplit); require(allowedSupply != 0, "There is no registered token supply"); tokenSupply[tokenIdentifier] = allowedSupply; address tokenContractAddress = tokenFactory.deployToken(name, symbol, tokenIdentifier); TokenParameters storage params = tokenParams[tokenIdentifier]; params.a = a; params.b = b; params.curveScaler = curveScaler; params.creatorFeeBasisPoints = bondingCreatorFeeBasisPoint; params.tokenContractAddress = tokenContractAddress; params.pairAddress = address(0); params.creatorAddress = tokenCreatorAddress; params.lpPercentage = 100 - uint8(tokenSplit); params.salePercentage = uint8(tokenSplit); holderRewardsMode[tokenIdentifier] = 2; delete nextLaunchHolderRewardsDisabled[msg.sender]; emit TokenCreated(tokenIdentifier, params, allowedSupply); if (amount > 0) { _handleInitialBuyFee(); if (whitelistLaunch) { _buy(amount, tokenIdentifier, tokenCreatorAddress, type(uint256).max); } else { _buyAndCreateLpIfPossible( amount, tokenIdentifier, tokenCreatorAddress, type(uint256).max ); } } ++tokenIdentifier; } function createTokenWithWL( uint32 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, address tokenCreatorAddress, uint256 tokenSplit, string memory name, string memory symbol, uint256 amount, IRobinhoodLaunchToken.Whitelist calldata whitelist ) external whenNotPaused nonReentrant { _createToken( a, b, curveScaler, creatorFeeBasisPoints, tokenCreatorAddress, tokenSplit, name, symbol, amount, true ); uint256 tokenId = tokenIdentifier - 1; IRobinhoodLaunchToken token = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress); token.setWhitelistedAddresses(whitelist); token.setCreator(tokenParams[tokenId].creatorAddress); if (_isLpTokenThresholdReached(tokenId)) _createLp(tokenId); } function _buy(uint256 amount, uint256 tokenId, address user, uint256 maxArenaToSpend) internal whenNotPaused lpNotDeployed(tokenId) { require(amount % GRANULARITY_SCALER == 0, "Amount must be a multiple of GRANULARITY_SCALER"); amount /= GRANULARITY_SCALER; uint256 currentSupply; { uint256 currentSupplyInWei = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply(); (uint256 maxBuyableAmountInWei, uint256 maxTokensForSaleInWei) = _getMaxTokensForSaleWithSupply(tokenId, currentSupplyInWei); uint256 maxBuyableAmount = maxBuyableAmountInWei / GRANULARITY_SCALER; uint256 maxTokensForSale = maxTokensForSaleInWei / GRANULARITY_SCALER; if (amount > maxBuyableAmount) amount = maxBuyableAmount; currentSupply = currentSupplyInWei / GRANULARITY_SCALER; require(currentSupply + amount <= maxTokensForSale, "supply mismatch in buy"); } require(amount > 0, "amount must be greater than 0"); uint256 costs = calculateCostWithSupply(amount, tokenId, currentSupply); FeeData memory feeData = getFeeData(tokenId, costs, user); uint256 totalCost = feeData.totalFeeAmount + costs; require(totalCost <= maxArenaToSpend, "Insufficient arena to spend"); ARENA_CONTRACT.safeTransferFrom(msg.sender, address(this), totalCost); IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).mint( msg.sender, amount * GRANULARITY_SCALER ); tokenBalanceOf[tokenId] += costs; _handleFeeTransfers(feeData); emit Buy( user, tokenId, amount, totalCost, currentSupply + amount, feeData.referrerAddress, feeData.referralFee, feeData.creatorFee, feeData.protocolFee ); } function buyAndCreateLpIfPossible( uint256 amount, uint256 tokenId, uint256 maxArenaToSpend ) public nonReentrant { _buyAndCreateLpIfPossible(amount, tokenId, msg.sender, maxArenaToSpend); } function _buyAndCreateLpIfPossible( uint256 amount, uint256 tokenId, address user, uint256 maxArenaToSpend ) internal { _buy(amount, tokenId, user, maxArenaToSpend); if (_isLpTokenThresholdReached(tokenId)) _createLp(tokenId); } function _sell(uint256 amount, uint256 tokenId, address user, uint256 minArenaToReceive) internal whenNotPaused lpNotDeployed(tokenId) returns (uint256 amountOut) { require(amount % GRANULARITY_SCALER == 0, "Amount must be a multiple of GRANULARITY_SCALER"); amount /= GRANULARITY_SCALER; require(amount > 0, "amount must be greater than zero"); (uint256 reward, uint256 currentSupply) = calculateRewardAndSupply(amount, tokenId); FeeData memory feeData = getFeeData(tokenId, reward, user); IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).burn( msg.sender, amount * GRANULARITY_SCALER ); tokenBalanceOf[tokenId] -= reward; _handleFeeTransfers(feeData); ARENA_CONTRACT.safeTransfer(msg.sender, reward - feeData.totalFeeAmount); emit Sell( user, tokenId, amount, reward, currentSupply - amount, feeData.referrerAddress, feeData.referralFee, feeData.creatorFee, feeData.protocolFee ); amountOut = reward - feeData.totalFeeAmount; require(amountOut >= minArenaToReceive, "Insufficient arena to receive"); } function sell(uint256 amount, uint256 tokenId, uint256 minArenaToReceive) public whenNotPaused lpNotDeployed(tokenId) nonReentrant returns (uint256 amountOut) { amountOut = _sell(amount, tokenId, msg.sender, minArenaToReceive); } function _createLp(uint256 tokenId) internal { require(canDeployLp, "Lp deploy not allowed right now!"); TokenParameters memory paramsCached = tokenParams[tokenId]; require(!paramsCached.lpDeployed, "Lp already deployed"); tokenParams[tokenId].lpDeployed = true; uint256 allowedMaxSupply = tokenSupply[tokenId]; uint256 onePercent = allowedMaxSupply / 100; uint256 tokenAmount = onePercent * paramsCached.lpPercentage; uint256 arenaAmount = tokenBalanceOf[tokenId]; tokenBalanceOf[tokenId] = 0; if (paramsCached.pairAddress != address(0)) { IRobinhoodLaunchToken(paramsCached.tokenContractAddress).setBlacklistStatus( paramsCached.pairAddress, false ); } IRobinhoodLaunchToken token = IRobinhoodLaunchToken(paramsCached.tokenContractAddress); token.mint(address(this), tokenAmount); IArenaFeeHelperMinimal.Fee[] memory fees = new IArenaFeeHelperMinimal.Fee[](1); V4PoolInitParams memory poolConfig = v4PoolInitParams; fees[0] = IArenaFeeHelperMinimal.Fee({ recipient: paramsCached.creatorAddress, feePpm: poolConfig.creatorFeePpm }); IERC20(address(token)).forceApprove(address(arenaPoolDeployer), tokenAmount); ARENA_CONTRACT.forceApprove(address(arenaPoolDeployer), arenaAmount); poolConfig.poolInitParams.recipient = LP_TOKEN_VAULT; poolConfig.poolInitParams.hookData = bytes(""); if (ARENA_ADDRESS > paramsCached.tokenContractAddress) { poolConfig.poolInitParams.startingPrice = poolConfig.invertedStartingPrice; int24 tickLowerCached = poolConfig.poolInitParams.tickLower; poolConfig.poolInitParams.tickLower = -poolConfig.poolInitParams.tickUpper; poolConfig.poolInitParams.tickUpper = -tickLowerCached; poolConfig.poolInitParams.token0Amount = tokenAmount; poolConfig.poolInitParams.token1Amount = arenaAmount; poolConfig.poolInitParams.token0 = paramsCached.tokenContractAddress; poolConfig.poolInitParams.token1 = ARENA_ADDRESS; } else { poolConfig.poolInitParams.token0Amount = arenaAmount; poolConfig.poolInitParams.token1Amount = tokenAmount; poolConfig.poolInitParams.token0 = ARENA_ADDRESS; poolConfig.poolInitParams.token1 = paramsCached.tokenContractAddress; } arenaPoolDeployer.initPoolAndSetFees(poolConfig.poolInitParams, fees); OwnableUpgradeable(paramsCached.tokenContractAddress).renounceOwnership(); require(token.totalSupply() == allowedMaxSupply, "total supply mismatch"); emit TokenLPCreated(tokenId, tokenAmount, arenaAmount, 0); } function getFeeData(uint256 tokenId, uint256 rawCosts, address user) public view returns (FeeData memory feeData) { feeData.tokenCreator = tokenParams[tokenId].creatorAddress; feeData.referrerAddress = referrerRegistry.getReferrer(user); feeData.protocolFee = (rawCosts * protocolFeeBasisPoint + 5000) / 10000; feeData.creatorFee = (rawCosts * bondingCreatorFeeBasisPoint + 5000) / 10000; feeData.referralFee = (rawCosts * referralFeeBasisPoint + 5000) / 10000; if (feeData.referrerAddress == address(0)) { feeData.protocolFee += feeData.referralFee; feeData.referralFee = 0; } feeData.totalFeeAmount = feeData.protocolFee + feeData.creatorFee + feeData.referralFee; } function _handleFeeTransfers(FeeData memory feeData) internal { if (feeData.referrerAddress != address(0)) { ARENA_CONTRACT.safeTransfer(feeData.referrerAddress, feeData.referralFee); } if (feeData.tokenCreator != address(0) && feeData.creatorFee > 0) { ARENA_CONTRACT.safeTransfer(feeData.tokenCreator, feeData.creatorFee); } ARENA_CONTRACT.safeTransfer(protocolFeeDestination, feeData.protocolFee); } function calculateCost(uint256 amountInToken, uint256 tokenId) public view returns (uint256) { if (amountInToken == 0) return 0; uint256 totalSupply = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply() / GRANULARITY_SCALER; return _integralCeil(tokenId, totalSupply + amountInToken, totalSupply); } function calculateCostWithFees(uint256 amountInToken, uint256 tokenId) public view returns (uint256) { if (amountInToken == 0) return 0; uint256 costs = calculateCost(amountInToken, tokenId); FeeData memory feeData = getFeeData(tokenId, costs, address(0)); return costs + feeData.totalFeeAmount; } function calculateCostWithSupply(uint256 amountInToken, uint256 tokenId, uint256 totalSupply) public view returns (uint256) { if (amountInToken == 0) return 0; return _integralCeil(tokenId, totalSupply + amountInToken, totalSupply); } function calculateCostScaledParametric( uint256 amountInWei, uint256 supplyInWei, uint256 a, uint256 b, uint256 curveScaler ) public pure returns (uint256) { uint256 amountInTokens = amountInWei / GRANULARITY_SCALER; uint256 supplyInTokens = supplyInWei / GRANULARITY_SCALER; uint256 upperBound = supplyInTokens + amountInTokens; uint256 lowerBound = supplyInTokens; uint256 upperSum = (2 * (upperBound ** 3) * a) + (3 * (upperBound ** 2) * b); uint256 lowerSum = (2 * (lowerBound ** 3) * a) + (3 * (lowerBound ** 2) * b); return ((upperSum - lowerSum) + (curveScaler * 6 - 1)) / (curveScaler * 6); } function calculateCostScaledParametricWithFees( uint256 amountInWei, uint256 supplyInWei, uint256 a, uint256 b, uint256 curveScaler, uint256 ) external view returns (uint256) { uint256 rawCosts = calculateCostScaledParametric(amountInWei, supplyInWei, a, b, curveScaler); return rawCosts + ((rawCosts * protocolFeeBasisPoint + 5000) / 10000) + ((rawCosts * bondingCreatorFeeBasisPoint + 5000) / 10000) + ((rawCosts * referralFeeBasisPoint + 5000) / 10000); } function calculateReward(uint256 amount, uint256 tokenId) public view returns (uint256) { if (amount == 0) return 0; uint256 totalSupply = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply() / GRANULARITY_SCALER; return _integralFloor(tokenId, totalSupply, totalSupply - amount); } function calculateRewardWithFees(uint256 amount, uint256 tokenId) external view returns (uint256) { if (amount == 0) return 0; uint256 reward = calculateReward(amount, tokenId); FeeData memory feeData = getFeeData(tokenId, reward, address(0)); return reward - feeData.totalFeeAmount; } function calculateRewardAndSupply(uint256 amount, uint256 tokenId) public view returns (uint256, uint256) { uint256 totalSupply = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply() / GRANULARITY_SCALER; if (amount == 0) return (0, totalSupply); return (_integralFloor(tokenId, totalSupply, totalSupply - amount), totalSupply); } function _integralFloor(uint256 tokenId, uint256 upperBound, uint256 lowerBound) internal view returns (uint256) { TokenParameters memory params = tokenParams[tokenId]; uint256 upperSum = ((2 * (upperBound ** 3)) * params.a) + (3 * (upperBound ** 2) * params.b); uint256 lowerSum = ((2 * (lowerBound ** 3)) * params.a) + (3 * (lowerBound ** 2) * params.b); return (upperSum - lowerSum) / (uint256(params.curveScaler) * 6); } function _integralCeil(uint256 tokenId, uint256 upperBound, uint256 lowerBound) internal view returns (uint256) { TokenParameters memory params = tokenParams[tokenId]; uint256 upperSum = (2 * (upperBound ** 3) * params.a) + (3 * (upperBound ** 2) * params.b); uint256 lowerSum = (2 * (lowerBound ** 3) * params.a) + (3 * (lowerBound ** 2) * params.b); uint256 denominator = uint256(params.curveScaler) * 6; return ((upperSum - lowerSum) + (denominator - 1)) / denominator; } function allowedTotalSupplyWithParameters( uint32 a, uint8 b, uint128 c, uint256 tokenSplit ) public view returns (uint256 allowedSupply) { bytes32 parametersHash = keccak256(abi.encodePacked(a, b, c, tokenSplit)); return allowedTokenSupplyWithParameters[parametersHash]; } function getMaxTokensForSale(uint256 tokenId) public view returns (uint256 buyLimit) { uint256 currentSupply = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply(); (buyLimit,) = _getMaxTokensForSaleWithSupply(tokenId, currentSupply); } function getTokenParameters(uint256 tokenId) external view returns (TokenParameters memory params) { params = tokenParams[tokenId]; params.creatorFeeBasisPoints = bondingCreatorFeeBasisPoint; } function getV4PoolInitParams() external view returns (V4PoolInitParams memory) { return v4PoolInitParams; } function _getMaxTokensForSaleWithSupply(uint256 tokenId, uint256 currentSupplyInWei) internal view returns (uint256 buyLimit, uint256 maxTokensForSale) { uint256 maxSupplyForSale = tokenSupply[tokenId] * tokenParams[tokenId].salePercentage / 100; if (maxSupplyForSale >= currentSupplyInWei) { return (maxSupplyForSale - currentSupplyInWei, maxSupplyForSale); } return (0, maxSupplyForSale); } function _isLpTokenThresholdReached(uint256 tokenId) internal view returns (bool) { return tokenSupply[tokenId] * tokenParams[tokenId].salePercentage == IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply() * 100; } function _handleInitialBuyFee() internal { if (tokenCreationBuyFeeAmount > 0) { ARENA_CONTRACT.safeTransferFrom( msg.sender, tokenCreationBuyFeeVault, tokenCreationBuyFeeAmount ); } } function buyAndCreateLpIfPossibleWithUser( uint256 amount, uint256 tokenId, address user, uint256 maxArenaToSpend ) external nonReentrant { require(msg.sender == NATIVE_HELPER, "Only NativeHelper can buy and create lp"); _buyAndCreateLpIfPossible(amount, tokenId, user, maxArenaToSpend); } function sellWithUser( uint256 amount, uint256 tokenId, address user, uint256 minArenaToReceive ) external nonReentrant returns (uint256 amountOut) { require(msg.sender == NATIVE_HELPER, "Only NativeHelper can sell"); amountOut = _sell(amount, tokenId, user, minArenaToReceive); } function getFeeInfoAndCurrentTokenIdentifier(uint256 tokenId) external view returns (uint256, uint256, uint256, uint256, uint256) { return ( protocolFeeBasisPoint, referralFeeBasisPoint, bondingCreatorFeeBasisPoint, tokenCreationBuyFeeAmount, tokenIdentifier ); } function getTokenInfo(uint256 tokenId) external view returns (TokenInfo memory) { return TokenInfo({ protocolFee: protocolFeeBasisPoint, creatorFee: bondingCreatorFeeBasisPoint, referralFee: referralFeeBasisPoint, tokenCreationBuyFee: tokenCreationBuyFeeAmount, curveScaler: tokenParams[tokenId].curveScaler, a: tokenParams[tokenId].a, tokenAddress: tokenParams[tokenId].tokenContractAddress }); } receive() external payable { require( msg.sender == address(uniswapV2Router02), "Only Uniswap V2 Router can send Ether to this contract" ); payable(owner()).transfer(msg.value); } }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol"; import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol"; import {Currency} from "@uniswap/v4-core/src/types/Currency.sol"; import {IRobinhoodLaunchToken} from "../robinhood/interfaces/IRobinhoodLaunchToken.sol"; import {IArenaPoolDeployer} from "../robinhood/interfaces/IArenaPoolDeployer.sol"; import { IRobinhoodArenaManagerHelper, IRobinhoodHelperPermit2, IRobinhoodHelperUniversalRouter } from "../helpers/RobinhoodHelperInterfaces.sol"; import {RobinhoodV4SwapExecutor} from "../helpers/RobinhoodV4SwapExecutor.sol"; interface IPrismBuyerRegistry { function isApprovedManager(address manager) external view returns (bool); } /// @notice Atomically launches, graduates, and performs the first v4 purchase /// through any registry-approved Arena Prism manager. contract RobinhoodPrismBuyer is RobinhoodV4SwapExecutor, ReentrancyGuard { using SafeERC20 for IERC20; struct CreationParams { address manager; uint32 a; uint8 b; uint128 curveScaler; uint8 creatorFeeBasisPoints; address tokenCreatorAddress; uint256 tokenSplit; bool enableHolderRewards; string name; string symbol; } struct Settlement { address token; uint256 pairBalanceBefore; uint256 preBondAmount; uint256 minPostBondTokenOut; uint256 deadline; } IPrismBuyerRegistry public immutable REGISTRY; error InvalidRegistry(); error ManagerNotApproved(); error CurveNotConfigured(); error GraduationFailed(); error NoPostBondInput(); error TokenTransferFailed(); event PrismTokenLaunchedAndBought( address indexed user, address indexed manager, address indexed pairToken, uint256 tokenId, address token, uint256 preBondTokenOut, uint256 postBondInput, uint256 postBondTokenOut ); constructor( IPrismBuyerRegistry registry, IRobinhoodHelperUniversalRouter universalRouter, IRobinhoodHelperPermit2 permit2 ) RobinhoodV4SwapExecutor(universalRouter, permit2) { if (address(registry) == address(0) || address(registry).code.length == 0) { revert InvalidRegistry(); } REGISTRY = registry; } function bondAndBuyFromLpOnCreation( CreationParams calldata params, uint256 pairTokenToSpend, uint256 minPostBondTokenOut, uint256 deadline ) external nonReentrant returns (address token, uint256 tokenOut) { IRobinhoodLaunchToken.Whitelist memory whitelist; return _launch( params, whitelist, false, pairTokenToSpend, minPostBondTokenOut, deadline ); } function bondAndBuyFromLpOnCreationWithWhitelist( CreationParams calldata params, uint256 pairTokenToSpend, IRobinhoodLaunchToken.Whitelist calldata whitelist, uint256 minPostBondTokenOut, uint256 deadline ) external nonReentrant returns (address token, uint256 tokenOut) { return _launch( params, whitelist, true, pairTokenToSpend, minPostBondTokenOut, deadline ); } function _launch( CreationParams calldata params, IRobinhoodLaunchToken.Whitelist memory whitelist, bool withWhitelist, uint256 pairTokenToSpend, uint256 minPostBondTokenOut, uint256 deadline ) internal returns (address token, uint256 tokenOut) { if (!REGISTRY.isApprovedManager(params.manager)) revert ManagerNotApproved(); IRobinhoodArenaManagerHelper manager = IRobinhoodArenaManagerHelper(params.manager); IERC20 pairToken = IERC20(manager.ARENA_ADDRESS()); uint256 balanceBefore = pairToken.balanceOf(address(this)); pairToken.safeTransferFrom(msg.sender, address(this), pairTokenToSpend); pairToken.forceApprove(params.manager, pairTokenToSpend); (uint256 tokenId, uint256 preBondAmount) = _createAndGraduate(manager, params, whitelist, withWhitelist); token = manager.getTokenParameters(tokenId).tokenContractAddress; uint256 postBondInput; uint256 postBondOut; (tokenOut, postBondInput, postBondOut) = _swapAndSettle( manager, pairToken, Settlement( token, balanceBefore, preBondAmount, minPostBondTokenOut, deadline ) ); emit PrismTokenLaunchedAndBought( msg.sender, params.manager, address(pairToken), tokenId, token, preBondAmount, postBondInput, postBondOut ); } function _swapAndSettle( IRobinhoodArenaManagerHelper manager, IERC20 pairToken, Settlement memory settlement ) internal returns (uint256 tokenOut, uint256 postBondInput, uint256 postBondOut) { postBondInput = pairToken.balanceOf(address(this)) - settlement.pairBalanceBefore; if (postBondInput == 0) revert NoPostBondInput(); postBondOut = _swapExactInputSingle( _poolKey( address(pairToken), settlement.token, manager.getV4PoolInitParams().poolInitParams ), address(pairToken) < settlement.token, postBondInput, settlement.minPostBondTokenOut, settlement.deadline ); tokenOut = IERC20(settlement.token).balanceOf(address(this)); if (tokenOut < settlement.preBondAmount + postBondOut) { revert TokenTransferFailed(); } IERC20(settlement.token).safeTransfer(msg.sender, tokenOut); uint256 refund = pairToken.balanceOf(address(this)) - settlement.pairBalanceBefore; if (refund != 0) pairToken.safeTransfer(msg.sender, refund); pairToken.forceApprove(address(manager), 0); } function _createAndGraduate( IRobinhoodArenaManagerHelper manager, CreationParams calldata params, IRobinhoodLaunchToken.Whitelist memory whitelist, bool withWhitelist ) internal returns (uint256 tokenId, uint256 preBondAmount) { tokenId = manager.tokenIdentifier(); uint256 allowed = manager.allowedTotalSupplyWithParameters( params.a, params.b, params.curveScaler, params.tokenSplit ); if (allowed == 0) revert CurveNotConfigured(); preBondAmount = allowed * params.tokenSplit / 100; manager.setNextLaunchHolderRewards(params.enableHolderRewards); if (withWhitelist) { _createWithWhitelist(manager, params, preBondAmount, whitelist); } else { _createWithoutWhitelist(manager, params, preBondAmount); } IRobinhoodArenaManagerHelper.TokenParameters memory tokenParams = manager.getTokenParameters(tokenId); if (!tokenParams.lpDeployed) revert GraduationFailed(); } function _createWithoutWhitelist( IRobinhoodArenaManagerHelper manager, CreationParams calldata params, uint256 preBondAmount ) internal { manager.createToken( params.a, params.b, params.curveScaler, params.creatorFeeBasisPoints, params.tokenCreatorAddress, params.tokenSplit, params.name, params.symbol, preBondAmount ); } function _createWithWhitelist( IRobinhoodArenaManagerHelper manager, CreationParams calldata params, uint256 preBondAmount, IRobinhoodLaunchToken.Whitelist memory whitelist ) internal { manager.createTokenWithWL( params.a, params.b, params.curveScaler, params.creatorFeeBasisPoints, params.tokenCreatorAddress, params.tokenSplit, params.name, params.symbol, preBondAmount, whitelist ); } function _poolKey( address pairedToken, address launchToken, IArenaPoolDeployer.PoolInitParams memory config ) internal pure returns (PoolKey memory) { address token0 = pairedToken < launchToken ? pairedToken : launchToken; address token1 = pairedToken < launchToken ? launchToken : pairedToken; return PoolKey({ currency0: Currency.wrap(token0), currency1: Currency.wrap(token1), fee: config.fee, tickSpacing: config.tickSpacing, hooks: IHooks(config.hookContract) }); } }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {IRobinhoodNativeManagerHelper} from "./RobinhoodHelperInterfaces.sol"; /// @notice Read-only inverse curve helper for Robinhood's native-ETH launcher. /// @dev Searches whole-token amounts because the manager only accepts buys in /// GRANULARITY_SCALER-sized units. contract RobinhoodNativePriceHelper { uint256 public constant GRANULARITY_SCALER = 1e18; IRobinhoodNativeManagerHelper public immutable TOKEN_MANAGER; error InvalidManager(); error CurveNotConfigured(); constructor(IRobinhoodNativeManagerHelper tokenManager_) { if (address(tokenManager_) == address(0) || address(tokenManager_).code.length == 0) { revert InvalidManager(); } TOKEN_MANAGER = tokenManager_; } function calculatePurchaseAmountAndPrice(uint256 nativeAmount, uint256 tokenId) external view returns (uint256 tokenAmount, uint256 price) { if (nativeAmount == 0) return (0, 0); uint256 maximum = TOKEN_MANAGER.getMaxTokensForSale(tokenId) / GRANULARITY_SCALER; uint256 units = _searchExisting(nativeAmount, tokenId, maximum); tokenAmount = units * GRANULARITY_SCALER; if (units != 0) price = TOKEN_MANAGER.calculateCostWithFees(units, tokenId); } function calculatePurchaseAmountAndPriceParametric( uint256 nativeAmount, uint16 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, uint256 tokenSplit ) external view returns (uint256 tokenAmount, uint256 price) { if (nativeAmount == 0) return (0, 0); uint256 allowedSupply = TOKEN_MANAGER.allowedTotalSupplyWithParameters(a, b, curveScaler, tokenSplit); if (allowedSupply == 0) revert CurveNotConfigured(); uint256 maximum = allowedSupply * tokenSplit / 100 / GRANULARITY_SCALER; uint256 units = _searchParametric( nativeAmount, a, b, curveScaler, creatorFeeBasisPoints, maximum ); tokenAmount = units * GRANULARITY_SCALER; if (units != 0) { price = _initialCost( tokenAmount, a, b, curveScaler, creatorFeeBasisPoints ); } } function _searchExisting(uint256 budget, uint256 tokenId, uint256 high) internal view returns (uint256 low) { while (low < high) { uint256 mid = (low + high + 1) / 2; uint256 cost = TOKEN_MANAGER.calculateCostWithFees(mid, tokenId); if (cost <= budget) low = mid; else high = mid - 1; } } function _searchParametric( uint256 budget, uint16 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, uint256 high ) internal view returns (uint256 low) { while (low < high) { uint256 mid = (low + high + 1) / 2; uint256 cost = _initialCost( mid * GRANULARITY_SCALER, a, b, curveScaler, creatorFeeBasisPoints ); if (cost <= budget) low = mid; else high = mid - 1; } } function _initialCost( uint256 amount, uint16 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints ) internal view returns (uint256) { return TOKEN_MANAGER.calculateInitialBuyCostScaledParametricWithFees( amount, 0, a, b, curveScaler, creatorFeeBasisPoints ); } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.20; import {IERC20} from "./IERC20.sol"; import {IERC20Metadata} from "./extensions/IERC20Metadata.sol"; import {Context} from "../../utils/Context.sol"; import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * * TIP: For a detailed writeup see our guide * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * The default value of {decimals} is 18. To change this, you should override * this function so it returns a different value. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. */ abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors { mapping(address account => uint256) private _balances; mapping(address account => mapping(address spender => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the default value returned by this function, unless * it's overridden. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `value`. */ function transfer(address to, uint256 value) public virtual returns (bool) { address owner = _msgSender(); _transfer(owner, to, value); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 value) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, value); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `value`. * - the caller must have allowance for ``from``'s tokens of at least * `value`. */ function transferFrom(address from, address to, uint256 value) public virtual returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, value); _transfer(from, to, value); return true; } /** * @dev Moves a `value` amount of tokens from `from` to `to`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * NOTE: This function is not virtual, {_update} should be overridden instead. */ function _transfer(address from, address to, uint256 value) internal { if (from == address(0)) { revert ERC20InvalidSender(address(0)); } if (to == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(from, to, value); } /** * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding * this function. * * Emits a {Transfer} event. */ function _update(address from, address to, uint256 value) internal virtual { if (from == address(0)) { // Overflow check required: The rest of the code assumes that totalSupply never overflows _totalSupply += value; } else { uint256 fromBalance = _balances[from]; if (fromBalance < value) { revert ERC20InsufficientBalance(from, fromBalance, value); } unchecked { // Overflow not possible: value <= fromBalance <= totalSupply. _balances[from] = fromBalance - value; } } if (to == address(0)) { unchecked { // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply. _totalSupply -= value; } } else { unchecked { // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256. _balances[to] += value; } } emit Transfer(from, to, value); } /** * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0). * Relies on the `_update` mechanism * * Emits a {Transfer} event with `from` set to the zero address. * * NOTE: This function is not virtual, {_update} should be overridden instead. */ function _mint(address account, uint256 value) internal { if (account == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(address(0), account, value); } /** * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply. * Relies on the `_update` mechanism. * * Emits a {Transfer} event with `to` set to the zero address. * * NOTE: This function is not virtual, {_update} should be overridden instead */ function _burn(address account, uint256 value) internal { if (account == address(0)) { revert ERC20InvalidSender(address(0)); } _update(account, address(0), value); } /** * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. * * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument. */ function _approve(address owner, address spender, uint256 value) internal { _approve(owner, spender, value, true); } /** * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event. * * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any * `Approval` event during `transferFrom` operations. * * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to * true using the following override: * ``` * function _approve(address owner, address spender, uint256 value, bool) internal virtual override { * super._approve(owner, spender, value, true); * } * ``` * * Requirements are the same as {_approve}. */ function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual { if (owner == address(0)) { revert ERC20InvalidApprover(address(0)); } if (spender == address(0)) { revert ERC20InvalidSpender(address(0)); } _allowances[owner][spender] = value; if (emitEvent) { emit Approval(owner, spender, value); } } /** * @dev Updates `owner` s allowance for `spender` based on spent `value`. * * Does not update the allowance value in case of infinite allowance. * Revert if not enough allowance is available. * * Does not emit an {Approval} event. */ function _spendAllowance(address owner, address spender, uint256 value) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { if (currentAllowance < value) { revert ERC20InsufficientAllowance(spender, currentAllowance, value); } unchecked { _approve(owner, spender, currentAllowance - value, false); } } } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol) pragma solidity ^0.8.20; /** * @dev This is the interface that {BeaconProxy} expects of its beacon. */ interface IBeacon { /** * @dev Must return an address that can be used as a delegate call target. * * {UpgradeableBeacon} will check that this address is a contract. */ function implementation() external view returns (address); }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable2Step.sol) pragma solidity ^0.8.20; import {Ownable} from "./Ownable.sol"; /** * @dev Contract module which provides access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * The initial owner is specified at deployment time in the constructor for `Ownable`. This * can later be changed with {transferOwnership} and {acceptOwnership}. * * This module is used through inheritance. It will make available all functions * from parent (Ownable). */ abstract contract Ownable2Step is Ownable { address private _pendingOwner; event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner); /** * @dev Returns the address of the pending owner. */ function pendingOwner() public view virtual returns (address) { return _pendingOwner; } /** * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual override onlyOwner { _pendingOwner = newOwner; emit OwnershipTransferStarted(owner(), newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner. * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual override { delete _pendingOwner; super._transferOwnership(newOwner); } /** * @dev The new owner accepts the ownership transfer. */ function acceptOwnership() public virtual { address sender = _msgSender(); if (pendingOwner() != sender) { revert OwnableUnauthorizedAccount(sender); } _transferOwnership(sender); } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /// @title FixedPoint128 /// @notice A library for handling binary fixed point numbers, see https://en.wikipedia.org/wiki/Q_(number_format) library FixedPoint128 { uint256 internal constant Q128 = 0x100000000000000000000000000000000; }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.24; import {PoolKey} from "../types/PoolKey.sol"; import {BalanceDelta} from "../types/BalanceDelta.sol"; /// @notice Parameter struct for `ModifyLiquidity` pool operations struct ModifyLiquidityParams { // the lower and upper tick of the position int24 tickLower; int24 tickUpper; // how to modify the liquidity int256 liquidityDelta; // a value to set if you want unique liquidity positions at the same range bytes32 salt; } /// @notice Parameter struct for `Swap` pool operations struct SwapParams { /// Whether to swap token0 for token1 or vice versa bool zeroForOne; /// The desired input amount if negative (exactIn), or the desired output amount if positive (exactOut) int256 amountSpecified; /// The sqrt price at which, if reached, the swap will stop executing uint160 sqrtPriceLimitX96; }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol) pragma solidity ^0.8.20; import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol"; import {Initializable} from "../proxy/utils/Initializable.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * The initial owner is set to the address provided by the deployer. This can * later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { /// @custom:storage-location erc7201:openzeppelin.storage.Ownable struct OwnableStorage { address _owner; } // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300; function _getOwnableStorage() private pure returns (OwnableStorage storage $) { assembly { $.slot := OwnableStorageLocation } } /** * @dev The caller account is not authorized to perform an operation. */ error OwnableUnauthorizedAccount(address account); /** * @dev The owner is not a valid owner account. (eg. `address(0)`) */ error OwnableInvalidOwner(address owner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the address provided by the deployer as the initial owner. */ function __Ownable_init(address initialOwner) internal onlyInitializing { __Ownable_init_unchained(initialOwner); } function __Ownable_init_unchained(address initialOwner) internal onlyInitializing { if (initialOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(initialOwner); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { OwnableStorage storage $ = _getOwnableStorage(); return $._owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { if (owner() != _msgSender()) { revert OwnableUnauthorizedAccount(_msgSender()); } } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { if (newOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { OwnableStorage storage $ = _getOwnableStorage(); address oldOwner = $._owner; $._owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; // Return type of the beforeSwap hook. // Upper 128 bits is the delta in specified tokens. Lower 128 bits is delta in unspecified tokens (to match the afterSwap hook) type BeforeSwapDelta is int256; // Creates a BeforeSwapDelta from specified and unspecified function toBeforeSwapDelta(int128 deltaSpecified, int128 deltaUnspecified) pure returns (BeforeSwapDelta beforeSwapDelta) { assembly ("memory-safe") { beforeSwapDelta := or(shl(128, deltaSpecified), and(sub(shl(128, 1), 1), deltaUnspecified)) } } /// @notice Library for getting the specified and unspecified deltas from the BeforeSwapDelta type library BeforeSwapDeltaLibrary { /// @notice A BeforeSwapDelta of 0 BeforeSwapDelta public constant ZERO_DELTA = BeforeSwapDelta.wrap(0); /// extracts int128 from the upper 128 bits of the BeforeSwapDelta /// returned by beforeSwap function getSpecifiedDelta(BeforeSwapDelta delta) internal pure returns (int128 deltaSpecified) { assembly ("memory-safe") { deltaSpecified := sar(128, delta) } } /// extracts int128 from the lower 128 bits of the BeforeSwapDelta /// returned by beforeSwap and afterSwap function getUnspecifiedDelta(BeforeSwapDelta delta) internal pure returns (int128 deltaUnspecified) { assembly ("memory-safe") { deltaUnspecified := signextend(15, delta) } } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /// @title Contains 512-bit math functions /// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision /// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits library FullMath { /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 /// @param a The multiplicand /// @param b The multiplier /// @param denominator The divisor /// @return result The 256-bit result /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv function mulDiv(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = a * b // Compute the product mod 2**256 and mod 2**256 - 1 // then use the Chinese Remainder Theorem to reconstruct // the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2**256 + prod0 uint256 prod0 = a * b; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly ("memory-safe") { let mm := mulmod(a, b, not(0)) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Make sure the result is less than 2**256. // Also prevents denominator == 0 require(denominator > prod1); // Handle non-overflow cases, 256 by 256 division if (prod1 == 0) { assembly ("memory-safe") { result := div(prod0, denominator) } return result; } /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0] // Compute remainder using mulmod uint256 remainder; assembly ("memory-safe") { remainder := mulmod(a, b, denominator) } // Subtract 256 bit number from 512 bit number assembly ("memory-safe") { prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator // Compute largest power of two divisor of denominator. // Always >= 1. uint256 twos = (0 - denominator) & denominator; // Divide denominator by power of two assembly ("memory-safe") { denominator := div(denominator, twos) } // Divide [prod1 prod0] by the factors of two assembly ("memory-safe") { prod0 := div(prod0, twos) } // Shift in bits from prod1 into prod0. For this we need // to flip `twos` such that it is 2**256 / twos. // If twos is zero, then it becomes one assembly ("memory-safe") { twos := add(div(sub(0, twos), twos), 1) } prod0 |= prod1 * twos; // Invert denominator mod 2**256 // Now that denominator is an odd number, it has an inverse // modulo 2**256 such that denominator * inv = 1 mod 2**256. // Compute the inverse by starting with a seed that is correct // correct for four bits. That is, denominator * inv = 1 mod 2**4 uint256 inv = (3 * denominator) ^ 2; // Now use Newton-Raphson iteration to improve the precision. // Thanks to Hensel's lifting lemma, this also works in modular // arithmetic, doubling the correct bits in each step. inv *= 2 - denominator * inv; // inverse mod 2**8 inv *= 2 - denominator * inv; // inverse mod 2**16 inv *= 2 - denominator * inv; // inverse mod 2**32 inv *= 2 - denominator * inv; // inverse mod 2**64 inv *= 2 - denominator * inv; // inverse mod 2**128 inv *= 2 - denominator * inv; // inverse mod 2**256 // Because the division is now exact we can divide by multiplying // with the modular inverse of denominator. This will give us the // correct result modulo 2**256. Since the preconditions guarantee // that the outcome is less than 2**256, this is the final result. // We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inv; return result; } } /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 /// @param a The multiplicand /// @param b The multiplier /// @param denominator The divisor /// @return result The 256-bit result function mulDivRoundingUp(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) { unchecked { result = mulDiv(a, b, denominator); if (mulmod(a, b, denominator) != 0) { require(++result > 0); } } } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.20; import {IERC20} from "../IERC20.sol"; import {IERC20Permit} from "../extensions/IERC20Permit.sol"; import {Address} from "../../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; /** * @dev An operation with an ERC20 token failed. */ error SafeERC20FailedOperation(address token); /** * @dev Indicates a failed `decreaseAllowance` request. */ error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease); /** * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value))); } /** * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful. */ function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value))); } /** * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 oldAllowance = token.allowance(address(this), spender); forceApprove(token, spender, oldAllowance + value); } /** * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no * value, non-reverting calls are assumed to be successful. */ function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal { unchecked { uint256 currentAllowance = token.allowance(address(this), spender); if (currentAllowance < requestedDecrease) { revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease); } forceApprove(token, spender, currentAllowance - requestedDecrease); } } /** * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval * to be set to zero before setting it to a non-zero value, such as USDT. */ function forceApprove(IERC20 token, address spender, uint256 value) internal { bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value)); if (!_callOptionalReturnBool(token, approvalCall)) { _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0))); _callOptionalReturn(token, approvalCall); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data); if (returndata.length != 0 && !abi.decode(returndata, (bool))) { revert SafeERC20FailedOperation(address(token)); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). * * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead. */ function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false // and not revert is the subcall reverts. (bool success, bytes memory returndata) = address(token).call(data); return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0; } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.24; import {Currency} from "../types/Currency.sol"; import {PoolKey} from "../types/PoolKey.sol"; import {IHooks} from "./IHooks.sol"; import {IERC6909Claims} from "./external/IERC6909Claims.sol"; import {IProtocolFees} from "./IProtocolFees.sol"; import {BalanceDelta} from "../types/BalanceDelta.sol"; import {PoolId} from "../types/PoolId.sol"; import {IExtsload} from "./IExtsload.sol"; import {IExttload} from "./IExttload.sol"; import {ModifyLiquidityParams, SwapParams} from "../types/PoolOperation.sol"; /// @notice Interface for the PoolManager interface IPoolManager is IProtocolFees, IERC6909Claims, IExtsload, IExttload { /// @notice Thrown when a currency is not netted out after the contract is unlocked error CurrencyNotSettled(); /// @notice Thrown when trying to interact with a non-initialized pool error PoolNotInitialized(); /// @notice Thrown when unlock is called, but the contract is already unlocked error AlreadyUnlocked(); /// @notice Thrown when a function is called that requires the contract to be unlocked, but it is not error ManagerLocked(); /// @notice Pools are limited to type(int16).max tickSpacing in #initialize, to prevent overflow error TickSpacingTooLarge(int24 tickSpacing); /// @notice Pools must have a positive non-zero tickSpacing passed to #initialize error TickSpacingTooSmall(int24 tickSpacing); /// @notice PoolKey must have currencies where address(currency0) < address(currency1) error CurrenciesOutOfOrderOrEqual(address currency0, address currency1); /// @notice Thrown when a call to updateDynamicLPFee is made by an address that is not the hook, /// or on a pool that does not have a dynamic swap fee. error UnauthorizedDynamicLPFeeUpdate(); /// @notice Thrown when trying to swap amount of 0 error SwapAmountCannotBeZero(); ///@notice Thrown when native currency is passed to a non native settlement error NonzeroNativeValue(); /// @notice Thrown when `clear` is called with an amount that is not exactly equal to the open currency delta. error MustClearExactPositiveDelta(); /// @notice Emitted when a new pool is initialized /// @param id The abi encoded hash of the pool key struct for the new pool /// @param currency0 The first currency of the pool by address sort order /// @param currency1 The second currency of the pool by address sort order /// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip /// @param tickSpacing The minimum number of ticks between initialized ticks /// @param hooks The hooks contract address for the pool, or address(0) if none /// @param sqrtPriceX96 The price of the pool on initialization /// @param tick The initial tick of the pool corresponding to the initialized price event Initialize( PoolId indexed id, Currency indexed currency0, Currency indexed currency1, uint24 fee, int24 tickSpacing, IHooks hooks, uint160 sqrtPriceX96, int24 tick ); /// @notice Emitted when a liquidity position is modified /// @param id The abi encoded hash of the pool key struct for the pool that was modified /// @param sender The address that modified the pool /// @param tickLower The lower tick of the position /// @param tickUpper The upper tick of the position /// @param liquidityDelta The amount of liquidity that was added or removed /// @param salt The extra data to make positions unique event ModifyLiquidity( PoolId indexed id, address indexed sender, int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt ); /// @notice Emitted for swaps between currency0 and currency1 /// @param id The abi encoded hash of the pool key struct for the pool that was modified /// @param sender The address that initiated the swap call, and that received the callback /// @param amount0 The delta of the currency0 balance of the pool /// @param amount1 The delta of the currency1 balance of the pool /// @param sqrtPriceX96 The sqrt(price) of the pool after the swap, as a Q64.96 /// @param liquidity The liquidity of the pool after the swap /// @param tick The log base 1.0001 of the price of the pool after the swap /// @param fee The swap fee in hundredths of a bip event Swap( PoolId indexed id, address indexed sender, int128 amount0, int128 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint24 fee ); /// @notice Emitted for donations /// @param id The abi encoded hash of the pool key struct for the pool that was donated to /// @param sender The address that initiated the donate call /// @param amount0 The amount donated in currency0 /// @param amount1 The amount donated in currency1 event Donate(PoolId indexed id, address indexed sender, uint256 amount0, uint256 amount1); /// @notice All interactions on the contract that account deltas require unlocking. A caller that calls `unlock` must implement /// `IUnlockCallback(msg.sender).unlockCallback(data)`, where they interact with the remaining functions on this contract. /// @dev The only functions callable without an unlocking are `initialize` and `updateDynamicLPFee` /// @param data Any data to pass to the callback, via `IUnlockCallback(msg.sender).unlockCallback(data)` /// @return The data returned by the call to `IUnlockCallback(msg.sender).unlockCallback(data)` function unlock(bytes calldata data) external returns (bytes memory); /// @notice Initialize the state for a given pool ID /// @dev A swap fee totaling MAX_SWAP_FEE (100%) makes exact output swaps impossible since the input is entirely consumed by the fee /// @param key The pool key for the pool to initialize /// @param sqrtPriceX96 The initial square root price /// @return tick The initial tick of the pool function initialize(PoolKey memory key, uint160 sqrtPriceX96) external returns (int24 tick); /// @notice Modify the liquidity for the given pool /// @dev Poke by calling with a zero liquidityDelta /// @param key The pool to modify liquidity in /// @param params The parameters for modifying the liquidity /// @param hookData The data to pass through to the add/removeLiquidity hooks /// @return callerDelta The balance delta of the caller of modifyLiquidity. This is the total of both principal, fee deltas, and hook deltas if applicable /// @return feesAccrued The balance delta of the fees generated in the liquidity range. Returned for informational purposes /// @dev Note that feesAccrued can be artificially inflated by a malicious actor and integrators should be careful using the value /// For pools with a single liquidity position, actors can donate to themselves to inflate feeGrowthGlobal (and consequently feesAccrued) /// atomically donating and collecting fees in the same unlockCallback may make the inflated value more extreme function modifyLiquidity(PoolKey memory key, ModifyLiquidityParams memory params, bytes calldata hookData) external returns (BalanceDelta callerDelta, BalanceDelta feesAccrued); /// @notice Swap against the given pool /// @param key The pool to swap in /// @param params The parameters for swapping /// @param hookData The data to pass through to the swap hooks /// @return swapDelta The balance delta of the address swapping /// @dev Swapping on low liquidity pools may cause unexpected swap amounts when liquidity available is less than amountSpecified. /// Additionally note that if interacting with hooks that have the BEFORE_SWAP_RETURNS_DELTA_FLAG or AFTER_SWAP_RETURNS_DELTA_FLAG /// the hook may alter the swap input/output. Integrators should perform checks on the returned swapDelta. function swap(PoolKey memory key, SwapParams memory params, bytes calldata hookData) external returns (BalanceDelta swapDelta); /// @notice Donate the given currency amounts to the in-range liquidity providers of a pool /// @dev Calls to donate can be frontrun adding just-in-time liquidity, with the aim of receiving a portion donated funds. /// Donors should keep this in mind when designing donation mechanisms. /// @dev This function donates to in-range LPs at slot0.tick. In certain edge-cases of the swap algorithm, the `sqrtPrice` of /// a pool can be at the lower boundary of tick `n`, but the `slot0.tick` of the pool is already `n - 1`. In this case a call to /// `donate` would donate to tick `n - 1` (slot0.tick) not tick `n` (getTickAtSqrtPrice(slot0.sqrtPriceX96)). /// Read the comments in `Pool.swap()` for more information about this. /// @param key The key of the pool to donate to /// @param amount0 The amount of currency0 to donate /// @param amount1 The amount of currency1 to donate /// @param hookData The data to pass through to the donate hooks /// @return BalanceDelta The delta of the caller after the donate function donate(PoolKey memory key, uint256 amount0, uint256 amount1, bytes calldata hookData) external returns (BalanceDelta); /// @notice Writes the current ERC20 balance of the specified currency to transient storage /// This is used to checkpoint balances for the manager and derive deltas for the caller. /// @dev This MUST be called before any ERC20 tokens are sent into the contract, but can be skipped /// for native tokens because the amount to settle is determined by the sent value. /// However, if an ERC20 token has been synced and not settled, and the caller instead wants to settle /// native funds, this function can be called with the native currency to then be able to settle the native currency function sync(Currency currency) external; /// @notice Called by the user to net out some value owed to the user /// @dev Will revert if the requested amount is not available, consider using `mint` instead /// @dev Can also be used as a mechanism for free flash loans /// @param currency The currency to withdraw from the pool manager /// @param to The address to withdraw to /// @param amount The amount of currency to withdraw function take(Currency currency, address to, uint256 amount) external; /// @notice Called by the user to pay what is owed /// @return paid The amount of currency settled function settle() external payable returns (uint256 paid); /// @notice Called by the user to pay on behalf of another address /// @param recipient The address to credit for the payment /// @return paid The amount of currency settled function settleFor(address recipient) external payable returns (uint256 paid); /// @notice WARNING - Any currency that is cleared, will be non-retrievable, and locked in the contract permanently. /// A call to clear will zero out a positive balance WITHOUT a corresponding transfer. /// @dev This could be used to clear a balance that is considered dust. /// Additionally, the amount must be the exact positive balance. This is to enforce that the caller is aware of the amount being cleared. function clear(Currency currency, uint256 amount) external; /// @notice Called by the user to move value into ERC6909 balance /// @param to The address to mint the tokens to /// @param id The currency address to mint to ERC6909s, as a uint256 /// @param amount The amount of currency to mint /// @dev The id is converted to a uint160 to correspond to a currency address /// If the upper 12 bytes are not 0, they will be 0-ed out function mint(address to, uint256 id, uint256 amount) external; /// @notice Called by the user to move value from ERC6909 balance /// @param from The address to burn the tokens from /// @param id The currency address to burn from ERC6909s, as a uint256 /// @param amount The amount of currency to burn /// @dev The id is converted to a uint160 to correspond to a currency address /// If the upper 12 bytes are not 0, they will be 0-ed out function burn(address from, uint256 id, uint256 amount) external; /// @notice Updates the pools lp fees for the a pool that has enabled dynamic lp fees. /// @dev A swap fee totaling MAX_SWAP_FEE (100%) makes exact output swaps impossible since the input is entirely consumed by the fee /// @param key The key of the pool to update dynamic LP fees for /// @param newDynamicLPFee The new dynamic pool LP fee function updateDynamicLPFee(PoolKey memory key, uint24 newDynamicLPFee) external; }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {PoolId} from "../types/PoolId.sol"; import {IPoolManager} from "../interfaces/IPoolManager.sol"; import {Position} from "./Position.sol"; /// @notice A helper library to provide state getters that use extsload library StateLibrary { /// @notice index of pools mapping in the PoolManager bytes32 public constant POOLS_SLOT = bytes32(uint256(6)); /// @notice index of feeGrowthGlobal0X128 in Pool.State uint256 public constant FEE_GROWTH_GLOBAL0_OFFSET = 1; // feeGrowthGlobal1X128 offset in Pool.State = 2 /// @notice index of liquidity in Pool.State uint256 public constant LIQUIDITY_OFFSET = 3; /// @notice index of TicksInfo mapping in Pool.State: mapping(int24 => TickInfo) ticks; uint256 public constant TICKS_OFFSET = 4; /// @notice index of tickBitmap mapping in Pool.State uint256 public constant TICK_BITMAP_OFFSET = 5; /// @notice index of Position.State mapping in Pool.State: mapping(bytes32 => Position.State) positions; uint256 public constant POSITIONS_OFFSET = 6; /** * @notice Get Slot0 of the pool: sqrtPriceX96, tick, protocolFee, lpFee * @dev Corresponds to pools[poolId].slot0 * @param manager The pool manager contract. * @param poolId The ID of the pool. * @return sqrtPriceX96 The square root of the price of the pool, in Q96 precision. * @return tick The current tick of the pool. * @return protocolFee The protocol fee of the pool. * @return lpFee The swap fee of the pool. */ function getSlot0(IPoolManager manager, PoolId poolId) internal view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee) { // slot key of Pool.State value: `pools[poolId]` bytes32 stateSlot = _getPoolStateSlot(poolId); bytes32 data = manager.extsload(stateSlot); // 24 bits |24bits|24bits |24 bits|160 bits // 0x000000 |000bb8|000000 |ffff75 |0000000000000000fe3aa841ba359daa0ea9eff7 // ---------- | fee |protocolfee | tick | sqrtPriceX96 assembly ("memory-safe") { // bottom 160 bits of data sqrtPriceX96 := and(data, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) // next 24 bits of data tick := signextend(2, shr(160, data)) // next 24 bits of data protocolFee := and(shr(184, data), 0xFFFFFF) // last 24 bits of data lpFee := and(shr(208, data), 0xFFFFFF) } } /** * @notice Retrieves the tick information of a pool at a specific tick. * @dev Corresponds to pools[poolId].ticks[tick] * @param manager The pool manager contract. * @param poolId The ID of the pool. * @param tick The tick to retrieve information for. * @return liquidityGross The total position liquidity that references this tick * @return liquidityNet The amount of net liquidity added (subtracted) when tick is crossed from left to right (right to left) * @return feeGrowthOutside0X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick) * @return feeGrowthOutside1X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick) */ function getTickInfo(IPoolManager manager, PoolId poolId, int24 tick) internal view returns ( uint128 liquidityGross, int128 liquidityNet, uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128 ) { bytes32 slot = _getTickInfoSlot(poolId, tick); // read all 3 words of the TickInfo struct bytes32[] memory data = manager.extsload(slot, 3); assembly ("memory-safe") { let firstWord := mload(add(data, 32)) liquidityNet := sar(128, firstWord) liquidityGross := and(firstWord, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) feeGrowthOutside0X128 := mload(add(data, 64)) feeGrowthOutside1X128 := mload(add(data, 96)) } } /** * @notice Retrieves the liquidity information of a pool at a specific tick. * @dev Corresponds to pools[poolId].ticks[tick].liquidityGross and pools[poolId].ticks[tick].liquidityNet. A more gas efficient version of getTickInfo * @param manager The pool manager contract. * @param poolId The ID of the pool. * @param tick The tick to retrieve liquidity for. * @return liquidityGross The total position liquidity that references this tick * @return liquidityNet The amount of net liquidity added (subtracted) when tick is crossed from left to right (right to left) */ function getTickLiquidity(IPoolManager manager, PoolId poolId, int24 tick) internal view returns (uint128 liquidityGross, int128 liquidityNet) { bytes32 slot = _getTickInfoSlot(poolId, tick); bytes32 value = manager.extsload(slot); assembly ("memory-safe") { liquidityNet := sar(128, value) liquidityGross := and(value, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) } } /** * @notice Retrieves the fee growth outside a tick range of a pool * @dev Corresponds to pools[poolId].ticks[tick].feeGrowthOutside0X128 and pools[poolId].ticks[tick].feeGrowthOutside1X128. A more gas efficient version of getTickInfo * @param manager The pool manager contract. * @param poolId The ID of the pool. * @param tick The tick to retrieve fee growth for. * @return feeGrowthOutside0X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick) * @return feeGrowthOutside1X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick) */ function getTickFeeGrowthOutside(IPoolManager manager, PoolId poolId, int24 tick) internal view returns (uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128) { bytes32 slot = _getTickInfoSlot(poolId, tick); // offset by 1 word, since the first word is liquidityGross + liquidityNet bytes32[] memory data = manager.extsload(bytes32(uint256(slot) + 1), 2); assembly ("memory-safe") { feeGrowthOutside0X128 := mload(add(data, 32)) feeGrowthOutside1X128 := mload(add(data, 64)) } } /** * @notice Retrieves the global fee growth of a pool. * @dev Corresponds to pools[poolId].feeGrowthGlobal0X128 and pools[poolId].feeGrowthGlobal1X128 * @param manager The pool manager contract. * @param poolId The ID of the pool. * @return feeGrowthGlobal0 The global fee growth for token0. * @return feeGrowthGlobal1 The global fee growth for token1. * @dev Note that feeGrowthGlobal can be artificially inflated * For pools with a single liquidity position, actors can donate to themselves to freely inflate feeGrowthGlobal * atomically donating and collecting fees in the same unlockCallback may make the inflated value more extreme */ function getFeeGrowthGlobals(IPoolManager manager, PoolId poolId) internal view returns (uint256 feeGrowthGlobal0, uint256 feeGrowthGlobal1) { // slot key of Pool.State value: `pools[poolId]` bytes32 stateSlot = _getPoolStateSlot(poolId); // Pool.State, `uint256 feeGrowthGlobal0X128` bytes32 slot_feeGrowthGlobal0X128 = bytes32(uint256(stateSlot) + FEE_GROWTH_GLOBAL0_OFFSET); // read the 2 words of feeGrowthGlobal bytes32[] memory data = manager.extsload(slot_feeGrowthGlobal0X128, 2); assembly ("memory-safe") { feeGrowthGlobal0 := mload(add(data, 32)) feeGrowthGlobal1 := mload(add(data, 64)) } } /** * @notice Retrieves total the liquidity of a pool. * @dev Corresponds to pools[poolId].liquidity * @param manager The pool manager contract. * @param poolId The ID of the pool. * @return liquidity The liquidity of the pool. */ function getLiquidity(IPoolManager manager, PoolId poolId) internal view returns (uint128 liquidity) { // slot key of Pool.State value: `pools[poolId]` bytes32 stateSlot = _getPoolStateSlot(poolId); // Pool.State: `uint128 liquidity` bytes32 slot = bytes32(uint256(stateSlot) + LIQUIDITY_OFFSET); liquidity = uint128(uint256(manager.extsload(slot))); } /** * @notice Retrieves the tick bitmap of a pool at a specific tick. * @dev Corresponds to pools[poolId].tickBitmap[tick] * @param manager The pool manager contract. * @param poolId The ID of the pool. * @param tick The tick to retrieve the bitmap for. * @return tickBitmap The bitmap of the tick. */ function getTickBitmap(IPoolManager manager, PoolId poolId, int16 tick) internal view returns (uint256 tickBitmap) { // slot key of Pool.State value: `pools[poolId]` bytes32 stateSlot = _getPoolStateSlot(poolId); // Pool.State: `mapping(int16 => uint256) tickBitmap;` bytes32 tickBitmapMapping = bytes32(uint256(stateSlot) + TICK_BITMAP_OFFSET); // slot id of the mapping key: `pools[poolId].tickBitmap[tick] bytes32 slot = keccak256(abi.encodePacked(int256(tick), tickBitmapMapping)); tickBitmap = uint256(manager.extsload(slot)); } /** * @notice Retrieves the position information of a pool without needing to calculate the `positionId`. * @dev Corresponds to pools[poolId].positions[positionId] * @param poolId The ID of the pool. * @param owner The owner of the liquidity position. * @param tickLower The lower tick of the liquidity range. * @param tickUpper The upper tick of the liquidity range. * @param salt The bytes32 randomness to further distinguish position state. * @return liquidity The liquidity of the position. * @return feeGrowthInside0LastX128 The fee growth inside the position for token0. * @return feeGrowthInside1LastX128 The fee growth inside the position for token1. */ function getPositionInfo( IPoolManager manager, PoolId poolId, address owner, int24 tickLower, int24 tickUpper, bytes32 salt ) internal view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128) { // positionKey = keccak256(abi.encodePacked(owner, tickLower, tickUpper, salt)) bytes32 positionKey = Position.calculatePositionKey(owner, tickLower, tickUpper, salt); (liquidity, feeGrowthInside0LastX128, feeGrowthInside1LastX128) = getPositionInfo(manager, poolId, positionKey); } /** * @notice Retrieves the position information of a pool at a specific position ID. * @dev Corresponds to pools[poolId].positions[positionId] * @param manager The pool manager contract. * @param poolId The ID of the pool. * @param positionId The ID of the position. * @return liquidity The liquidity of the position. * @return feeGrowthInside0LastX128 The fee growth inside the position for token0. * @return feeGrowthInside1LastX128 The fee growth inside the position for token1. */ function getPositionInfo(IPoolManager manager, PoolId poolId, bytes32 positionId) internal view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128) { bytes32 slot = _getPositionInfoSlot(poolId, positionId); // read all 3 words of the Position.State struct bytes32[] memory data = manager.extsload(slot, 3); assembly ("memory-safe") { liquidity := mload(add(data, 32)) feeGrowthInside0LastX128 := mload(add(data, 64)) feeGrowthInside1LastX128 := mload(add(data, 96)) } } /** * @notice Retrieves the liquidity of a position. * @dev Corresponds to pools[poolId].positions[positionId].liquidity. More gas efficient for just retrieiving liquidity as compared to getPositionInfo * @param manager The pool manager contract. * @param poolId The ID of the pool. * @param positionId The ID of the position. * @return liquidity The liquidity of the position. */ function getPositionLiquidity(IPoolManager manager, PoolId poolId, bytes32 positionId) internal view returns (uint128 liquidity) { bytes32 slot = _getPositionInfoSlot(poolId, positionId); liquidity = uint128(uint256(manager.extsload(slot))); } /** * @notice Calculate the fee growth inside a tick range of a pool * @dev pools[poolId].feeGrowthInside0LastX128 in Position.State is cached and can become stale. This function will calculate the up to date feeGrowthInside * @param manager The pool manager contract. * @param poolId The ID of the pool. * @param tickLower The lower tick of the range. * @param tickUpper The upper tick of the range. * @return feeGrowthInside0X128 The fee growth inside the tick range for token0. * @return feeGrowthInside1X128 The fee growth inside the tick range for token1. */ function getFeeGrowthInside(IPoolManager manager, PoolId poolId, int24 tickLower, int24 tickUpper) internal view returns (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) { (uint256 feeGrowthGlobal0X128, uint256 feeGrowthGlobal1X128) = getFeeGrowthGlobals(manager, poolId); (uint256 lowerFeeGrowthOutside0X128, uint256 lowerFeeGrowthOutside1X128) = getTickFeeGrowthOutside(manager, poolId, tickLower); (uint256 upperFeeGrowthOutside0X128, uint256 upperFeeGrowthOutside1X128) = getTickFeeGrowthOutside(manager, poolId, tickUpper); (, int24 tickCurrent,,) = getSlot0(manager, poolId); unchecked { if (tickCurrent < tickLower) { feeGrowthInside0X128 = lowerFeeGrowthOutside0X128 - upperFeeGrowthOutside0X128; feeGrowthInside1X128 = lowerFeeGrowthOutside1X128 - upperFeeGrowthOutside1X128; } else if (tickCurrent >= tickUpper) { feeGrowthInside0X128 = upperFeeGrowthOutside0X128 - lowerFeeGrowthOutside0X128; feeGrowthInside1X128 = upperFeeGrowthOutside1X128 - lowerFeeGrowthOutside1X128; } else { feeGrowthInside0X128 = feeGrowthGlobal0X128 - lowerFeeGrowthOutside0X128 - upperFeeGrowthOutside0X128; feeGrowthInside1X128 = feeGrowthGlobal1X128 - lowerFeeGrowthOutside1X128 - upperFeeGrowthOutside1X128; } } } function _getPoolStateSlot(PoolId poolId) internal pure returns (bytes32) { return keccak256(abi.encodePacked(PoolId.unwrap(poolId), POOLS_SLOT)); } function _getTickInfoSlot(PoolId poolId, int24 tick) internal pure returns (bytes32) { // slot key of Pool.State value: `pools[poolId]` bytes32 stateSlot = _getPoolStateSlot(poolId); // Pool.State: `mapping(int24 => TickInfo) ticks` bytes32 ticksMappingSlot = bytes32(uint256(stateSlot) + TICKS_OFFSET); // slot key of the tick key: `pools[poolId].ticks[tick] return keccak256(abi.encodePacked(int256(tick), ticksMappingSlot)); } function _getPositionInfoSlot(PoolId poolId, bytes32 positionId) internal pure returns (bytes32) { // slot key of Pool.State value: `pools[poolId]` bytes32 stateSlot = _getPoolStateSlot(poolId); // Pool.State: `mapping(bytes32 => Position.State) positions;` bytes32 positionMapping = bytes32(uint256(stateSlot) + POSITIONS_OFFSET); // slot of the mapping key: `pools[poolId].positions[positionId] return keccak256(abi.encodePacked(positionId, positionMapping)); } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol) pragma solidity ^0.8.20; import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol"; import {Initializable} from "../proxy/utils/Initializable.sol"; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract PausableUpgradeable is Initializable, ContextUpgradeable { /// @custom:storage-location erc7201:openzeppelin.storage.Pausable struct PausableStorage { bool _paused; } // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Pausable")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300; function _getPausableStorage() private pure returns (PausableStorage storage $) { assembly { $.slot := PausableStorageLocation } } /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); /** * @dev The operation failed because the contract is paused. */ error EnforcedPause(); /** * @dev The operation failed because the contract is not paused. */ error ExpectedPause(); /** * @dev Initializes the contract in unpaused state. */ function __Pausable_init() internal onlyInitializing { __Pausable_init_unchained(); } function __Pausable_init_unchained() internal onlyInitializing { PausableStorage storage $ = _getPausableStorage(); $._paused = false; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { _requireNotPaused(); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { _requirePaused(); _; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { PausableStorage storage $ = _getPausableStorage(); return $._paused; } /** * @dev Throws if the contract is paused. */ function _requireNotPaused() internal view virtual { if (paused()) { revert EnforcedPause(); } } /** * @dev Throws if the contract is not paused. */ function _requirePaused() internal view virtual { if (!paused()) { revert ExpectedPause(); } } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { PausableStorage storage $ = _getPausableStorage(); $._paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { PausableStorage storage $ = _getPausableStorage(); $._paused = false; emit Unpaused(_msgSender()); } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {PoolKey} from "./PoolKey.sol"; type PoolId is bytes32; /// @notice Library for computing the ID of a pool library PoolIdLibrary { /// @notice Returns value equal to keccak256(abi.encode(poolKey)) function toId(PoolKey memory poolKey) internal pure returns (PoolId poolId) { assembly ("memory-safe") { // 0xa0 represents the total size of the poolKey struct (5 slots of 32 bytes) poolId := keccak256(poolKey, 0xa0) } } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /// @notice Interface for claims over a contract balance, wrapped as a ERC6909 interface IERC6909Claims { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event OperatorSet(address indexed owner, address indexed operator, bool approved); event Approval(address indexed owner, address indexed spender, uint256 indexed id, uint256 amount); event Transfer(address caller, address indexed from, address indexed to, uint256 indexed id, uint256 amount); /*////////////////////////////////////////////////////////////// FUNCTIONS //////////////////////////////////////////////////////////////*/ /// @notice Owner balance of an id. /// @param owner The address of the owner. /// @param id The id of the token. /// @return amount The balance of the token. function balanceOf(address owner, uint256 id) external view returns (uint256 amount); /// @notice Spender allowance of an id. /// @param owner The address of the owner. /// @param spender The address of the spender. /// @param id The id of the token. /// @return amount The allowance of the token. function allowance(address owner, address spender, uint256 id) external view returns (uint256 amount); /// @notice Checks if a spender is approved by an owner as an operator /// @param owner The address of the owner. /// @param spender The address of the spender. /// @return approved The approval status. function isOperator(address owner, address spender) external view returns (bool approved); /// @notice Transfers an amount of an id from the caller to a receiver. /// @param receiver The address of the receiver. /// @param id The id of the token. /// @param amount The amount of the token. /// @return bool True, always, unless the function reverts function transfer(address receiver, uint256 id, uint256 amount) external returns (bool); /// @notice Transfers an amount of an id from a sender to a receiver. /// @param sender The address of the sender. /// @param receiver The address of the receiver. /// @param id The id of the token. /// @param amount The amount of the token. /// @return bool True, always, unless the function reverts function transferFrom(address sender, address receiver, uint256 id, uint256 amount) external returns (bool); /// @notice Approves an amount of an id to a spender. /// @param spender The address of the spender. /// @param id The id of the token. /// @param amount The amount of the token. /// @return bool True, always function approve(address spender, uint256 id, uint256 amount) external returns (bool); /// @notice Sets or removes an operator for the caller. /// @param operator The address of the operator. /// @param approved The approval status. /// @return bool True, always function setOperator(address operator, bool approved) external returns (bool); }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /// @title Library for reverting with custom errors efficiently /// @notice Contains functions for reverting with custom errors with different argument types efficiently /// @dev To use this library, declare `using CustomRevert for bytes4;` and replace `revert CustomError()` with /// `CustomError.selector.revertWith()` /// @dev The functions may tamper with the free memory pointer but it is fine since the call context is exited immediately library CustomRevert { /// @dev ERC-7751 error for wrapping bubbled up reverts error WrappedError(address target, bytes4 selector, bytes reason, bytes details); /// @dev Reverts with the selector of a custom error in the scratch space function revertWith(bytes4 selector) internal pure { assembly ("memory-safe") { mstore(0, selector) revert(0, 0x04) } } /// @dev Reverts with a custom error with an address argument in the scratch space function revertWith(bytes4 selector, address addr) internal pure { assembly ("memory-safe") { mstore(0, selector) mstore(0x04, and(addr, 0xffffffffffffffffffffffffffffffffffffffff)) revert(0, 0x24) } } /// @dev Reverts with a custom error with an int24 argument in the scratch space function revertWith(bytes4 selector, int24 value) internal pure { assembly ("memory-safe") { mstore(0, selector) mstore(0x04, signextend(2, value)) revert(0, 0x24) } } /// @dev Reverts with a custom error with a uint160 argument in the scratch space function revertWith(bytes4 selector, uint160 value) internal pure { assembly ("memory-safe") { mstore(0, selector) mstore(0x04, and(value, 0xffffffffffffffffffffffffffffffffffffffff)) revert(0, 0x24) } } /// @dev Reverts with a custom error with two int24 arguments function revertWith(bytes4 selector, int24 value1, int24 value2) internal pure { assembly ("memory-safe") { let fmp := mload(0x40) mstore(fmp, selector) mstore(add(fmp, 0x04), signextend(2, value1)) mstore(add(fmp, 0x24), signextend(2, value2)) revert(fmp, 0x44) } } /// @dev Reverts with a custom error with two uint160 arguments function revertWith(bytes4 selector, uint160 value1, uint160 value2) internal pure { assembly ("memory-safe") { let fmp := mload(0x40) mstore(fmp, selector) mstore(add(fmp, 0x04), and(value1, 0xffffffffffffffffffffffffffffffffffffffff)) mstore(add(fmp, 0x24), and(value2, 0xffffffffffffffffffffffffffffffffffffffff)) revert(fmp, 0x44) } } /// @dev Reverts with a custom error with two address arguments function revertWith(bytes4 selector, address value1, address value2) internal pure { assembly ("memory-safe") { let fmp := mload(0x40) mstore(fmp, selector) mstore(add(fmp, 0x04), and(value1, 0xffffffffffffffffffffffffffffffffffffffff)) mstore(add(fmp, 0x24), and(value2, 0xffffffffffffffffffffffffffffffffffffffff)) revert(fmp, 0x44) } } /// @notice bubble up the revert message returned by a call and revert with a wrapped ERC-7751 error /// @dev this method can be vulnerable to revert data bombs function bubbleUpAndRevertWith( address revertingContract, bytes4 revertingFunctionSelector, bytes4 additionalContext ) internal pure { bytes4 wrappedErrorSelector = WrappedError.selector; assembly ("memory-safe") { // Ensure the size of the revert data is a multiple of 32 bytes let encodedDataSize := mul(div(add(returndatasize(), 31), 32), 32) let fmp := mload(0x40) // Encode wrapped error selector, address, function selector, offset, additional context, size, revert reason mstore(fmp, wrappedErrorSelector) mstore(add(fmp, 0x04), and(revertingContract, 0xffffffffffffffffffffffffffffffffffffffff)) mstore( add(fmp, 0x24), and(revertingFunctionSelector, 0xffffffff00000000000000000000000000000000000000000000000000000000) ) // offset revert reason mstore(add(fmp, 0x44), 0x80) // offset additional context mstore(add(fmp, 0x64), add(0xa0, encodedDataSize)) // size revert reason mstore(add(fmp, 0x84), returndatasize()) // revert reason returndatacopy(add(fmp, 0xa4), 0, returndatasize()) // size additional context mstore(add(fmp, add(0xa4, encodedDataSize)), 0x04) // additional context mstore( add(fmp, add(0xc4, encodedDataSize)), and(additionalContext, 0xffffffff00000000000000000000000000000000000000000000000000000000) ) revert(fmp, add(0xe4, encodedDataSize)) } } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol) // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. pragma solidity ^0.8.20; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ```solidity * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(newImplementation.code.length > 0); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` */ library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } /** * @dev Returns an `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.20; import {IERC20} from "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {CustomRevert} from "./CustomRevert.sol"; /// @title Safe casting methods /// @notice Contains methods for safely casting between types library SafeCast { using CustomRevert for bytes4; error SafeCastOverflow(); /// @notice Cast a uint256 to a uint160, revert on overflow /// @param x The uint256 to be downcasted /// @return y The downcasted integer, now type uint160 function toUint160(uint256 x) internal pure returns (uint160 y) { y = uint160(x); if (y != x) SafeCastOverflow.selector.revertWith(); } /// @notice Cast a uint256 to a uint128, revert on overflow /// @param x The uint256 to be downcasted /// @return y The downcasted integer, now type uint128 function toUint128(uint256 x) internal pure returns (uint128 y) { y = uint128(x); if (x != y) SafeCastOverflow.selector.revertWith(); } /// @notice Cast a int128 to a uint128, revert on overflow or underflow /// @param x The int128 to be casted /// @return y The casted integer, now type uint128 function toUint128(int128 x) internal pure returns (uint128 y) { if (x < 0) SafeCastOverflow.selector.revertWith(); y = uint128(x); } /// @notice Cast a int256 to a int128, revert on overflow or underflow /// @param x The int256 to be downcasted /// @return y The downcasted integer, now type int128 function toInt128(int256 x) internal pure returns (int128 y) { y = int128(x); if (y != x) SafeCastOverflow.selector.revertWith(); } /// @notice Cast a uint256 to a int256, revert on overflow /// @param x The uint256 to be casted /// @return y The casted integer, now type int256 function toInt256(uint256 x) internal pure returns (int256 y) { y = int256(x); if (y < 0) SafeCastOverflow.selector.revertWith(); } /// @notice Cast a uint256 to a int128, revert on overflow /// @param x The uint256 to be downcasted /// @return The downcasted integer, now type int128 function toInt128(uint256 x) internal pure returns (int128) { if (x >= 1 << 127) SafeCastOverflow.selector.revertWith(); return int128(int256(x)); } }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {RobinhoodArenaPairTokenManager} from "../arena-pair/RobinhoodArenaPairTokenManager.sol"; /// @notice Arena Prism bonding manager for one approved ERC-20 numeraire. /// @dev Each approved RWA receives a separate proxy backed by an implementation /// constructed with that RWA as `pairToken_`. This deliberately preserves /// the battle-tested WARENA curve, fee, whitelist, and v4 graduation flow /// while isolating configuration and reserves between numeraires. contract RobinhoodPrismTokenManager is RobinhoodArenaPairTokenManager { constructor(address pairToken_, address stakerRewardTokenVault_) RobinhoodArenaPairTokenManager(pairToken_, stakerRewardTokenVault_) {} function PAIR_TOKEN() external view returns (address) { return ARENA_ADDRESS; } }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol"; import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol"; import {FixedPoint96} from "@uniswap/v4-core/src/libraries/FixedPoint96.sol"; import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol"; import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol"; import {Currency} from "@uniswap/v4-core/src/types/Currency.sol"; import {IArenaPoolDeployer} from "../robinhood/interfaces/IArenaPoolDeployer.sol"; import { IRobinhoodArenaManagerHelper, IRobinhoodHelperStateView, IRobinhoodNativeManagerHelper } from "./RobinhoodHelperInterfaces.sol"; /// @notice Batched curve and post-graduation market data for Robinhood tokens. contract RobinhoodTokenDataHelper { using PoolIdLibrary for PoolKey; uint256 public constant PRICE_SCALE = 1e18; enum PairKind { NATIVE, ARENA } struct TokenRequest { uint256 tokenId; PairKind pairKind; } struct TokenData { uint256 tokenId; address tokenAddress; address pairedToken; uint256 supply; uint256 pairedReserve; uint256 price; uint256 marketCap; uint128 liquidity; bool lpDeployed; bytes32 poolId; } IRobinhoodNativeManagerHelper public immutable NATIVE_MANAGER; IRobinhoodArenaManagerHelper public immutable ARENA_MANAGER; IRobinhoodHelperStateView public immutable STATE_VIEW; error InvalidDependency(); error UnknownToken(); error InvalidPoolPrice(); constructor( IRobinhoodNativeManagerHelper nativeManager_, IRobinhoodArenaManagerHelper arenaManager_, IRobinhoodHelperStateView stateView_ ) { if ( address(nativeManager_) == address(0) || address(arenaManager_) == address(0) || address(stateView_) == address(0) ) revert InvalidDependency(); NATIVE_MANAGER = nativeManager_; ARENA_MANAGER = arenaManager_; STATE_VIEW = stateView_; } function getTokenData(TokenRequest[] calldata requests) external view returns (TokenData[] memory response) { response = new TokenData[](requests.length); for (uint256 i; i < requests.length; ++i) { response[i] = requests[i].pairKind == PairKind.NATIVE ? _nativeTokenData(requests[i].tokenId) : _arenaTokenData(requests[i].tokenId); } } function _nativeTokenData(uint256 tokenId) internal view returns (TokenData memory data) { IRobinhoodNativeManagerHelper.TokenParameters memory params = NATIVE_MANAGER.getTokenParameters(tokenId); if (params.tokenContractAddress == address(0)) revert UnknownToken(); data.tokenId = tokenId; data.tokenAddress = params.tokenContractAddress; data.pairedToken = NATIVE_MANAGER.WETH_ADDRESS(); data.supply = IERC20(data.tokenAddress).totalSupply(); data.lpDeployed = params.lpDeployed; if (!params.lpDeployed) { data.pairedReserve = NATIVE_MANAGER.tokenBalanceOf(tokenId); data.price = NATIVE_MANAGER.calculateCostWithFees(1, tokenId); } else { IRobinhoodNativeManagerHelper.V4PoolInitParams memory config = NATIVE_MANAGER.getV4PoolInitParams(); (data.price, data.liquidity, data.poolId) = _poolData( data.tokenAddress, data.pairedToken, config.poolInitParams ); } data.marketCap = FullMath.mulDiv(data.price, data.supply, PRICE_SCALE); } function _arenaTokenData(uint256 tokenId) internal view returns (TokenData memory data) { IRobinhoodArenaManagerHelper.TokenParameters memory params = ARENA_MANAGER.getTokenParameters(tokenId); if (params.tokenContractAddress == address(0)) revert UnknownToken(); data.tokenId = tokenId; data.tokenAddress = params.tokenContractAddress; data.pairedToken = ARENA_MANAGER.ARENA_ADDRESS(); data.supply = IERC20(data.tokenAddress).totalSupply(); data.lpDeployed = params.lpDeployed; if (!params.lpDeployed) { data.pairedReserve = ARENA_MANAGER.tokenBalanceOf(tokenId); data.price = ARENA_MANAGER.calculateCostWithFees(1, tokenId); } else { IRobinhoodArenaManagerHelper.V4PoolInitParams memory config = ARENA_MANAGER.getV4PoolInitParams(); (data.price, data.liquidity, data.poolId) = _poolData( data.tokenAddress, data.pairedToken, config.poolInitParams ); } data.marketCap = FullMath.mulDiv(data.price, data.supply, PRICE_SCALE); } function _poolData( address token, address pairedToken, IArenaPoolDeployer.PoolInitParams memory config ) internal view returns (uint256 price, uint128 liquidity, bytes32 poolId) { bool tokenIsCurrency0 = token < pairedToken; PoolKey memory key = PoolKey({ currency0: Currency.wrap(tokenIsCurrency0 ? token : pairedToken), currency1: Currency.wrap(tokenIsCurrency0 ? pairedToken : token), fee: config.fee, tickSpacing: config.tickSpacing, hooks: IHooks(config.hookContract) }); poolId = PoolId.unwrap(key.toId()); (uint160 sqrtPriceX96,,,) = STATE_VIEW.getSlot0(key.toId()); if (sqrtPriceX96 == 0) revert InvalidPoolPrice(); liquidity = STATE_VIEW.getLiquidity(key.toId()); uint256 sqrt = uint256(sqrtPriceX96); if (tokenIsCurrency0) { price = FullMath.mulDiv( sqrt, sqrt * PRICE_SCALE, uint256(FixedPoint96.Q96) ** 2 ); } else { uint256 reciprocalSqrtX96 = FullMath.mulDiv( FixedPoint96.Q96, FixedPoint96.Q96, sqrt ); price = FullMath.mulDiv( reciprocalSqrtX96, reciprocalSqrtX96 * PRICE_SCALE, uint256(FixedPoint96.Q96) ** 2 ); } } }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol"; import {PoolId} from "@uniswap/v4-core/src/types/PoolId.sol"; import {IRobinhoodLaunchToken} from "../robinhood/interfaces/IRobinhoodLaunchToken.sol"; import {IArenaPoolDeployer} from "../robinhood/interfaces/IArenaPoolDeployer.sol"; interface IRobinhoodHelperUniversalRouter { function execute(bytes calldata commands, bytes[] calldata inputs, uint256 deadline) external payable; function poolManager() external view returns (address); } interface IRobinhoodHelperPermit2 { function allowance(address user, address token, address spender) external view returns (uint160 amount, uint48 expiration, uint48 nonce); function approve(address token, address spender, uint160 amount, uint48 expiration) external; } interface IRobinhoodHelperWETH is IERC20 { function deposit() external payable; function withdraw(uint256 amount) external; } interface IRobinhoodNativeManagerHelper { function setNextLaunchHolderRewards(bool enabled) external; struct TokenParameters { uint128 curveScaler; uint16 a; uint8 b; bool lpDeployed; uint8 lpPercentage; uint8 salePercentage; uint8 creatorFeeBasisPoints; address creatorAddress; address pairAddress; address tokenContractAddress; } struct V4PoolInitParams { IArenaPoolDeployer.PoolInitParams poolInitParams; uint16 creatorFeePpm; uint160 invertedStartingPrice; } function tokenIdentifier() external view returns (uint256); function tokenSupply(uint256 tokenId) external view returns (uint256); function tokenBalanceOf(uint256 tokenId) external view returns (uint256); function tokenCreationBuyFeeAmount() external view returns (uint88); function WETH_ADDRESS() external view returns (address); function allowedTotalSupplyWithParameters( uint16 a, uint8 b, uint128 curveScaler, uint256 tokenSplit ) external view returns (uint256); function getMaxTokensForSale(uint256 tokenId) external view returns (uint256); function getTokenParameters(uint256 tokenId) external view returns (TokenParameters memory); function getV4PoolInitParams() external view returns (V4PoolInitParams memory); function calculateCostWithFees(uint256 amountInToken, uint256 tokenId) external view returns (uint256); function calculateCostScaledParametric( uint256 amountInWei, uint256 supplyInWei, uint256 a, uint256 b, uint256 curveScaler ) external pure returns (uint256); function calculateInitialBuyCostScaledParametricWithFees( uint256 amountInWei, uint256 supplyInWei, uint256 a, uint256 b, uint256 curveScaler, uint256 creatorFeeBasisPoints ) external view returns (uint256); function createToken( uint16 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, address tokenCreatorAddress, uint256 tokenSplit, string calldata name, string calldata symbol, uint256 amount, uint256 maxTotalCost, uint256 deadline ) external payable; function createTokenWithWL( uint16 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, address tokenCreatorAddress, uint256 tokenSplit, string calldata name, string calldata symbol, uint256 amount, IRobinhoodLaunchToken.Whitelist calldata whitelist, uint256 maxTotalCost, uint256 deadline ) external payable; } interface IRobinhoodArenaManagerHelper { function setNextLaunchHolderRewards(bool enabled) external; struct TokenParameters { uint128 curveScaler; uint32 a; uint8 b; bool lpDeployed; uint8 lpPercentage; uint8 salePercentage; uint8 creatorFeeBasisPoints; address creatorAddress; address pairAddress; address tokenContractAddress; } struct V4PoolInitParams { IArenaPoolDeployer.PoolInitParams poolInitParams; uint16 creatorFeePpm; uint160 invertedStartingPrice; } function ARENA_ADDRESS() external view returns (address); function tokenIdentifier() external view returns (uint256); function tokenSupply(uint256 tokenId) external view returns (uint256); function tokenBalanceOf(uint256 tokenId) external view returns (uint256); function tokenCreationBuyFeeAmount() external view returns (uint88); function allowedTotalSupplyWithParameters( uint32 a, uint8 b, uint128 curveScaler, uint256 tokenSplit ) external view returns (uint256); function getMaxTokensForSale(uint256 tokenId) external view returns (uint256); function getTokenParameters(uint256 tokenId) external view returns (TokenParameters memory); function getV4PoolInitParams() external view returns (V4PoolInitParams memory); function calculateCostWithFees(uint256 amountInToken, uint256 tokenId) external view returns (uint256); function calculateRewardWithFees(uint256 amountInToken, uint256 tokenId) external view returns (uint256); function calculateCostScaledParametric( uint256 amountInWei, uint256 supplyInWei, uint256 a, uint256 b, uint256 curveScaler ) external pure returns (uint256); function calculateCostScaledParametricWithFees( uint256 amountInWei, uint256 supplyInWei, uint256 a, uint256 b, uint256 curveScaler, uint256 creatorFeeBasisPoints ) external view returns (uint256); function createToken( uint32 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, address tokenCreatorAddress, uint256 tokenSplit, string calldata name, string calldata symbol, uint256 amount ) external; function createTokenWithWL( uint32 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, address tokenCreatorAddress, uint256 tokenSplit, string calldata name, string calldata symbol, uint256 amount, IRobinhoodLaunchToken.Whitelist calldata whitelist ) external; function buyAndCreateLpIfPossibleWithUser( uint256 amount, uint256 tokenId, address user, uint256 maxArenaToSpend ) external; function sellWithUser( uint256 amount, uint256 tokenId, address user, uint256 minArenaToReceive ) external returns (uint256 amountOut); } interface IRobinhoodHelperStateView { function poolManager() external view returns (IPoolManager); function getSlot0(PoolId poolId) external view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee); function getLiquidity(PoolId poolId) external view returns (uint128 liquidity); }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.26; interface IRobinhoodLaunchTokenFactory { function deployToken(string memory name, string memory symbol, uint256 salt) external returns (address token); }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol) pragma solidity ^0.8.20; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. * * ==== Security Considerations * * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be * considered as an intention to spend the allowance in any specific way. The second is that because permits have * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be * generally recommended is: * * ```solidity * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public { * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {} * doThing(..., value); * } * * function doThing(..., uint256 value) public { * token.safeTransferFrom(msg.sender, address(this), value); * ... * } * ``` * * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also * {SafeERC20-safeTransferFrom}). * * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so * contracts should have entry points that don't rely on permit. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. * * CAUTION: See Security Considerations above. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol"; import {PoolId} from "@uniswap/v4-core/src/types/PoolId.sol"; import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol"; import {Position} from "@uniswap/v4-core/src/libraries/Position.sol"; import {IImmutableState} from "../interfaces/IImmutableState.sol"; /// @title IStateView /// @notice Interface for the StateView contract interface IStateView is IImmutableState { /// @notice Get Slot0 of the pool: sqrtPriceX96, tick, protocolFee, lpFee /// @dev Corresponds to pools[poolId].slot0 /// @param poolId The ID of the pool. /// @return sqrtPriceX96 The square root of the price of the pool, in Q96 precision. /// @return tick The current tick of the pool. /// @return protocolFee The protocol fee of the pool. /// @return lpFee The swap fee of the pool. function getSlot0(PoolId poolId) external view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee); /// @notice Retrieves the tick information of a pool at a specific tick. /// @dev Corresponds to pools[poolId].ticks[tick] /// @param poolId The ID of the pool. /// @param tick The tick to retrieve information for. /// @return liquidityGross The total position liquidity that references this tick /// @return liquidityNet The amount of net liquidity added (subtracted) when tick is crossed from left to right (right to left) /// @return feeGrowthOutside0X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick) /// @return feeGrowthOutside1X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick) function getTickInfo(PoolId poolId, int24 tick) external view returns ( uint128 liquidityGross, int128 liquidityNet, uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128 ); /// @notice Retrieves the liquidity information of a pool at a specific tick. /// @dev Corresponds to pools[poolId].ticks[tick].liquidityGross and pools[poolId].ticks[tick].liquidityNet. A more gas efficient version of getTickInfo /// @param poolId The ID of the pool. /// @param tick The tick to retrieve liquidity for. /// @return liquidityGross The total position liquidity that references this tick /// @return liquidityNet The amount of net liquidity added (subtracted) when tick is crossed from left to right (right to left) function getTickLiquidity(PoolId poolId, int24 tick) external view returns (uint128 liquidityGross, int128 liquidityNet); /// @notice Retrieves the fee growth outside a tick range of a pool /// @dev Corresponds to pools[poolId].ticks[tick].feeGrowthOutside0X128 and pools[poolId].ticks[tick].feeGrowthOutside1X128. A more gas efficient version of getTickInfo /// @param poolId The ID of the pool. /// @param tick The tick to retrieve fee growth for. /// @return feeGrowthOutside0X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick) /// @return feeGrowthOutside1X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick) function getTickFeeGrowthOutside(PoolId poolId, int24 tick) external view returns (uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128); /// @notice Retrieves the global fee growth of a pool. /// @dev Corresponds to pools[poolId].feeGrowthGlobal0X128 and pools[poolId].feeGrowthGlobal1X128 /// @param poolId The ID of the pool. /// @return feeGrowthGlobal0 The global fee growth for token0. /// @return feeGrowthGlobal1 The global fee growth for token1. function getFeeGrowthGlobals(PoolId poolId) external view returns (uint256 feeGrowthGlobal0, uint256 feeGrowthGlobal1); /// @notice Retrieves the total liquidity of a pool. /// @dev Corresponds to pools[poolId].liquidity /// @param poolId The ID of the pool. /// @return liquidity The liquidity of the pool. function getLiquidity(PoolId poolId) external view returns (uint128 liquidity); /// @notice Retrieves the tick bitmap of a pool at a specific tick. /// @dev Corresponds to pools[poolId].tickBitmap[tick] /// @param poolId The ID of the pool. /// @param tick The tick to retrieve the bitmap for. /// @return tickBitmap The bitmap of the tick. function getTickBitmap(PoolId poolId, int16 tick) external view returns (uint256 tickBitmap); /// @notice Retrieves the position info without needing to calculate the `positionId`. /// @dev Corresponds to pools[poolId].positions[positionId] /// @param poolId The ID of the pool. /// @param owner The owner of the liquidity position. /// @param tickLower The lower tick of the liquidity range. /// @param tickUpper The upper tick of the liquidity range. /// @param salt The bytes32 randomness to further distinguish position state. /// @return liquidity The liquidity of the position. /// @return feeGrowthInside0LastX128 The fee growth inside the position for token0. /// @return feeGrowthInside1LastX128 The fee growth inside the position for token1. function getPositionInfo(PoolId poolId, address owner, int24 tickLower, int24 tickUpper, bytes32 salt) external view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128); /// @notice Retrieves the position information of a pool at a specific position ID. /// @dev Corresponds to pools[poolId].positions[positionId] /// @param poolId The ID of the pool. /// @param positionId The ID of the position. /// @return liquidity The liquidity of the position. /// @return feeGrowthInside0LastX128 The fee growth inside the position for token0. /// @return feeGrowthInside1LastX128 The fee growth inside the position for token1. function getPositionInfo(PoolId poolId, bytes32 positionId) external view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128); /// @notice Retrieves the liquidity of a position. /// @dev Corresponds to pools[poolId].positions[positionId].liquidity. More gas efficient for just retrieving liquidity as compared to getPositionInfo /// @param poolId The ID of the pool. /// @param positionId The ID of the position. /// @return liquidity The liquidity of the position. function getPositionLiquidity(PoolId poolId, bytes32 positionId) external view returns (uint128 liquidity); /// @notice Calculate the fee growth inside a tick range of a pool /// @dev pools[poolId].feeGrowthInside0LastX128 in Position.Info is cached and can become stale. This function will calculate the up to date feeGrowthInside /// @param poolId The ID of the pool. /// @param tickLower The lower tick of the range. /// @param tickUpper The upper tick of the range. /// @return feeGrowthInside0X128 The fee growth inside the tick range for token0. /// @return feeGrowthInside1X128 The fee growth inside the tick range for token1. function getFeeGrowthInside(PoolId poolId, int24 tickLower, int24 tickUpper) external view returns (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128); }

// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.0; import {FullMath} from "./FullMath.sol"; import {FixedPoint128} from "./FixedPoint128.sol"; import {LiquidityMath} from "./LiquidityMath.sol"; import {CustomRevert} from "./CustomRevert.sol"; /// @title Position /// @notice Positions represent an owner address' liquidity between a lower and upper tick boundary /// @dev Positions store additional state for tracking fees owed to the position library Position { using CustomRevert for bytes4; /// @notice Cannot update a position with no liquidity error CannotUpdateEmptyPosition(); // info stored for each user's position struct State { // the amount of liquidity owned by this position uint128 liquidity; // fee growth per unit of liquidity as of the last update to liquidity or fees owed uint256 feeGrowthInside0LastX128; uint256 feeGrowthInside1LastX128; } /// @notice Returns the State struct of a position, given an owner and position boundaries /// @param self The mapping containing all user positions /// @param owner The address of the position owner /// @param tickLower The lower tick boundary of the position /// @param tickUpper The upper tick boundary of the position /// @param salt A unique value to differentiate between multiple positions in the same range /// @return position The position info struct of the given owners' position function get(mapping(bytes32 => State) storage self, address owner, int24 tickLower, int24 tickUpper, bytes32 salt) internal view returns (State storage position) { bytes32 positionKey = calculatePositionKey(owner, tickLower, tickUpper, salt); position = self[positionKey]; } /// @notice A helper function to calculate the position key /// @param owner The address of the position owner /// @param tickLower the lower tick boundary of the position /// @param tickUpper the upper tick boundary of the position /// @param salt A unique value to differentiate between multiple positions in the same range, by the same owner. Passed in by the caller. function calculatePositionKey(address owner, int24 tickLower, int24 tickUpper, bytes32 salt) internal pure returns (bytes32 positionKey) { // positionKey = keccak256(abi.encodePacked(owner, tickLower, tickUpper, salt)) assembly ("memory-safe") { let fmp := mload(0x40) mstore(add(fmp, 0x26), salt) // [0x26, 0x46) mstore(add(fmp, 0x06), tickUpper) // [0x23, 0x26) mstore(add(fmp, 0x03), tickLower) // [0x20, 0x23) mstore(fmp, owner) // [0x0c, 0x20) positionKey := keccak256(add(fmp, 0x0c), 0x3a) // len is 58 bytes // now clean the memory we used mstore(add(fmp, 0x40), 0) // fmp+0x40 held salt mstore(add(fmp, 0x20), 0) // fmp+0x20 held tickLower, tickUpper, salt mstore(fmp, 0) // fmp held owner } } /// @notice Credits accumulated fees to a user's position /// @param self The individual position to update /// @param liquidityDelta The change in pool liquidity as a result of the position update /// @param feeGrowthInside0X128 The all-time fee growth in currency0, per unit of liquidity, inside the position's tick boundaries /// @param feeGrowthInside1X128 The all-time fee growth in currency1, per unit of liquidity, inside the position's tick boundaries /// @return feesOwed0 The amount of currency0 owed to the position owner /// @return feesOwed1 The amount of currency1 owed to the position owner function update( State storage self, int128 liquidityDelta, uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128 ) internal returns (uint256 feesOwed0, uint256 feesOwed1) { uint128 liquidity = self.liquidity; if (liquidityDelta == 0) { // disallow pokes for 0 liquidity positions if (liquidity == 0) CannotUpdateEmptyPosition.selector.revertWith(); } else { self.liquidity = LiquidityMath.addDelta(liquidity, liquidityDelta); } // calculate accumulated fees. overflow in the subtraction of fee growth is expected unchecked { feesOwed0 = FullMath.mulDiv(feeGrowthInside0X128 - self.feeGrowthInside0LastX128, liquidity, FixedPoint128.Q128); feesOwed1 = FullMath.mulDiv(feeGrowthInside1X128 - self.feeGrowthInside1LastX128, liquidity, FixedPoint128.Q128); } // update the position self.feeGrowthInside0LastX128 = feeGrowthInside0X128; self.feeGrowthInside1LastX128 = feeGrowthInside1X128; } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol) pragma solidity ^0.8.20; import {Context} from "../utils/Context.sol"; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { bool private _paused; /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); /** * @dev The operation failed because the contract is paused. */ error EnforcedPause(); /** * @dev The operation failed because the contract is not paused. */ error ExpectedPause(); /** * @dev Initializes the contract in unpaused state. */ constructor() { _paused = false; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { _requireNotPaused(); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { _requirePaused(); _; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Throws if the contract is paused. */ function _requireNotPaused() internal view virtual { if (paused()) { revert EnforcedPause(); } } /** * @dev Throws if the contract is not paused. */ function _requirePaused() internal view virtual { if (!paused()) { revert ExpectedPause(); } } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {IERC20Minimal} from "../interfaces/external/IERC20Minimal.sol"; import {CustomRevert} from "../libraries/CustomRevert.sol"; type Currency is address; using {greaterThan as >, lessThan as <, greaterThanOrEqualTo as >=, equals as ==} for Currency global; using CurrencyLibrary for Currency global; function equals(Currency currency, Currency other) pure returns (bool) { return Currency.unwrap(currency) == Currency.unwrap(other); } function greaterThan(Currency currency, Currency other) pure returns (bool) { return Currency.unwrap(currency) > Currency.unwrap(other); } function lessThan(Currency currency, Currency other) pure returns (bool) { return Currency.unwrap(currency) < Currency.unwrap(other); } function greaterThanOrEqualTo(Currency currency, Currency other) pure returns (bool) { return Currency.unwrap(currency) >= Currency.unwrap(other); } /// @title CurrencyLibrary /// @dev This library allows for transferring and holding native tokens and ERC20 tokens library CurrencyLibrary { /// @notice Additional context for ERC-7751 wrapped error when a native transfer fails error NativeTransferFailed(); /// @notice Additional context for ERC-7751 wrapped error when an ERC20 transfer fails error ERC20TransferFailed(); /// @notice A constant to represent the native currency Currency public constant ADDRESS_ZERO = Currency.wrap(address(0)); function transfer(Currency currency, address to, uint256 amount) internal { // altered from https://github.com/transmissions11/solmate/blob/44a9963d4c78111f77caa0e65d677b8b46d6f2e6/src/utils/SafeTransferLib.sol // modified custom error selectors bool success; if (currency.isAddressZero()) { assembly ("memory-safe") { // Transfer the ETH and revert if it fails. success := call(gas(), to, amount, 0, 0, 0, 0) } // revert with NativeTransferFailed, containing the bubbled up error as an argument if (!success) { CustomRevert.bubbleUpAndRevertWith(to, bytes4(0), NativeTransferFailed.selector); } } else { assembly ("memory-safe") { // Get a pointer to some free memory. let fmp := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(fmp, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) mstore(add(fmp, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument. mstore(add(fmp, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), currency, 0, fmp, 68, 0, 32) ) // Now clean the memory we used mstore(fmp, 0) // 4 byte `selector` and 28 bytes of `to` were stored here mstore(add(fmp, 0x20), 0) // 4 bytes of `to` and 28 bytes of `amount` were stored here mstore(add(fmp, 0x40), 0) // 4 bytes of `amount` were stored here } // revert with ERC20TransferFailed, containing the bubbled up error as an argument if (!success) { CustomRevert.bubbleUpAndRevertWith( Currency.unwrap(currency), IERC20Minimal.transfer.selector, ERC20TransferFailed.selector ); } } } function balanceOfSelf(Currency currency) internal view returns (uint256) { if (currency.isAddressZero()) { return address(this).balance; } else { return IERC20Minimal(Currency.unwrap(currency)).balanceOf(address(this)); } } function balanceOf(Currency currency, address owner) internal view returns (uint256) { if (currency.isAddressZero()) { return owner.balance; } else { return IERC20Minimal(Currency.unwrap(currency)).balanceOf(owner); } } function isAddressZero(Currency currency) internal pure returns (bool) { return Currency.unwrap(currency) == Currency.unwrap(ADDRESS_ZERO); } function toId(Currency currency) internal pure returns (uint256) { return uint160(Currency.unwrap(currency)); } // If the upper 12 bytes are non-zero, they will be zero-ed out // Therefore, fromId() and toId() are not inverses of each other function fromId(uint256 id) internal pure returns (Currency) { return Currency.wrap(address(uint160(id))); } }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {IArenaPoolDeployer} from "../robinhood/interfaces/IArenaPoolDeployer.sol"; import {IRobinhoodArenaManagerHelper} from "../helpers/RobinhoodHelperInterfaces.sol"; import {RobinhoodArenaPairPriceHelper} from "../helpers/RobinhoodArenaPairPriceHelper.sol"; interface IPrismRegistryView { function isApprovedManager(address manager) external view returns (bool); } interface IPrismPostBondQuoter { struct PostBondQuoteParams { address pairedToken; address launchToken; uint256 tokenAmountToLp; uint256 pairedTokenAmountToLp; uint256 pairedTokenAmountIn; IArenaPoolDeployer.PoolInitParams config; uint16 creatorFeePpm; uint160 invertedStartingPrice; } function quotePostBond(PostBondQuoteParams calldata params) external view returns (uint256 tokenOut, uint256 pairedTokenConsumed); } interface IPrismPriceHelperIdentity { function TOKEN_MANAGER() external view returns (IRobinhoodArenaManagerHelper); } /// @notice Quotes creation, graduation, and the immediate v4 buy for any /// registry-approved Arena Prism manager. contract RobinhoodPrismQuoter { uint256 private constant GRANULARITY = 1e18; struct QuoteParams { address manager; address priceHelper; uint32 a; uint8 b; uint128 curveScaler; uint8 creatorFeeBasisPoints; uint256 tokenSplit; bool enableHolderRewards; uint256 amountIn; address predictedToken; } struct QuoteResult { uint256 preBondTokenOut; uint256 preBondCost; uint256 postBondTokenOut; uint256 postBondCost; uint256 postBondInputConsumed; uint256 totalTokenOut; bool tokenBonds; } IPrismRegistryView public immutable REGISTRY; IPrismPostBondQuoter public immutable POST_BOND_QUOTER; error ManagerNotApproved(); error InvalidDependency(); error PriceHelperMismatch(); error CurveNotConfigured(); constructor(IPrismRegistryView registry, IPrismPostBondQuoter postBondQuoter) { if (address(registry) == address(0) || address(postBondQuoter) == address(0)) { revert InvalidDependency(); } REGISTRY = registry; POST_BOND_QUOTER = postBondQuoter; } function quoteCreation(QuoteParams calldata params) external view returns (QuoteResult memory quote) { if (!REGISTRY.isApprovedManager(params.manager)) revert ManagerNotApproved(); if ( address(IPrismPriceHelperIdentity(params.priceHelper).TOKEN_MANAGER()) != params.manager ) revert PriceHelperMismatch(); IRobinhoodArenaManagerHelper manager = IRobinhoodArenaManagerHelper(params.manager); uint256 allowed = manager.allowedTotalSupplyWithParameters( params.a, params.b, params.curveScaler, params.tokenSplit ); if (allowed == 0) revert CurveNotConfigured(); uint256 amountToBond = allowed * params.tokenSplit / 100; quote.preBondCost = manager.calculateCostScaledParametricWithFees( amountToBond, 0, params.a, params.b, params.curveScaler, params.creatorFeeBasisPoints ) + manager.tokenCreationBuyFeeAmount(); if (params.amountIn < quote.preBondCost) { (quote.preBondTokenOut, quote.preBondCost) = RobinhoodArenaPairPriceHelper(params.priceHelper) .calculatePurchaseAmountAndPriceParametric( params.amountIn, params.a, params.b, params.curveScaler, params.creatorFeeBasisPoints, params.tokenSplit ); quote.totalTokenOut = quote.preBondTokenOut; return quote; } quote.preBondTokenOut = amountToBond; quote.tokenBonds = true; quote.postBondCost = params.amountIn - quote.preBondCost; if (quote.postBondCost != 0) { (quote.postBondTokenOut, quote.postBondInputConsumed) = _quotePostBond(manager, params, allowed, amountToBond, quote.postBondCost); } quote.totalTokenOut = quote.preBondTokenOut + quote.postBondTokenOut; } function _quotePostBond( IRobinhoodArenaManagerHelper manager, QuoteParams calldata params, uint256 allowed, uint256 amountToBond, uint256 postBondCost ) internal view returns (uint256 tokenOut, uint256 pairedTokenConsumed) { uint256 tokenAmountToLp = allowed * (100 - params.tokenSplit) / 100; uint256 pairedTokenAmountToLp = manager.calculateCostScaledParametric( amountToBond, 0, params.a, params.b, params.curveScaler ); IRobinhoodArenaManagerHelper.V4PoolInitParams memory config = manager.getV4PoolInitParams(); return POST_BOND_QUOTER.quotePostBond( IPrismPostBondQuoter.PostBondQuoteParams({ pairedToken: manager.ARENA_ADDRESS(), launchToken: params.predictedToken, tokenAmountToLp: tokenAmountToLp, pairedTokenAmountToLp: pairedTokenAmountToLp, pairedTokenAmountIn: postBondCost, config: config.poolInitParams, creatorFeePpm: config.creatorFeePpm, invertedStartingPrice: config.invertedStartingPrice }) ); } }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol"; import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; interface IPrismManagerIdentity { function PAIR_TOKEN() external view returns (address); } /// @notice Canonical allowlist of RWA numeraires and their isolated managers. contract RobinhoodPrismRegistry is Ownable2Step { struct Pair { address manager; uint8 decimals; bool enabled; string label; } mapping(address pairToken => Pair pair) private _pairs; mapping(address manager => address pairToken) public pairTokenForManager; address[] private _pairTokens; error ZeroAddress(); error NotContract(address account); error PairManagerMismatch(address expected, address actual); error ManagerAlreadyRegistered(address manager); error UnsupportedDecimals(uint8 decimals); error PairNotRegistered(address pairToken); event PairRegistered( address indexed pairToken, address indexed manager, uint8 decimals, string label ); event PairStatusSet(address indexed pairToken, bool enabled); constructor(address initialOwner) Ownable(initialOwner) { if (initialOwner == address(0)) revert ZeroAddress(); } function registerPair(address pairToken, address manager, string calldata label) external onlyOwner { if (pairToken == address(0) || manager == address(0)) revert ZeroAddress(); if (pairToken.code.length == 0) revert NotContract(pairToken); if (manager.code.length == 0) revert NotContract(manager); address actual = IPrismManagerIdentity(manager).PAIR_TOKEN(); if (actual != pairToken) revert PairManagerMismatch(pairToken, actual); address existingToken = pairTokenForManager[manager]; if (existingToken != address(0) && existingToken != pairToken) { revert ManagerAlreadyRegistered(manager); } uint8 decimals = IERC20Metadata(pairToken).decimals(); if (decimals == 0 || decimals > 18) revert UnsupportedDecimals(decimals); if (_pairs[pairToken].manager == address(0)) _pairTokens.push(pairToken); _pairs[pairToken] = Pair(manager, decimals, true, label); pairTokenForManager[manager] = pairToken; emit PairRegistered(pairToken, manager, decimals, label); } function setPairEnabled(address pairToken, bool enabled) external onlyOwner { Pair storage pair = _pairs[pairToken]; if (pair.manager == address(0)) revert PairNotRegistered(pairToken); pair.enabled = enabled; emit PairStatusSet(pairToken, enabled); } function getPair(address pairToken) external view returns (Pair memory) { return _pairs[pairToken]; } function isApprovedManager(address manager) external view returns (bool) { address pairToken = pairTokenForManager[manager]; return pairToken != address(0) && _pairs[pairToken].enabled && _pairs[pairToken].manager == manager; } function pairCount() external view returns (uint256) { return _pairTokens.length; } function pairAt(uint256 index) external view returns (address pairToken, Pair memory pair) { pairToken = _pairTokens[index]; pair = _pairs[pairToken]; } function renounceOwnership() public view override onlyOwner { revert OwnableInvalidOwner(address(0)); } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol) pragma solidity ^0.8.20; import {Initializable} from "../proxy/utils/Initializable.sol"; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuardUpgradeable is Initializable { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant NOT_ENTERED = 1; uint256 private constant ENTERED = 2; /// @custom:storage-location erc7201:openzeppelin.storage.ReentrancyGuard struct ReentrancyGuardStorage { uint256 _status; } // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant ReentrancyGuardStorageLocation = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; function _getReentrancyGuardStorage() private pure returns (ReentrancyGuardStorage storage $) { assembly { $.slot := ReentrancyGuardStorageLocation } } /** * @dev Unauthorized reentrant call. */ error ReentrancyGuardReentrantCall(); function __ReentrancyGuard_init() internal onlyInitializing { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal onlyInitializing { ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage(); $._status = NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage(); // On the first call to nonReentrant, _status will be NOT_ENTERED if ($._status == ENTERED) { revert ReentrancyGuardReentrantCall(); } // Any calls to nonReentrant after this point will fail $._status = ENTERED; } function _nonReentrantAfter() private { ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage(); // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) $._status = NOT_ENTERED; } /** * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a * `nonReentrant` function in the call stack. */ function _reentrancyGuardEntered() internal view returns (bool) { ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage(); return $._status == ENTERED; } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol) pragma solidity ^0.8.20; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC1822.sol) pragma solidity ^0.8.20; /** * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified * proxy whose upgrades are fully controlled by the current implementation. */ interface IERC1822Proxiable { /** * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation * address. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. */ function proxiableUUID() external view returns (bytes32); }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol) pragma solidity ^0.8.20; /** * @dev Standard ERC20 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens. */ interface IERC20Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC20InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. * @param spender Address that may be allowed to operate on tokens without being their owner. * @param allowance Amount of tokens a `spender` is allowed to operate with. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC20InvalidApprover(address approver); /** * @dev Indicates a failure with the `spender` to be approved. Used in approvals. * @param spender Address that may be allowed to operate on tokens without being their owner. */ error ERC20InvalidSpender(address spender); } /** * @dev Standard ERC721 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens. */ interface IERC721Errors { /** * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20. * Used in balance queries. * @param owner Address of the current owner of a token. */ error ERC721InvalidOwner(address owner); /** * @dev Indicates a `tokenId` whose `owner` is the zero address. * @param tokenId Identifier number of a token. */ error ERC721NonexistentToken(uint256 tokenId); /** * @dev Indicates an error related to the ownership over a particular token. Used in transfers. * @param sender Address whose tokens are being transferred. * @param tokenId Identifier number of a token. * @param owner Address of the current owner of a token. */ error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC721InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC721InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param tokenId Identifier number of a token. */ error ERC721InsufficientApproval(address operator, uint256 tokenId); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC721InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC721InvalidOperator(address operator); } /** * @dev Standard ERC1155 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens. */ interface IERC1155Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. * @param tokenId Identifier number of a token. */ error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC1155InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC1155InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param owner Address of the current owner of a token. */ error ERC1155MissingApprovalForAll(address operator, address owner); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC1155InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC1155InvalidOperator(address operator); /** * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation. * Used in batch transfers. * @param idsLength Length of the array of token identifiers * @param valuesLength Length of the array of token amounts */ error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength); }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; /// @notice Robinhood launch creation-fee adapter interface. interface ICreationFeeBuybackAdapter { function depositCreationFee() external payable; }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.24; /// @notice Interface for functions to access any transient storage slot in a contract interface IExttload { /// @notice Called by external contracts to access transient storage of the contract /// @param slot Key of slot to tload /// @return value The value of the slot as bytes32 function exttload(bytes32 slot) external view returns (bytes32 value); /// @notice Called by external contracts to access sparse transient pool state /// @param slots List of slots to tload /// @return values List of loaded values function exttload(bytes32[] calldata slots) external view returns (bytes32[] memory values); }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.20; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the value of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the value of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves a `value` amount of tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 value) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets a `value` amount of tokens as the allowance of `spender` over the * caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 value) external returns (bool); /** * @dev Moves a `value` amount of tokens from `from` to `to` using the * allowance mechanism. `value` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 value) external returns (bool); }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {RobinhoodLaunchToken} from "./RobinhoodLaunchToken.sol"; import {Create2} from "@openzeppelin/contracts/utils/Create2.sol"; /// @notice Robinhood deployment of Arena's permissionless CREATE2 token factory. /// @dev The PoolManager constructor argument is the only chain-specific addition. contract RobinhoodLaunchTokenFactory { address public immutable poolManager; constructor(address poolManager_) { poolManager = poolManager_; } function deployToken(string memory name, string memory symbol, uint256 salt) external returns (address token) { bytes memory tokenBytecode = abi.encodePacked( type(RobinhoodLaunchToken).creationCode, abi.encode(name, symbol, msg.sender, poolManager) ); token = Create2.deploy(0, bytes32(salt), tokenBytecode); } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.26; interface IRobinhoodLaunchToken { struct Whitelist { address[] addresses; uint256 startTsOffset; uint256 duration; uint256 transferLimit; uint256 balanceLimit; } function mint(address to, uint256 amount) external; function burn(address account, uint256 value) external; function setBlacklistStatus(address account, bool blacklisted) external; function totalSupply() external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transfer(address to, uint256 amount) external returns (bool); function transferFrom(address from, address to, uint256 amount) external returns (bool); function balanceOf(address account) external view returns (uint256); function setWhitelistedAddresses(Whitelist calldata whitelist) external; function setCreator(address creator) external; }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {SafeCast} from "../libraries/SafeCast.sol"; /// @dev Two `int128` values packed into a single `int256` where the upper 128 bits represent the amount0 /// and the lower 128 bits represent the amount1. type BalanceDelta is int256; using {add as +, sub as -, eq as ==, neq as !=} for BalanceDelta global; using BalanceDeltaLibrary for BalanceDelta global; using SafeCast for int256; function toBalanceDelta(int128 _amount0, int128 _amount1) pure returns (BalanceDelta balanceDelta) { assembly ("memory-safe") { balanceDelta := or(shl(128, _amount0), and(sub(shl(128, 1), 1), _amount1)) } } function add(BalanceDelta a, BalanceDelta b) pure returns (BalanceDelta) { int256 res0; int256 res1; assembly ("memory-safe") { let a0 := sar(128, a) let a1 := signextend(15, a) let b0 := sar(128, b) let b1 := signextend(15, b) res0 := add(a0, b0) res1 := add(a1, b1) } return toBalanceDelta(res0.toInt128(), res1.toInt128()); } function sub(BalanceDelta a, BalanceDelta b) pure returns (BalanceDelta) { int256 res0; int256 res1; assembly ("memory-safe") { let a0 := sar(128, a) let a1 := signextend(15, a) let b0 := sar(128, b) let b1 := signextend(15, b) res0 := sub(a0, b0) res1 := sub(a1, b1) } return toBalanceDelta(res0.toInt128(), res1.toInt128()); } function eq(BalanceDelta a, BalanceDelta b) pure returns (bool) { return BalanceDelta.unwrap(a) == BalanceDelta.unwrap(b); } function neq(BalanceDelta a, BalanceDelta b) pure returns (bool) { return BalanceDelta.unwrap(a) != BalanceDelta.unwrap(b); } /// @notice Library for getting the amount0 and amount1 deltas from the BalanceDelta type library BalanceDeltaLibrary { /// @notice A BalanceDelta of 0 BalanceDelta public constant ZERO_DELTA = BalanceDelta.wrap(0); function amount0(BalanceDelta balanceDelta) internal pure returns (int128 _amount0) { assembly ("memory-safe") { _amount0 := sar(128, balanceDelta) } } function amount1(BalanceDelta balanceDelta) internal pure returns (int128 _amount1) { assembly ("memory-safe") { _amount1 := signextend(15, balanceDelta) } } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/UUPSUpgradeable.sol) pragma solidity ^0.8.20; import {IERC1822Proxiable} from "@openzeppelin/contracts/interfaces/draft-IERC1822.sol"; import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol"; import {Initializable} from "./Initializable.sol"; /** * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy. * * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing * `UUPSUpgradeable` with a custom implementation of upgrades. * * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism. */ abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable { /// @custom:oz-upgrades-unsafe-allow state-variable-immutable address private immutable __self = address(this); /** * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)` * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called, * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string. * If the getter returns `"5.0.0"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function * during an upgrade. */ string public constant UPGRADE_INTERFACE_VERSION = "5.0.0"; /** * @dev The call is from an unauthorized context. */ error UUPSUnauthorizedCallContext(); /** * @dev The storage `slot` is unsupported as a UUID. */ error UUPSUnsupportedProxiableUUID(bytes32 slot); /** * @dev Check that the execution is being performed through a delegatecall call and that the execution context is * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to * fail. */ modifier onlyProxy() { _checkProxy(); _; } /** * @dev Check that the execution is not being performed through a delegate call. This allows a function to be * callable on the implementing contract but not through proxies. */ modifier notDelegated() { _checkNotDelegated(); _; } function __UUPSUpgradeable_init() internal onlyInitializing { } function __UUPSUpgradeable_init_unchained() internal onlyInitializing { } /** * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the * implementation. It is used to validate the implementation's compatibility when performing an upgrade. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier. */ function proxiableUUID() external view virtual notDelegated returns (bytes32) { return ERC1967Utils.IMPLEMENTATION_SLOT; } /** * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call * encoded in `data`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. * * @custom:oz-upgrades-unsafe-allow-reachable delegatecall */ function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, data); } /** * @dev Reverts if the execution is not performed via delegatecall or the execution * context is not of a proxy with an ERC1967-compliant implementation pointing to self. * See {_onlyProxy}. */ function _checkProxy() internal view virtual { if ( address(this) == __self || // Must be called through delegatecall ERC1967Utils.getImplementation() != __self // Must be called through an active proxy ) { revert UUPSUnauthorizedCallContext(); } } /** * @dev Reverts if the execution is performed via delegatecall. * See {notDelegated}. */ function _checkNotDelegated() internal view virtual { if (address(this) != __self) { // Must not be called through delegatecall revert UUPSUnauthorizedCallContext(); } } /** * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by * {upgradeToAndCall}. * * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. * * ```solidity * function _authorizeUpgrade(address) internal onlyOwner {} * ``` */ function _authorizeUpgrade(address newImplementation) internal virtual; /** * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call. * * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value * is expected to be the implementation slot in ERC1967. * * Emits an {IERC1967-Upgraded} event. */ function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private { try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) { if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) { revert UUPSUnsupportedProxiableUUID(slot); } ERC1967Utils.upgradeToAndCall(newImplementation, data); } catch { // The implementation is not UUPS revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation); } } }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {IRobinhoodArenaManagerHelper} from "../helpers/RobinhoodHelperInterfaces.sol"; import {RobinhoodArenaPairPriceHelper} from "../helpers/RobinhoodArenaPairPriceHelper.sol"; /// @notice Pair-agnostic inverse curve helper for an Arena Prism manager. contract RobinhoodPrismPriceHelper is RobinhoodArenaPairPriceHelper { constructor(IRobinhoodArenaManagerHelper manager) RobinhoodArenaPairPriceHelper(manager) {} }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.20; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ```solidity * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Storage of the initializable contract. * * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions * when using with upgradeable contracts. * * @custom:storage-location erc7201:openzeppelin.storage.Initializable */ struct InitializableStorage { /** * @dev Indicates that the contract has been initialized. */ uint64 _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool _initializing; } // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00; /** * @dev The contract is already initialized. */ error InvalidInitialization(); /** * @dev The contract is not initializing. */ error NotInitializing(); /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint64 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. * * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in * production. * * Emits an {Initialized} event. */ modifier initializer() { // solhint-disable-next-line var-name-mixedcase InitializableStorage storage $ = _getInitializableStorage(); // Cache values to avoid duplicated sloads bool isTopLevelCall = !$._initializing; uint64 initialized = $._initialized; // Allowed calls: // - initialSetup: the contract is not in the initializing state and no previous version was // initialized // - construction: the contract is initialized at version 1 (no reininitialization) and the // current contract is just being deployed bool initialSetup = initialized == 0 && isTopLevelCall; bool construction = initialized == 1 && address(this).code.length == 0; if (!initialSetup && !construction) { revert InvalidInitialization(); } $._initialized = 1; if (isTopLevelCall) { $._initializing = true; } _; if (isTopLevelCall) { $._initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * A reinitializer may be used after the original initialization step. This is essential to configure modules that * are added through upgrades and that require initialization. * * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` * cannot be nested. If one is invoked in the context of another, execution will revert. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. * * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization. * * Emits an {Initialized} event. */ modifier reinitializer(uint64 version) { // solhint-disable-next-line var-name-mixedcase InitializableStorage storage $ = _getInitializableStorage(); if ($._initializing || $._initialized >= version) { revert InvalidInitialization(); } $._initialized = version; $._initializing = true; _; $._initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { _checkInitializing(); _; } /** * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}. */ function _checkInitializing() internal view virtual { if (!_isInitializing()) { revert NotInitializing(); } } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. * * Emits an {Initialized} event the first time it is successfully executed. */ function _disableInitializers() internal virtual { // solhint-disable-next-line var-name-mixedcase InitializableStorage storage $ = _getInitializableStorage(); if ($._initializing) { revert InvalidInitialization(); } if ($._initialized != type(uint64).max) { $._initialized = type(uint64).max; emit Initialized(type(uint64).max); } } /** * @dev Returns the highest version that has been initialized. See {reinitializer}. */ function _getInitializedVersion() internal view returns (uint64) { return _getInitializableStorage()._initialized; } /** * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}. */ function _isInitializing() internal view returns (bool) { return _getInitializableStorage()._initializing; } /** * @dev Returns a pointer to the storage namespace. */ // solhint-disable-next-line var-name-mixedcase function _getInitializableStorage() private pure returns (InitializableStorage storage $) { assembly { $.slot := INITIALIZABLE_STORAGE } } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol"; /// @title IImmutableState /// @notice Interface for the ImmutableState contract interface IImmutableState { /// @notice The Uniswap v4 PoolManager contract function poolManager() external view returns (IPoolManager); }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol) pragma solidity ^0.8.20; import {Context} from "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * The initial owner is set to the address provided by the deployer. This can * later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; /** * @dev The caller account is not authorized to perform an operation. */ error OwnableUnauthorizedAccount(address account); /** * @dev The owner is not a valid owner account. (eg. `address(0)`) */ error OwnableInvalidOwner(address owner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the address provided by the deployer as the initial owner. */ constructor(address initialOwner) { if (initialOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(initialOwner); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { if (owner() != _msgSender()) { revert OwnableUnauthorizedAccount(_msgSender()); } } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { if (newOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.26; import {IArenaFeeHelperMinimal} from "./IArenaFeeHelperMinimal.sol"; /// @notice Pool deployment interface used by Robinhood launch managers. interface IArenaPoolDeployer { struct PoolInitParams { int24 tickSpacing; int24 tickLower; int24 tickUpper; uint24 fee; uint160 startingPrice; uint256 token0Amount; uint256 token1Amount; address token0; address token1; address recipient; address hookContract; bytes hookData; } function initPoolAndSetFees( PoolInitParams memory params, IArenaFeeHelperMinimal.Fee[] calldata fees ) external returns (uint256); }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /// @notice Library to define different pool actions. /// @dev These are suggested common commands, however additional commands should be defined as required /// Some of these actions are not supported in the Router contracts or Position Manager contracts, but are left as they may be helpful commands for other peripheral contracts. library Actions { // pool actions // liquidity actions uint256 internal constant INCREASE_LIQUIDITY = 0x00; uint256 internal constant DECREASE_LIQUIDITY = 0x01; uint256 internal constant MINT_POSITION = 0x02; uint256 internal constant BURN_POSITION = 0x03; uint256 internal constant INCREASE_LIQUIDITY_FROM_DELTAS = 0x04; uint256 internal constant MINT_POSITION_FROM_DELTAS = 0x05; // swapping uint256 internal constant SWAP_EXACT_IN_SINGLE = 0x06; uint256 internal constant SWAP_EXACT_IN = 0x07; uint256 internal constant SWAP_EXACT_OUT_SINGLE = 0x08; uint256 internal constant SWAP_EXACT_OUT = 0x09; // donate // note this is not supported in the position manager or router uint256 internal constant DONATE = 0x0a; // closing deltas on the pool manager // settling uint256 internal constant SETTLE = 0x0b; uint256 internal constant SETTLE_ALL = 0x0c; uint256 internal constant SETTLE_PAIR = 0x0d; // taking uint256 internal constant TAKE = 0x0e; uint256 internal constant TAKE_ALL = 0x0f; uint256 internal constant TAKE_PORTION = 0x10; uint256 internal constant TAKE_PAIR = 0x11; uint256 internal constant CLOSE_CURRENCY = 0x12; uint256 internal constant CLEAR_OR_TAKE = 0x13; uint256 internal constant SWEEP = 0x14; uint256 internal constant WRAP = 0x15; uint256 internal constant UNWRAP = 0x16; // minting/burning 6909s to close deltas // note this is not supported in the position manager or router uint256 internal constant MINT_6909 = 0x17; uint256 internal constant BURN_6909 = 0x18; }

// SPDX-License-Identifier: UNLICENSED pragma solidity 0.8.28; import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol"; import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol"; import {IRobinhoodLaunchTokenFactory} from "./interfaces/IRobinhoodLaunchTokenFactory.sol"; import {IRobinhoodLaunchToken} from "./interfaces/IRobinhoodLaunchToken.sol"; import {IArenaPoolDeployer} from "./interfaces/IArenaPoolDeployer.sol"; import {IArenaFeeHelperMinimal} from "./interfaces/IArenaFeeHelperMinimal.sol"; import {ICreationFeeBuybackAdapter} from "./interfaces/ICreationFeeBuybackAdapter.sol"; interface IWETH9Parity { function deposit() external payable; function approve(address spender, uint256 amount) external returns (bool); } interface IReferrerRegistryParity { function getReferrer(address referee) external view returns (address); } interface IFeeSwapRouterParity { function factory() external pure returns (address); } interface IOwnableLaunchToken { function renounceOwnership() external; } /// @notice Robinhood Chain native-pair launch-token manager. /// @dev User, fee, whitelist, pause, owner, and curve behavior intentionally /// follows the Arena launcher implementation. Chain-specific graduation is routed /// through an IArenaPoolDeployer-compatible Robinhood Uniswap v4 adapter. contract RobinhoodNativePairTokenManager is OwnableUpgradeable, UUPSUpgradeable, PausableUpgradeable, ReentrancyGuardUpgradeable { uint256 public constant GRANULARITY_SCALER = 1e18; uint8 public constant MAX_FEE_BASIS_POINT = 250; uint256 public constant INITIAL_TOKEN_ID = 1; uint256 public constant MAX_CREATOR_FEE_BASIS_POINT = 250; /// @custom:oz-upgrades-unsafe-allow state-variable-immutable address public immutable STAKER_REWARD_TOKEN_VAULT; /// @custom:oz-upgrades-unsafe-allow state-variable-immutable address public immutable WETH_ADDRESS; uint256 public tokenIdentifier; address public protocolFeeDestination; uint8 public protocolFeeBasisPoint; uint8 public referralFeeBasisPoint; bool public canDeployLp; IFeeSwapRouterParity public uniswapV2Router02; IRobinhoodLaunchTokenFactory public tokenFactory; address public tokenCreationBuyFeeVault; uint88 public tokenCreationBuyFeeAmount; bool public transferTokenCreationBuyFeeToVault; uint256[99] private __gap; error InvalidFeeSetting(); error InsufficentFunds(); error CurveParametersNotAllowed(); error TokenSplitNotAllowed(); error DeadlineExpired(); error SlippageExceeded(); error InvalidWETH(); error InvalidStakerRewardVault(); error InvalidCreationFeeBuybackAdapter(); error CreationFeeTransferFailed(); struct TokenParameters { uint128 curveScaler; uint16 a; uint8 b; bool lpDeployed; uint8 lpPercentage; uint8 salePercentage; uint8 creatorFeeBasisPoints; address creatorAddress; address pairAddress; address tokenContractAddress; } struct FeeData { uint256 protocolFee; uint256 creatorFee; uint256 referralFee; uint256 totalFeeAmount; address tokenCreator; address referrerAddress; } struct V4PoolInitParams { IArenaPoolDeployer.PoolInitParams poolInitParams; uint16 creatorFeePpm; uint160 invertedStartingPrice; } mapping(uint256 => TokenParameters) public tokenParams; mapping(uint256 => uint256) public tokenBalanceOf; mapping(address => address) public referrers; mapping(bytes32 => uint256) public allowedTokenSupplyWithParameters; mapping(uint256 => uint256) public tokenSupply; address public LP_TOKEN_VAULT; IArenaPoolDeployer public arenaPoolDeployer; V4PoolInitParams public v4PoolInitParams; IReferrerRegistryParity public referrerRegistry; ICreationFeeBuybackAdapter public creationFeeBuybackAdapter; /// @notice Creator fee charged on every bonding-curve buy and sell. /// @dev Appended for UUPS storage compatibility with the deployed proxy. uint8 public bondingCreatorFeeBasisPoint; /// @dev Appended after all existing proxy state for storage compatibility. mapping(uint256 => uint8) private holderRewardsMode; mapping(address => bool) private nextLaunchHolderRewardsDisabled; /// @notice Retained for ABI compatibility. Holder rewards are permanently disabled. function setNextLaunchHolderRewards(bool enabled) external { enabled; delete nextLaunchHolderRewardsDisabled[msg.sender]; } /// @notice Retained for ABI compatibility and always returns false. function holderRewardsEnabled(uint256 tokenId) public view returns (bool) { tokenId; return false; } event TokenCreated(uint256 tokenId, TokenParameters params, uint256 tokenSupply); event Sell( address user, uint256 tokenId, uint256 tokenAmount, uint256 reward, uint256 tokenSupply, address referrerAddress, uint256 referralFee, uint256 creatorFee, uint256 protocolFee ); event Buy( address user, uint256 tokenId, uint256 tokenAmount, uint256 cost, uint256 tokenSupply, address referrerAddress, uint256 referralFee, uint256 creatorFee, uint256 protocolFee ); event TokenLPCreated(uint256 tokenId, uint256 amountToken, uint256 amountNative, uint256 liquidity); event ProtocolFeeBasisPointSet(uint256 oldBasisPoint, uint256 newBasisPoint); event ReferralFeeBasisPointSet(uint256 oldBasisPoint, uint256 newBasisPoint); event AllowedTokenSupplyForParamsSet( uint256 a, uint256 b, uint256 curveScaler, uint256 tokenSupply, uint256 tokenSplit ); event ProtocolFeeDestinationSet(address oldDestination, address newDestination); event LPDeployPermissionSet(bool value); event ReferrerSet(address user, address referrer); event TokenFactorySet(address oldTokenFactoryAddress, address newTokenFactory); event TokenCreationBuyFeeParamsSet( address tokenCreationBuyFeeVault, uint88 tokenCreationBuyFeeAmount, bool transferTokenCreationBuyFeeToVault ); event CreationFeeBuybackAdapterSet(address oldAdapter, address newAdapter); event BondingCreatorFeeBasisPointSet(uint256 oldBasisPoint, uint256 newBasisPoint); modifier lpNotDeployed(uint256 tokenId) { require(!tokenParams[tokenId].lpDeployed, "LP already deployed!"); _; } /// @custom:oz-upgrades-unsafe-allow constructor constructor(address weth_, address stakerRewardVault_) { if (weth_ == address(0)) revert InvalidWETH(); if (stakerRewardVault_ == address(0)) revert InvalidStakerRewardVault(); WETH_ADDRESS = weth_; STAKER_REWARD_TOKEN_VAULT = stakerRewardVault_; _disableInitializers(); } function initialize( address uniswapV2RouterAddress, address ownerAddress, address tokenFactoryContractAddress ) public initializer { __Ownable_init(ownerAddress); __UUPSUpgradeable_init(); __Pausable_init(); __ReentrancyGuard_init(); uniswapV2Router02 = IFeeSwapRouterParity(uniswapV2RouterAddress); tokenIdentifier = INITIAL_TOKEN_ID; tokenFactory = IRobinhoodLaunchTokenFactory(tokenFactoryContractAddress); canDeployLp = true; } function _authorizeUpgrade(address) internal override onlyOwner {} function setReferralFeeBasisPoint(uint8 feeBasisPoint) external onlyOwner { if (feeBasisPoint > MAX_FEE_BASIS_POINT) revert InvalidFeeSetting(); uint8 oldFeeBasisPoint = referralFeeBasisPoint; referralFeeBasisPoint = feeBasisPoint; emit ReferralFeeBasisPointSet(oldFeeBasisPoint, feeBasisPoint); } function setBondingCreatorFeeBasisPoint(uint8 feeBasisPoint) external onlyOwner { if (feeBasisPoint > MAX_CREATOR_FEE_BASIS_POINT) revert InvalidFeeSetting(); uint8 oldFeeBasisPoint = bondingCreatorFeeBasisPoint; bondingCreatorFeeBasisPoint = feeBasisPoint; emit BondingCreatorFeeBasisPointSet(oldFeeBasisPoint, feeBasisPoint); } function setLpTokenVault(address lpTokenVault) external onlyOwner { LP_TOKEN_VAULT = lpTokenVault; } function setArenaPoolDeployer(address poolDeployer) external onlyOwner { arenaPoolDeployer = IArenaPoolDeployer(poolDeployer); } function setReferrerRegistry(address registry) external onlyOwner { referrerRegistry = IReferrerRegistryParity(registry); } function setCreationFeeBuybackAdapter(address adapter) external onlyOwner { if (adapter == address(0) || adapter.code.length == 0) { revert InvalidCreationFeeBuybackAdapter(); } address oldAdapter = address(creationFeeBuybackAdapter); creationFeeBuybackAdapter = ICreationFeeBuybackAdapter(adapter); emit CreationFeeBuybackAdapterSet(oldAdapter, adapter); } function setPoolInitParams( IArenaPoolDeployer.PoolInitParams calldata poolInitParams, uint16 creatorFeePpm, uint160 invertedStartingPrice ) external onlyOwner { v4PoolInitParams.poolInitParams = poolInitParams; v4PoolInitParams.creatorFeePpm = creatorFeePpm; v4PoolInitParams.invertedStartingPrice = invertedStartingPrice; require( invertedStartingPrice < v4PoolInitParams.poolInitParams.startingPrice, "Inverted starting price must be greater than starting price" ); } function setAllowedTokenSupplyForParameters( uint16 a, uint8 b, uint128 c, uint256 allowedTokenSupply, uint256 tokenSplit ) external onlyOwner { require(c != 0, "Invalid c coefficient"); require(!(a > 0 && b > 0), "Invalid parameters"); require(!(a == 0 && b == 0), "Both a and b are zero, should revert"); require(tokenSplit <= 80 && tokenSplit >= 60, "Token split must be smaller"); require(allowedTokenSupply % 1e18 == 0, "allowedtokenSupply must be divisible by 1e18"); bytes32 parametersAndSupplyHash = keccak256(abi.encodePacked(a, b, c, tokenSplit)); allowedTokenSupplyWithParameters[parametersAndSupplyHash] = allowedTokenSupply; emit AllowedTokenSupplyForParamsSet(a, b, c, allowedTokenSupply, tokenSplit); } function setLpDeployPermission(bool value) external onlyOwner { canDeployLp = value; emit LPDeployPermissionSet(value); } function setProtocolFeeBasisPoint(uint8 feeBasisPoint) external onlyOwner { if (feeBasisPoint > MAX_FEE_BASIS_POINT) revert InvalidFeeSetting(); uint8 oldFeeBasisPoint = protocolFeeBasisPoint; protocolFeeBasisPoint = feeBasisPoint; emit ProtocolFeeBasisPointSet(oldFeeBasisPoint, feeBasisPoint); } function setFeeDestination(address feeDestination) external onlyOwner { require(feeDestination != address(0), "Invalid fee destination"); address oldDestination = protocolFeeDestination; protocolFeeDestination = feeDestination; emit ProtocolFeeDestinationSet(oldDestination, feeDestination); } function setTokenFactory(address newTokenFactory) external onlyOwner { address oldTokenFactory = address(tokenFactory); tokenFactory = IRobinhoodLaunchTokenFactory(newTokenFactory); emit TokenFactorySet(oldTokenFactory, newTokenFactory); } function setRouter02(address newRouter02) external onlyOwner { uniswapV2Router02 = IFeeSwapRouterParity(newRouter02); } function pause() public onlyOwner { _pause(); } function unpause() public onlyOwner { _unpause(); } function renounceOwnership() public override onlyOwner {} function setTokenCreationBuyFeeParams( address tokenCreationBuyFeeVault_, uint88 tokenCreationBuyFeeAmount_, bool transferTokenCreationBuyFeeToVault_ ) external onlyOwner { require(tokenCreationBuyFeeVault_ != address(0), "Invalid token creation buy fee vault"); tokenCreationBuyFeeAmount = tokenCreationBuyFeeAmount_; transferTokenCreationBuyFeeToVault = transferTokenCreationBuyFeeToVault_; tokenCreationBuyFeeVault = tokenCreationBuyFeeVault_; emit TokenCreationBuyFeeParamsSet( tokenCreationBuyFeeVault_, tokenCreationBuyFeeAmount_, transferTokenCreationBuyFeeToVault_ ); } function createTokenWithWL( uint16 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, address tokenCreatorAddress, uint256 tokenSplit, string memory name, string memory symbol, uint256 amount, IRobinhoodLaunchToken.Whitelist calldata whitelist, uint256 maxTotalCost, uint256 deadline ) external payable whenNotPaused nonReentrant { _checkDeadline(deadline); _createToken( a, b, curveScaler, creatorFeeBasisPoints, tokenCreatorAddress, tokenSplit, name, symbol, amount ); uint256 tokenId = tokenIdentifier - 1; address tokenContractAddress = tokenParams[tokenId].tokenContractAddress; IRobinhoodLaunchToken(tokenContractAddress).setWhitelistedAddresses(whitelist); IRobinhoodLaunchToken(tokenContractAddress).setCreator(tokenParams[tokenId].creatorAddress); if (amount > 0) { _handleInitialBuyFee(); _buy(amount, tokenId, maxTotalCost, true); } if (_isLpTokenThresholdReached(tokenId)) _createLp(tokenId); } function createToken( uint16 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, address tokenCreatorAddress, uint256 tokenSplit, string memory name, string memory symbol, uint256 amount, uint256 maxTotalCost, uint256 deadline ) public payable whenNotPaused nonReentrant { _checkDeadline(deadline); _createToken( a, b, curveScaler, creatorFeeBasisPoints, tokenCreatorAddress, tokenSplit, name, symbol, amount ); if (amount > 0) { uint256 tokenId = tokenIdentifier - 1; _handleInitialBuyFee(); _buy(amount, tokenId, maxTotalCost, true); if (_isLpTokenThresholdReached(tokenId)) _createLp(tokenId); } } function _createToken( uint16 a, uint8 b, uint128 curveScaler, uint8, address tokenCreatorAddress, uint256 tokenSplit, string memory name, string memory symbol, uint256 amount ) internal { require(tokenCreatorAddress != address(0), "Token creator address must be set"); if (amount == 0) require(msg.value == 0, "Invalid msg.value"); uint256 allowedSupply = allowedTotalSupplyWithParameters(a, b, curveScaler, tokenSplit); require(allowedSupply != 0, "There is no registered token supply"); tokenSupply[tokenIdentifier] = allowedSupply; address tokenContractAddress = tokenFactory.deployToken(name, symbol, tokenIdentifier); TokenParameters storage params = tokenParams[tokenIdentifier]; params.a = a; params.b = b; params.curveScaler = curveScaler; params.creatorFeeBasisPoints = bondingCreatorFeeBasisPoint; params.tokenContractAddress = tokenContractAddress; params.pairAddress = address(0); params.creatorAddress = tokenCreatorAddress; params.lpPercentage = 100 - uint8(tokenSplit); params.salePercentage = uint8(tokenSplit); holderRewardsMode[tokenIdentifier] = 2; delete nextLaunchHolderRewardsDisabled[msg.sender]; emit TokenCreated(tokenIdentifier, params, allowedSupply); // The public entry points perform an optional initial buy only after // all launch configuration (including a whitelist) is active. ++tokenIdentifier; } function _buy( uint256 amount, uint256 tokenId, uint256 maxTotalCost, bool initialBuy ) internal whenNotPaused lpNotDeployed(tokenId) returns (uint256 totalCost) { require(amount % GRANULARITY_SCALER == 0, "Amount must be a multiple of GRANULARITY_SCALER"); amount /= GRANULARITY_SCALER; uint256 currentSupply; { uint256 currentSupplyInWei = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply(); (uint256 maxBuyableAmountInWei, uint256 maxTokensForSaleInWei) = _getMaxTokensForSaleWithSupply(tokenId, currentSupplyInWei); uint256 maxBuyableAmount = maxBuyableAmountInWei / GRANULARITY_SCALER; uint256 maxTokensForSale = maxTokensForSaleInWei / GRANULARITY_SCALER; if (amount > maxBuyableAmount) revert SlippageExceeded(); currentSupply = currentSupplyInWei / GRANULARITY_SCALER; require(currentSupply + amount <= maxTokensForSale, "supply mismatch in buy"); } require(amount > 0, "amount must be greater than 0"); uint256 costs = calculateCostWithSupply(amount, tokenId, currentSupply); FeeData memory feeData = getFeeData(tokenId, costs, msg.sender); if (initialBuy) feeData.totalFeeAmount += tokenCreationBuyFeeAmount; totalCost = feeData.totalFeeAmount + costs; if (totalCost > maxTotalCost) revert SlippageExceeded(); if (totalCost > msg.value) revert InsufficentFunds(); IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).mint( msg.sender, amount * GRANULARITY_SCALER ); tokenBalanceOf[tokenId] += costs; _handleFeeTransfers(feeData, totalCost); emit Buy( msg.sender, tokenId, amount, totalCost, currentSupply + amount, feeData.referrerAddress, feeData.referralFee, feeData.creatorFee, feeData.protocolFee ); } function buyAndCreateLpIfPossible( uint256 amount, uint256 tokenId, uint256 maxTotalCost, uint256 deadline ) public payable nonReentrant { _checkDeadline(deadline); _buy(amount, tokenId, maxTotalCost, false); if (_isLpTokenThresholdReached(tokenId)) _createLp(tokenId); } function sell(uint256 amount, uint256 tokenId, uint256 minNetReward, uint256 deadline) public whenNotPaused nonReentrant lpNotDeployed(tokenId) { _checkDeadline(deadline); require(amount % GRANULARITY_SCALER == 0, "Amount must be a multiple of GRANULARITY_SCALER"); amount /= GRANULARITY_SCALER; require(amount > 0, "amount must be greater than zero"); (uint256 reward, uint256 currentSupply) = calculateRewardAndSupply(amount, tokenId); FeeData memory feeData = getFeeData(tokenId, reward, msg.sender); uint256 netReward = reward - feeData.totalFeeAmount; if (netReward < minNetReward) revert SlippageExceeded(); IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).burn( msg.sender, amount * GRANULARITY_SCALER ); tokenBalanceOf[tokenId] -= reward; _handleFeeTransfers(feeData, 0); payable(msg.sender).transfer(netReward); emit Sell( msg.sender, tokenId, amount, reward, currentSupply - amount, feeData.referrerAddress, feeData.referralFee, feeData.creatorFee, feeData.protocolFee ); } function _createLp(uint256 tokenId) internal { require(canDeployLp, "Lp deploy not allowed right now!"); TokenParameters memory paramsCached = tokenParams[tokenId]; require(!paramsCached.lpDeployed, "Lp already deployed"); tokenParams[tokenId].lpDeployed = true; uint256 allowedMaxSupply = tokenSupply[tokenId]; uint256 onePercent = allowedMaxSupply / 100; uint256 tokenAmount = onePercent * paramsCached.lpPercentage; uint256 nativeAmount = tokenBalanceOf[tokenId]; tokenBalanceOf[tokenId] = 0; if (paramsCached.pairAddress != address(0)) { IRobinhoodLaunchToken(paramsCached.tokenContractAddress).setBlacklistStatus( paramsCached.pairAddress, false ); } IRobinhoodLaunchToken token = IRobinhoodLaunchToken(paramsCached.tokenContractAddress); token.mint(address(this), tokenAmount); IArenaFeeHelperMinimal.Fee[] memory fees = new IArenaFeeHelperMinimal.Fee[](1); V4PoolInitParams memory poolConfig = v4PoolInitParams; fees[0] = IArenaFeeHelperMinimal.Fee({ recipient: paramsCached.creatorAddress, feePpm: poolConfig.creatorFeePpm }); IWETH9Parity(WETH_ADDRESS).deposit{value: nativeAmount}(); token.approve(address(arenaPoolDeployer), tokenAmount); IWETH9Parity(WETH_ADDRESS).approve(address(arenaPoolDeployer), nativeAmount); poolConfig.poolInitParams.recipient = LP_TOKEN_VAULT; poolConfig.poolInitParams.hookData = bytes(""); if (WETH_ADDRESS > paramsCached.tokenContractAddress) { poolConfig.poolInitParams.startingPrice = poolConfig.invertedStartingPrice; int24 tickLowerCached = poolConfig.poolInitParams.tickLower; poolConfig.poolInitParams.tickLower = -poolConfig.poolInitParams.tickUpper; poolConfig.poolInitParams.tickUpper = -tickLowerCached; poolConfig.poolInitParams.token0Amount = tokenAmount; poolConfig.poolInitParams.token1Amount = nativeAmount; poolConfig.poolInitParams.token0 = paramsCached.tokenContractAddress; poolConfig.poolInitParams.token1 = WETH_ADDRESS; } else { poolConfig.poolInitParams.token0Amount = nativeAmount; poolConfig.poolInitParams.token1Amount = tokenAmount; poolConfig.poolInitParams.token0 = WETH_ADDRESS; poolConfig.poolInitParams.token1 = paramsCached.tokenContractAddress; } arenaPoolDeployer.initPoolAndSetFees(poolConfig.poolInitParams, fees); IOwnableLaunchToken(paramsCached.tokenContractAddress).renounceOwnership(); require(token.totalSupply() == allowedMaxSupply, "total supply mismatch"); emit TokenLPCreated(tokenId, tokenAmount, nativeAmount, 0); } function getFeeData(uint256 tokenId, uint256 rawCosts, address user) public view returns (FeeData memory feeData) { feeData.tokenCreator = tokenParams[tokenId].creatorAddress; feeData.referrerAddress = referrerRegistry.getReferrer(user); feeData.protocolFee = (rawCosts * protocolFeeBasisPoint + 5000) / 10000; feeData.creatorFee = (rawCosts * bondingCreatorFeeBasisPoint + 5000) / 10000; feeData.referralFee = (rawCosts * referralFeeBasisPoint + 5000) / 10000; if (feeData.referrerAddress == address(0)) { feeData.protocolFee += feeData.referralFee; feeData.referralFee = 0; } feeData.totalFeeAmount = feeData.protocolFee + feeData.creatorFee + feeData.referralFee; } function _handleFeeTransfers(FeeData memory feeData, uint256 totalCost) internal { uint256 protocolFeeAmount = feeData.protocolFee; if (feeData.referrerAddress != address(0)) { (bool success,) = payable(feeData.referrerAddress).call{ value: feeData.referralFee, gas: 2300 }(""); if (!success) protocolFeeAmount += feeData.referralFee; } if (msg.value > totalCost) payable(msg.sender).transfer(msg.value - totalCost); if (feeData.tokenCreator != address(0) && feeData.creatorFee > 0) { (bool success,) = payable(feeData.tokenCreator).call{ value: feeData.creatorFee, gas: 2300 }(""); if (!success) protocolFeeAmount += feeData.creatorFee; } (bool sentSuccess,) = payable(protocolFeeDestination).call{value: protocolFeeAmount}(""); require(sentSuccess, "Failed to send protocol fee"); } function calculateCost(uint256 amountInToken, uint256 tokenId) public view returns (uint256) { if (amountInToken == 0) return 0; uint256 totalSupply = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply() / GRANULARITY_SCALER; return _integralCeil(tokenId, totalSupply + amountInToken, totalSupply); } function calculateCostWithFees(uint256 amountInToken, uint256 tokenId) public view returns (uint256) { if (amountInToken == 0) return 0; uint256 costs = calculateCost(amountInToken, tokenId); FeeData memory feeData = getFeeData(tokenId, costs, address(0)); return costs + feeData.totalFeeAmount; } function calculateCostWithSupply(uint256 amountInToken, uint256 tokenId, uint256 totalSupply) public view returns (uint256) { if (amountInToken == 0) return 0; return _integralCeil(tokenId, totalSupply + amountInToken, totalSupply); } function calculateCostScaledParametric( uint256 amountInWei, uint256 supplyInWei, uint256 a, uint256 b, uint256 curveScaler ) public pure returns (uint256) { uint256 amountInTokens = amountInWei / GRANULARITY_SCALER; uint256 supplyInTokens = supplyInWei / GRANULARITY_SCALER; uint256 upperBound = supplyInTokens + amountInTokens; uint256 lowerBound = supplyInTokens; uint256 upperSum = (2 * (upperBound ** 3) * a) + (3 * (upperBound ** 2) * b); uint256 lowerSum = (2 * (lowerBound ** 3) * a) + (3 * (lowerBound ** 2) * b); return ((upperSum - lowerSum) + (curveScaler * 6 - 1)) / (curveScaler * 6); } function calculateCostScaledParametricWithFees( uint256 amountInWei, uint256 supplyInWei, uint256 a, uint256 b, uint256 curveScaler, uint256 ) public view returns (uint256) { uint256 rawCosts = calculateCostScaledParametric(amountInWei, supplyInWei, a, b, curveScaler); return rawCosts + ((rawCosts * protocolFeeBasisPoint + 5000) / 10000) + (rawCosts * bondingCreatorFeeBasisPoint + 5000) / 10000 + (rawCosts * referralFeeBasisPoint + 5000) / 10000; } /// @notice Pre-creation quote for an optional initial buy. Unlike the /// tokenId-based quote, this can be called before the launch token exists. /// A zero initial buy remains free, matching existing launcher behavior. function calculateInitialBuyCostScaledParametricWithFees( uint256 amountInWei, uint256 supplyInWei, uint256 a, uint256 b, uint256 curveScaler, uint256 creatorFeeBasisPoints ) external view returns (uint256) { if (amountInWei == 0) return 0; return calculateCostScaledParametricWithFees( amountInWei, supplyInWei, a, b, curveScaler, creatorFeeBasisPoints ) + tokenCreationBuyFeeAmount; } function calculateReward(uint256 amount, uint256 tokenId) public view returns (uint256) { if (amount == 0) return 0; uint256 totalSupply = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply() / GRANULARITY_SCALER; return _integralFloor(tokenId, totalSupply, totalSupply - amount); } function calculateRewardWithFees(uint256 amount, uint256 tokenId) external view returns (uint256) { if (amount == 0) return 0; uint256 reward = calculateReward(amount, tokenId); FeeData memory feeData = getFeeData(tokenId, reward, address(0)); return reward - feeData.totalFeeAmount; } function calculateRewardAndSupply(uint256 amount, uint256 tokenId) public view returns (uint256, uint256) { uint256 totalSupply = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply() / GRANULARITY_SCALER; if (amount == 0) return (0, totalSupply); return (_integralFloor(tokenId, totalSupply, totalSupply - amount), totalSupply); } function _integralFloor(uint256 tokenId, uint256 upperBound, uint256 lowerBound) internal view returns (uint256) { TokenParameters memory params = tokenParams[tokenId]; uint256 upperSum = ((2 * (upperBound ** 3)) * params.a) + (3 * (upperBound ** 2) * params.b); uint256 lowerSum = ((2 * (lowerBound ** 3)) * params.a) + (3 * (lowerBound ** 2) * params.b); return (upperSum - lowerSum) / (uint256(params.curveScaler) * 6); } function _integralCeil(uint256 tokenId, uint256 upperBound, uint256 lowerBound) internal view returns (uint256) { TokenParameters memory params = tokenParams[tokenId]; uint256 upperSum = (2 * (upperBound ** 3) * params.a) + (3 * (upperBound ** 2) * params.b); uint256 lowerSum = (2 * (lowerBound ** 3) * params.a) + (3 * (lowerBound ** 2) * params.b); uint256 denominator = uint256(params.curveScaler) * 6; return ((upperSum - lowerSum) + (denominator - 1)) / denominator; } function allowedTotalSupplyWithParameters(uint16 a, uint8 b, uint128 c, uint256 tokenSplit) public view returns (uint256) { bytes32 parametersHash = keccak256(abi.encodePacked(a, b, c, tokenSplit)); return allowedTokenSupplyWithParameters[parametersHash]; } function getMaxTokensForSale(uint256 tokenId) public view returns (uint256 buyLimit) { uint256 currentSupply = IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply(); (buyLimit,) = _getMaxTokensForSaleWithSupply(tokenId, currentSupply); } function getTokenParameters(uint256 tokenId) external view returns (TokenParameters memory params) { params = tokenParams[tokenId]; params.creatorFeeBasisPoints = bondingCreatorFeeBasisPoint; } function getV4PoolInitParams() external view returns (V4PoolInitParams memory) { return v4PoolInitParams; } function _getMaxTokensForSaleWithSupply(uint256 tokenId, uint256 currentSupplyInWei) internal view returns (uint256 buyLimit, uint256 maxTokensForSale) { uint256 maxSupplyForSale = tokenSupply[tokenId] * tokenParams[tokenId].salePercentage / 100; if (maxSupplyForSale >= currentSupplyInWei) { return (maxSupplyForSale - currentSupplyInWei, maxSupplyForSale); } return (0, maxSupplyForSale); } function _isLpTokenThresholdReached(uint256 tokenId) internal view returns (bool) { return tokenSupply[tokenId] * tokenParams[tokenId].salePercentage == IRobinhoodLaunchToken(tokenParams[tokenId].tokenContractAddress).totalSupply() * 100; } receive() external payable { require(msg.sender == address(uniswapV2Router02), "Only Uniswap V2 Router can send Ether to this contract"); payable(owner()).transfer(msg.value); } function _handleInitialBuyFee() internal { if (tokenCreationBuyFeeAmount == 0) return; if (transferTokenCreationBuyFeeToVault) { (bool success,) = payable(tokenCreationBuyFeeVault).call{ value: tokenCreationBuyFeeAmount }(""); if (!success) revert CreationFeeTransferFailed(); } else { ICreationFeeBuybackAdapter adapter = creationFeeBuybackAdapter; if (address(adapter) == address(0)) revert InvalidCreationFeeBuybackAdapter(); adapter.depositCreationFee{value: tokenCreationBuyFeeAmount}(); } } function _checkDeadline(uint256 deadline) internal view { if (block.timestamp > deadline) revert DeadlineExpired(); } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Create2.sol) pragma solidity ^0.8.20; /** * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer. * `CREATE2` can be used to compute in advance the address where a smart * contract will be deployed, which allows for interesting new mechanisms known * as 'counterfactual interactions'. * * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more * information. */ library Create2 { /** * @dev Not enough balance for performing a CREATE2 deploy. */ error Create2InsufficientBalance(uint256 balance, uint256 needed); /** * @dev There's no code to deploy. */ error Create2EmptyBytecode(); /** * @dev The deployment failed. */ error Create2FailedDeployment(); /** * @dev Deploys a contract using `CREATE2`. The address where the contract * will be deployed can be known in advance via {computeAddress}. * * The bytecode for a contract can be obtained from Solidity with * `type(contractName).creationCode`. * * Requirements: * * - `bytecode` must not be empty. * - `salt` must have not been used for `bytecode` already. * - the factory must have a balance of at least `amount`. * - if `amount` is non-zero, `bytecode` must have a `payable` constructor. */ function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) { if (address(this).balance < amount) { revert Create2InsufficientBalance(address(this).balance, amount); } if (bytecode.length == 0) { revert Create2EmptyBytecode(); } /// @solidity memory-safe-assembly assembly { addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt) } if (addr == address(0)) { revert Create2FailedDeployment(); } } /** * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the * `bytecodeHash` or `salt` will result in a new destination address. */ function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) { return computeAddress(salt, bytecodeHash, address(this)); } /** * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}. */ function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) { /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) // Get free memory pointer // | | ↓ ptr ... ↓ ptr + 0x0B (start) ... ↓ ptr + 0x20 ... ↓ ptr + 0x40 ... | // |-------------------|---------------------------------------------------------------------------| // | bytecodeHash | CCCCCCCCCCCCC...CC | // | salt | BBBBBBBBBBBBB...BB | // | deployer | 000000...0000AAAAAAAAAAAAAAAAAAA...AA | // | 0xFF | FF | // |-------------------|---------------------------------------------------------------------------| // | memory | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC | // | keccak(start, 85) | ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ | mstore(add(ptr, 0x40), bytecodeHash) mstore(add(ptr, 0x20), salt) mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff mstore8(start, 0xff) addr := keccak256(start, 85) } } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {Currency} from "../types/Currency.sol"; import {PoolId} from "../types/PoolId.sol"; import {PoolKey} from "../types/PoolKey.sol"; /// @notice Interface for all protocol-fee related functions in the pool manager interface IProtocolFees { /// @notice Thrown when protocol fee is set too high error ProtocolFeeTooLarge(uint24 fee); /// @notice Thrown when collectProtocolFees or setProtocolFee is not called by the controller. error InvalidCaller(); /// @notice Thrown when collectProtocolFees is attempted on a token that is synced. error ProtocolFeeCurrencySynced(); /// @notice Emitted when the protocol fee controller address is updated in setProtocolFeeController. event ProtocolFeeControllerUpdated(address indexed protocolFeeController); /// @notice Emitted when the protocol fee is updated for a pool. event ProtocolFeeUpdated(PoolId indexed id, uint24 protocolFee); /// @notice Given a currency address, returns the protocol fees accrued in that currency /// @param currency The currency to check /// @return amount The amount of protocol fees accrued in the currency function protocolFeesAccrued(Currency currency) external view returns (uint256 amount); /// @notice Sets the protocol fee for the given pool /// @param key The key of the pool to set a protocol fee for /// @param newProtocolFee The fee to set function setProtocolFee(PoolKey memory key, uint24 newProtocolFee) external; /// @notice Sets the protocol fee controller /// @param controller The new protocol fee controller function setProtocolFeeController(address controller) external; /// @notice Collects the protocol fees for a given recipient and currency, returning the amount collected /// @dev This will revert if the contract is unlocked /// @param recipient The address to receive the protocol fees /// @param currency The currency to withdraw /// @param amount The amount of currency to withdraw /// @return amountCollected The amount of currency successfully withdrawn function collectProtocolFees(address recipient, Currency currency, uint256 amount) external returns (uint256 amountCollected); /// @notice Returns the current protocol fee controller address /// @return address The current protocol fee controller address function protocolFeeController() external view returns (address); }

// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol"; import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol"; import {Currency} from "@uniswap/v4-core/src/types/Currency.sol"; import { IRobinhoodArenaManagerHelper, IRobinhoodHelperPermit2, IRobinhoodHelperUniversalRouter } from "../../helpers/RobinhoodHelperInterfaces.sol"; import {RobinhoodV4SwapExecutor} from "../../helpers/RobinhoodV4SwapExecutor.sol"; /// @notice Native-ETH convenience router for wARENA-paired bonding tokens. /// @dev The manager must authorize this contract through setNativeHelper. contract RobinhoodArenaPairNativeHelper is RobinhoodV4SwapExecutor, ReentrancyGuard { using SafeERC20 for IERC20; IRobinhoodArenaManagerHelper public immutable TOKEN_MANAGER; IERC20 public immutable ARENA; uint24 public immutable POOL_FEE; int24 public immutable TICK_SPACING; address public immutable HOOKS; error InvalidManager(); error InvalidPoolConfiguration(); error TokenTransferFailed(); error NativeTransferFailed(); event BoughtWithNative( address indexed user, uint256 indexed tokenId, uint256 nativeIn, uint256 arenaSpent, uint256 tokenOut ); event SoldToNative( address indexed user, uint256 indexed tokenId, uint256 tokenIn, uint256 arenaIn, uint256 nativeOut ); constructor( IRobinhoodArenaManagerHelper tokenManager_, IRobinhoodHelperUniversalRouter universalRouter_, IRobinhoodHelperPermit2 permit2_, uint24 poolFee_, int24 tickSpacing_, address hooks_ ) RobinhoodV4SwapExecutor(universalRouter_, permit2_) { if (address(tokenManager_) == address(0) || address(tokenManager_).code.length == 0) { revert InvalidManager(); } address arena = tokenManager_.ARENA_ADDRESS(); if (arena == address(0) || arena.code.length == 0) revert InvalidManager(); if (poolFee_ == 0 || tickSpacing_ <= 0) revert InvalidPoolConfiguration(); if (hooks_ != address(0) && hooks_.code.length == 0) { revert InvalidPoolConfiguration(); } TOKEN_MANAGER = tokenManager_; ARENA = IERC20(arena); POOL_FEE = poolFee_; TICK_SPACING = tickSpacing_; HOOKS = hooks_; IERC20(arena).forceApprove(address(tokenManager_), type(uint256).max); } function buyAndCreateLpIfPossibleWithNative( uint256 tokenId, uint256 desiredTokenAmount, uint256 minArenaFromSwap, uint256 deadline ) external payable nonReentrant returns (uint256 tokenOut, uint256 arenaSpent) { uint256 arenaBefore = ARENA.balanceOf(address(this)); uint256 arenaOut = _swapExactInputSingle( _nativeArenaPoolKey(), true, msg.value, minArenaFromSwap, deadline ); IRobinhoodArenaManagerHelper.TokenParameters memory params = TOKEN_MANAGER.getTokenParameters(tokenId); uint256 tokenBefore = IERC20(params.tokenContractAddress).balanceOf(address(this)); TOKEN_MANAGER.buyAndCreateLpIfPossibleWithUser( desiredTokenAmount, tokenId, msg.sender, arenaOut ); tokenOut = IERC20(params.tokenContractAddress).balanceOf(address(this)) - tokenBefore; if (tokenOut == 0) revert TokenTransferFailed(); IERC20(params.tokenContractAddress).safeTransfer(msg.sender, tokenOut); uint256 arenaRefund = ARENA.balanceOf(address(this)) - arenaBefore; arenaSpent = arenaOut - arenaRefund; if (arenaRefund != 0) ARENA.safeTransfer(msg.sender, arenaRefund); emit BoughtWithNative(msg.sender, tokenId, msg.value, arenaSpent, tokenOut); } function sellToNative( uint256 tokenId, uint256 tokenAmount, uint256 minNativeOut, uint256 deadline ) external nonReentrant returns (uint256 nativeOut) { IRobinhoodArenaManagerHelper.TokenParameters memory params = TOKEN_MANAGER.getTokenParameters(tokenId); IERC20 token = IERC20(params.tokenContractAddress); token.safeTransferFrom(msg.sender, address(this), tokenAmount); uint256 arenaBefore = ARENA.balanceOf(address(this)); uint256 arenaOut = TOKEN_MANAGER.sellWithUser( tokenAmount, tokenId, msg.sender, 0 ); uint256 received = ARENA.balanceOf(address(this)) - arenaBefore; if (received != arenaOut) revert TokenTransferFailed(); nativeOut = _swapExactInputSingle( _nativeArenaPoolKey(), false, arenaOut, minNativeOut, deadline ); (bool success,) = payable(msg.sender).call{value: nativeOut}(""); if (!success) revert NativeTransferFailed(); emit SoldToNative(msg.sender, tokenId, tokenAmount, arenaOut, nativeOut); } function nativeArenaPoolKey() external view returns (PoolKey memory) { return _nativeArenaPoolKey(); } function _nativeArenaPoolKey() internal view returns (PoolKey memory) { return PoolKey({ currency0: Currency.wrap(address(0)), currency1: Currency.wrap(address(ARENA)), fee: POOL_FEE, tickSpacing: TICK_SPACING, hooks: IHooks(HOOKS) }); } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {Currency} from "./Currency.sol"; import {IHooks} from "../interfaces/IHooks.sol"; import {PoolIdLibrary} from "./PoolId.sol"; using PoolIdLibrary for PoolKey global; /// @notice Returns the key for identifying a pool struct PoolKey { /// @notice The lower currency of the pool, sorted numerically Currency currency0; /// @notice The higher currency of the pool, sorted numerically Currency currency1; /// @notice The pool LP fee, capped at 1_000_000. If the highest bit is 1, the pool has a dynamic fee and must be exactly equal to 0x800000 uint24 fee; /// @notice Ticks that involve positions must be a multiple of tick spacing int24 tickSpacing; /// @notice The hooks of the pool IHooks hooks; }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /// @title Math library for liquidity library LiquidityMath { /// @notice Add a signed liquidity delta to liquidity and revert if it overflows or underflows /// @param x The liquidity before change /// @param y The delta by which liquidity should be changed /// @return z The liquidity delta function addDelta(uint128 x, int128 y) internal pure returns (uint128 z) { assembly ("memory-safe") { z := add(and(x, 0xffffffffffffffffffffffffffffffff), signextend(15, y)) if shr(128, z) { // revert SafeCastOverflow() mstore(0, 0x93dafdf1) revert(0x1c, 0x04) } } } }