Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.26;

import "./interfaces/IERC20Unsafe.sol";
import "./interfaces/IAggregatorExecutor.sol";
import "./interfaces/IUniswapV2Pool.sol";
import "./interfaces/IUniswapV3Pool.sol";
import "./interfaces/IStCoreEarn.sol";
import "./interfaces/IBalancer.sol";
import "./interfaces/ICurve.sol";
import "./interfaces/IWeth.sol";
import "./interfaces/IUniswapV4PoolManager.sol";
import "./libaries/CalldataDecoder.sol";
import "./libaries/TransientStateLibrary.sol";
import "./libaries/BalanceDelta.sol";

contract AggregatorExecutor is IAggregatorExecutor {
    using CalldataDecoder for uint256;
    using TransientStateLibrary for IUniswapV4PoolManager;
    using BalanceDeltaLibrary for BalanceDelta;

    uint256 public constant VERSION = 1;

    uint32 constant CALLBACK_IDENTIFIER = 0xd37ac04b; // random value used to signal where our data starts in callbacks
    uint8 constant CALLBACK_TYPE_V3_SIMPLE = 0x01;
    uint8 constant CALLBACK_TYPE_V3_ADVANCED = 0x02;
    uint8 constant CALLBACK_TYPE_V2_ADVANCED = 0x03;
    uint8 constant CALLBACK_TYPE_V4_ADVANCED = 0x04;

    error TokenAmountRevert(uint256 outBeforeTaxes, uint256 outAfterTaxes);
    error SqrtPriceNotFound(address pool);

    event RevenueCaptured(
        address indexed token,
        uint256 amount,
        uint256 kind
    );

    receive() external payable {}

    fallback(bytes calldata) external returns (bytes memory) {
        uint256 identifierStart = 4;
        uint32 slotIdentifier;
        while (true) {
            assembly {
                slotIdentifier := shr(224, calldataload(identifierStart))
            }
            if (slotIdentifier == CALLBACK_IDENTIFIER) {
                break;
            }
            identifierStart += 32;
        }

        uint8 callbackType;
        assembly {
            callbackType := shr(248, calldataload(add(identifierStart, 4)))
        }

        if (callbackType == CALLBACK_TYPE_V3_SIMPLE || callbackType == CALLBACK_TYPE_V3_ADVANCED) {
            // v3 simple + advanced
            address repayTokenAddress;
            assembly {
                repayTokenAddress := shr(96, calldataload(add(identifierStart, 5)))
            }
            require(identifierStart == 4+4*32, "Incorrect V3Advanced callback");
            int256 amount0;
            int256 amount1;
            assembly {
                amount0 := calldataload(4)
                amount1 := calldataload(36)
            }
            uint256 amountToRepay = uint256(amount0 > 0 ? amount0 : amount1);

            if (callbackType == CALLBACK_TYPE_V3_ADVANCED) {
                executeOpcodes(identifierStart + 25, address(this), uint256(amount0 > 0 ? -amount1 : -amount0), amountToRepay);
            }

            IERC20Unsafe(repayTokenAddress).transfer(msg.sender, amountToRepay);
        } else if (callbackType == CALLBACK_TYPE_V2_ADVANCED) {
            // v2 advanced
            address repayTokenAddress;
            assembly {
                repayTokenAddress := shr(96, calldataload(add(identifierStart, 5)))
            }
            require(identifierStart == 4+5*32, "Incorrect V2Advanced callback");
            uint256 amount0;
            uint256 amount1;
            uint256 amountIn;
            assembly {
                amount0 := calldataload(36)
                amount1 := calldataload(68)
                amountIn := calldataload(add(identifierStart, 25))
            }

            executeOpcodes(identifierStart + 25 + 32, address(this), uint256(amount0 > 0 ? amount0 : amount1), amountIn);

            IERC20Unsafe(repayTokenAddress).transfer(msg.sender, amountIn);
        } else if (callbackType == CALLBACK_TYPE_V4_ADVANCED) {
            // V4 Callback
            executeOpcodes(identifierStart + 5, msg.sender, uint256(0), uint256(0));
            return abi.encode("");
        } else {
            revert("Unknown callback");
        }

        return "";
    }

    function executeSwap(bytes calldata) external payable {
        address lastToAddress;
        uint256 lastAmountOut;
        assembly {
            lastToAddress := shr(96, calldataload(101))
            lastAmountOut := shr(128, calldataload(68))
        }
        executeOpcodes(100, lastToAddress, lastAmountOut, 0);
    }

    function executeOpcodes(uint256 opcodeStart, address lastToAddress, uint256 lastAmountOut, uint256 amountToRepay) internal {
        uint256 decoder = CalldataDecoder.createDecoder(opcodeStart);

        // None of the memory allocated inside the loop is required after the loop finishes.
        // As solidity never reclaims memory, leading to higher memory expansion gas cost, we could reset the free memory pointer after each iteration
        while (true) {
            require(decoder.notEmpty(), "Opcode oob");
            uint8 command = decoder.readUint8();
            if (command < 64) { // [0-63] 6 flags
                // V2 Swap
                address to = address(this);
                bool zeroForOne;
                bytes memory data;
                uint256 fee_bps = 30;

                if (command & 0x01 != 0) lastToAddress = decoder.readAddress(); // !useLastTo
                (uint112 reserve0, uint112 reserve1,) = IUniswapV2Pool(lastToAddress).getReserves();
                if (command & 0x02 != 0) to = decoder.readAddress(); // !sendToRouter
                zeroForOne = command & 0x04 != 0;  // zeroForOne
                if (command & 0x08 != 0) { // readPoolBalance
                    uint256 balance = IERC20Unsafe(decoder.readAddress()).balanceOf(lastToAddress);
                    if (balance >= (zeroForOne ? reserve0 : reserve1)) {
                        lastAmountOut = balance - (zeroForOne ? reserve0 : reserve1);
                    } else {
                        // special case for virtual liquidity pools where the token is not actually held by the swap contract
                        lastAmountOut = balance;
                    }
                }
                if (command & 0x10 != 0) { // customFee
                    fee_bps = decoder.readUint16();
                }
                if (command & 0x20 != 0) { // forwardCalldata
                    lastAmountOut = decoder.readUint256Compact();
                    address tokenInAddress = decoder.readAddress();
                    data = abi.encodePacked(
                        CALLBACK_IDENTIFIER,
                        CALLBACK_TYPE_V2_ADVANCED,
                        tokenInAddress,
                        lastAmountOut,
                        decoder.readBytes(decoder.readUint16())
                    );
                }

                (uint256 reserveIn, uint256 reserveOut) = zeroForOne ? (reserve0, reserve1) : (reserve1, reserve0);
                uint256 amountInWithFee = (lastAmountOut - 1) * (10_000 - fee_bps);
                lastAmountOut = (amountInWithFee * reserveOut) / (reserveIn * 10_000 + amountInWithFee);

                IUniswapV2Pool(lastToAddress).swap(
                    zeroForOne? 0 : lastAmountOut,
                    zeroForOne? lastAmountOut : 0,
                    to,
                    data
                );

                lastToAddress = to;
            } else if (command < 96) { // [64-95] 5 flags
                // V3 Swap
                address poolAddress = decoder.readAddress();
                address tokenInAddress = decoder.readAddress();
                lastToAddress = address(this);
                bool zeroForOne;
                bytes memory data;

                if (command & 0x01 != 0) lastToAddress = decoder.readAddress(); // !sendToRouter
                zeroForOne = command & 0x02 != 0;  // zeroForOne
                if (command & 0x04 != 0) lastAmountOut = IERC20Unsafe(tokenInAddress).balanceOf(address(this)); // readRouterBalance
                if (command & 0x08 != 0) lastAmountOut = lastAmountOut * decoder.readUint16() / 0xffff; // partial
                if (command & 0x10 != 0) { // forwardCalldata
                    lastAmountOut = decoder.readUint256Compact();
                    data = abi.encodePacked(
                        CALLBACK_IDENTIFIER,
                        CALLBACK_TYPE_V3_ADVANCED,
                        tokenInAddress,
                        decoder.readBytes(decoder.readUint16())
                    );
                } else {
                    data = abi.encodePacked(
                        CALLBACK_IDENTIFIER,
                        CALLBACK_TYPE_V3_SIMPLE,
                        tokenInAddress
                    );
                }

                (int256 amount0, int256 amount1) = IUniswapV3Pool(poolAddress).swap(
                    lastToAddress,
                    zeroForOne,
                    int256(lastAmountOut - 1),
                    zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341, // min/max sqrt ratio
                    data
                );

                lastAmountOut = uint256(-(zeroForOne? amount1 : amount0));
            } else if (command < 104) { // [96-103] 3 flags
                // Balancer Swap
                lastToAddress = decoder.readAddress();
                uint8 tokenIndexes = decoder.readUint8();
                uint8 tokenIndexFrom = tokenIndexes >> 4;
                uint8 tokenIndexTo = tokenIndexes & 0x0f;

                if (command & (0x01 + 0x02) != 0) {
                    address tokenInAddress = decoder.readAddress();
                    if (command & 0x01 != 0) IERC20Unsafe(tokenInAddress).approve(lastToAddress, type(uint256).max); // needApproval
                    if (command & 0x02 != 0) lastAmountOut = IERC20Unsafe(tokenInAddress).balanceOf(address(this)); // readRouterBalance
                }
                if (command & 0x04 != 0) lastAmountOut = lastAmountOut * decoder.readUint16() / 0xffff; // partial

                try ICurve(lastToAddress).ma_exp_time() {
                    lastAmountOut = ICurve(lastToAddress).exchange(int128(uint128(tokenIndexFrom)), int128(uint128(tokenIndexTo)), lastAmountOut - 1, 0);
                } catch {
                    lastAmountOut = IBalancer(lastToAddress).swap(tokenIndexFrom, tokenIndexTo, lastAmountOut - 1, 0, block.timestamp);
                }

                lastToAddress = address(this);
            } else if (command < 112) { // [104-111] 3 flag
                // Unwrap
                address wEthAddress = decoder.readAddress();

                if (command & 0x01 != 0) lastAmountOut = IERC20Unsafe(wEthAddress).balanceOf(address(this)); // readRouterBalance
                if (command & 0x02 != 0) lastAmountOut = amountToRepay + 5; // unwrapRepayAmount
                if (command & 0x04 != 0) lastAmountOut = lastAmountOut * decoder.readUint16() / 0xffff; // partial

                lastAmountOut -= 1;
                IWeth(wEthAddress).withdraw(lastAmountOut);
            } else if (command < 116) { // [112-115] 2 flags
                // Transfer Token
                address tokenAddress = decoder.readAddress();
                lastToAddress = decoder.readAddress();

                if (command & 0x01 != 0) { // readRouterBalance
                    lastAmountOut = IERC20Unsafe(tokenAddress).balanceOf(address(this));
                    if (lastAmountOut > 1) lastAmountOut -= 1;
                }
                if (command & 0x02 != 0) lastAmountOut = lastAmountOut * decoder.readUint16() / 0xffff; // partial

                if (lastAmountOut > 0) IERC20Unsafe(tokenAddress).transfer(lastToAddress, lastAmountOut);
            } else if (command < 120) { // [116-119] 2 flag
                // Wrap
                address payable wEthAddress = payable(decoder.readAddress());
                lastAmountOut = address(this).balance;

                if (command & 0x01 != 0) lastAmountOut = lastAmountOut * decoder.readUint16() / 0xffff; // partial

                lastAmountOut -= 1;
                IWeth(wEthAddress).deposit{value: lastAmountOut}();

                if (command & 0x02 != 0) { // transfer
                    lastAmountOut -= 1;
                    lastToAddress = decoder.readAddress();
                    IERC20Unsafe(wEthAddress).transfer(lastToAddress, lastAmountOut);
                }
            } else if (command < 124) { // [120-123] 2 flags
                // V4 Swap
                address token0 = decoder.readAddress();
                address token1 = decoder.readAddress();

                PoolKey memory poolKey = PoolKey({
                    currency0: token0,
                    currency1: token1,
                    fee: decoder.readUint24(),
                    tickSpacing: int24(decoder.readUint24()),
                    hooks: decoder.readAddress()
                });

                bool zeroForOne = command & 0x01 != 0;  // zeroForOne

                if (command & 0x02 != 0) { // readPoolBalance
                    lastAmountOut = uint256(IUniswapV4PoolManager(lastToAddress).currencyDelta(address(this), IERC20Unsafe(zeroForOne ? token0 : token1)));
                } else if (amountToRepay == 0) {
                    amountToRepay = lastAmountOut;
                }

                BalanceDelta swapDelta = IUniswapV4PoolManager(lastToAddress).swap(poolKey, SwapParams({
                    zeroForOne: zeroForOne,
                    amountSpecified: -int256(lastAmountOut),
                    sqrtPriceLimitX96: zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341 // min/max sqrt ratio
                }), "");

                lastAmountOut = uint256(uint128(zeroForOne ? swapDelta.amount1() : swapDelta.amount0()));
            } else if (command < 126) { // [124-125] 1 flag
                // Transfer Native
                lastToAddress = decoder.readAddress();
                lastAmountOut = address(this).balance;

                if (command & 0x01 != 0) lastAmountOut = lastAmountOut * decoder.readUint16() / 0xffff; // partial

                lastAmountOut -= 1;
                (bool sent,) = lastToAddress.call{value: lastAmountOut}("");
                require(sent, "Transfer Native failed");
            } else if (command < 128) { // [126-127] 1 flag
                // transfer surplus
                address tokenAddress = decoder.readAddress();
                uint256 amountToKeep = decoder.readUint256Compact() + 1;
                lastToAddress = decoder.readAddress();
                uint16 decreaseTs = decoder.readUint16();
                uint8 decreaseFraction = decoder.readUint8(); // 10 equals 1bip. Max value is 0.256%

                uint256 revenueType = 1;
                if (decreaseFraction != 0 && (block.timestamp & 0xFFFF) > decreaseTs) { // small chance this check is incorrect when wrapping around, but this is ok
                    amountToKeep = amountToKeep * (100_000 - decreaseFraction) / 100_000;
                    revenueType = 2;
                }

                if (command & 0x01 != 0) lastAmountOut = IERC20Unsafe(tokenAddress).balanceOf(address(this)); // readRouterBalance

                if (lastAmountOut > amountToKeep) {
                    uint256 revenueAmount = lastAmountOut - amountToKeep;
                    IERC20Unsafe(tokenAddress).transfer(lastToAddress, revenueAmount);
                    lastAmountOut = amountToKeep;
                    emit RevenueCaptured(tokenAddress, revenueAmount, revenueType);
                }
            } else if (command < 130) { // [128-129] 1 flag
                // require UniswapV2 ratio
                address poolAddress = decoder.readAddress();
                uint256 thresholdRatio = decoder.readUint256Compact();
                bool zeroForOne = command & 0x01 != 0;  // zeroForOne

                (uint112 reserve0, uint112 reserve1,) = IUniswapV2Pool(poolAddress).getReserves();
                require((zeroForOne? (uint256(reserve1) << 128) / reserve0 : (uint256(reserve0) << 128) / reserve1) > thresholdRatio, "OOR V2");
            } else if (command < 132) { // [130-131] 1 flag
                // require UniswapV3 ratio
                address poolAddress = decoder.readAddress();
                uint256 thresholdRatio = decoder.readUint256Compact();
                bool zeroForOne = command & 0x01 != 0;  // zeroForOne

                uint160 sqrtPriceX96 = _sqrtPriceX96(poolAddress);
                require((zeroForOne? sqrtPriceX96 > thresholdRatio : sqrtPriceX96 < thresholdRatio), "OOR V3");
            } else if (command < 134) { // [132-133] 1 flags
                // V4 Take Credit
                address currencyAddress = decoder.readAddress();
                address to = address(this);
                if (command & 0x01 != 0) to = decoder.readAddress(); // !sendToRouter
                IUniswapV4PoolManager(lastToAddress).take(currencyAddress, to, lastAmountOut);
            } else if (command < 136) { // [134-135] 1 flags
                // V4 Swap Settle
                uint256 value = (command & 0x01 != 0) ? lastAmountOut : 0; // native
                lastAmountOut = IUniswapV4PoolManager(lastToAddress).settle{value: value}();
            } else if (command < 242) { // [136-241]
                // unused opcodes, only single bit opcodes afterwards
                revert("Invalid Opcode");
            } else if (command < 243) { // [242] 0 flags
                // split amount
                lastAmountOut = lastAmountOut * decoder.readUint16() / 0xffff;
            } else if (command < 244) { // [243] 0 flags
                // read ERC20 balance
                lastAmountOut = IERC20Unsafe(decoder.readAddress()).balanceOf(address(this));
                if (lastAmountOut > 0) lastAmountOut -= 1;
            } else if (command < 245) { // [244] 0 flags
                // read native balance
                lastAmountOut = address(this).balance;
                if (lastAmountOut > 0) lastAmountOut -= 1;
            } else if (command < 246) { // [245] 0 flags
                // V4 Swap Sync
                address tokenAddress = decoder.readAddress();
                IUniswapV4PoolManager(lastToAddress).sync(tokenAddress);
            } else if (command < 247) { // [246] 0 flags
                // V4 Read Debt
                address tokenAddress = decoder.readAddress();
                lastAmountOut = uint256(-IUniswapV4PoolManager(lastToAddress).currencyDelta(address(this), IERC20Unsafe(tokenAddress)));
            } else if (command < 248) { // [247] 0 flags
                // V4 Read Credit
                address tokenAddress = decoder.readAddress();
                lastAmountOut = uint256(IUniswapV4PoolManager(lastToAddress).currencyDelta(address(this), IERC20Unsafe(tokenAddress)));
            } else if (command < 249) { // [248] 0 flags
                // Set lastToAddress
                lastToAddress = decoder.readAddress();
            } else if (command < 250) { // [249] 0 flags
                // set lastAmountOut
                lastAmountOut = decoder.readUint256Compact();
            }  else if (command < 251) { // [250] 0 flags
                // V4 unlock
                lastToAddress = decoder.readAddress();
                bytes memory data;
                data = abi.encodePacked(
                    CALLBACK_IDENTIFIER,
                    CALLBACK_TYPE_V4_ADVANCED,
                    decoder.readBytes(decoder.readUint16())
                );
                IUniswapV4PoolManager(lastToAddress).unlock(data);
            } else if (command < 252) { // [251] 0 flags
                // require address(this).value
                uint8 flags = decoder.readUint8();
                uint16 expectedBalance = decoder.readUint16();
                require(flags & 0x01 != 0 ? address(this).balance % 65535 == expectedBalance : address(this).balance % 65535 != expectedBalance, "IB");
            } else if (command < 253) { // [252] 0 flags
                // require block.coinbase
                uint8 flags = decoder.readUint8();
                // address is xor'ed with a random hardcoded address to make sure it can not easily be detected in calldata
                address expectedValidatorAddress = address(uint160(decoder.readAddressRaw()) ^ 0x0077162b8ade1458b7eb153cdba945af4175b7b192);
                require(flags & 0x01 != 0 ? block.coinbase == expectedValidatorAddress : block.coinbase != expectedValidatorAddress, "IC");
            } else if (command < 254) { // [253] 0 flags
                // Stake StCore
                uint8 flags = decoder.readUint8();
                IStCoreEarn stCoreEarn = IStCoreEarn(decoder.readAddress());
                address validator = payable(decoder.readAddress());

                lastAmountOut = address(this).balance;
                if (flags & 0x01 != 0) lastAmountOut = lastAmountOut * decoder.readUint16() / 0xffff; // partial

                stCoreEarn.mint{value: lastAmountOut-1}(validator);

                lastAmountOut = 0;
                lastToAddress = address(this);
            } else if (command < 255) { // [254] 0 flags
                // Revert token amount
                address tokenAddress = decoder.readAddress();
                uint256 balance = IERC20Unsafe(tokenAddress).balanceOf(address(this));
                revert TokenAmountRevert(lastAmountOut, balance);
            } else { // [255] 0 flags
                // Stop
                // stops the interpreter and returns, each executeOpcodes bytes array ends with the stop opcode
                return;
            }
        }
    }

    // Read just the first 32-byte return word of slot0() and take the low 160 bits.
    // Works across many V3 forks that changed slot0's full signature/return tuple.
    function _sqrtPriceX96(address pool) internal view returns (uint160 s) {
        assembly {
            // Free memory pointer
            let ptr := mload(0x40)

            // -------------------
            // 1. Try slot0()
            // -------------------
            mstore(ptr, shl(224, 0x3850c7bd)) // selector slot0()

            let ok := staticcall(gas(), pool, ptr, 4, 0, 0)
            let rsz := returndatasize()

            if and(ok, iszero(lt(rsz, 32))) {
                returndatacopy(ptr, 0, 32)
                s := and(mload(ptr), 0xffffffffffffffffffffffffffffffffffffffff)
            }

            // -------------------
            // 2. If slot0 failed, try globalState()
            // -------------------
            if iszero(s) {
                mstore(ptr, shl(224, 0xe76c01e4)) // selector globalState()

                ok := staticcall(gas(), pool, ptr, 4, 0, 0)
                rsz := returndatasize()

                if and(ok, iszero(lt(rsz, 32))) {
                    returndatacopy(ptr, 0, 32)
                    s := and(mload(ptr), 0xffffffffffffffffffffffffffffffffffffffff)
                }
            }

            // -------------------
            // 3. If both failed, revert with custom error
            // -------------------
            if iszero(s) {
                mstore(0x00, 0x9d770d77) // bytes4(keccak256("SqrtPriceNotFound(address)"))
                mstore(0x04, pool)
                revert(0x00, 0x24)
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/// @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;



/// @notice Library for getting the amount0 and amount1 deltas from the BalanceDelta type
library BalanceDeltaLibrary {

    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
pragma solidity ^0.8.24;

import {IUniswapV4PoolManager} from "../interfaces/IUniswapV4PoolManager.sol";
import "../interfaces/IERC20Unsafe.sol";


/// @notice A helper library to provide state getters that use exttload
library TransientStateLibrary {

    /// @notice Get the current delta for a caller in the given currency
    /// @param target The credited account address
    /// @param currency The currency for which to lookup the delta
    function currencyDelta(IUniswapV4PoolManager manager, address target, IERC20Unsafe currency) internal view returns (int256) {
        bytes32 key;
        assembly ("memory-safe") {
            mstore(0, and(target, 0xffffffffffffffffffffffffffffffffffffffff))
            mstore(32, and(currency, 0xffffffffffffffffffffffffffffffffffffffff))
            key := keccak256(0, 64)
        }
        return int256(uint256(manager.exttload(key)));
    }

}

// SPDX-License-Identifier: UNLICENSED

pragma solidity 0.8.26;

library CalldataDecoder {
  function createDecoder(uint256 calldataOffset) internal pure returns (uint256 decoder) {
    assembly {
      // use 2 memory words for pointers towards next opcode (decoder) and towards the array where the addresses are stored
      decoder := mload(0x40)
      let addressArray := add(decoder, 32)
      mstore(0x40, add(decoder, 64))

      // first calldata byte defines the number of addresses in the address array
      let numAddresses := shr(248, calldataload(calldataOffset))

      // stores the two pointers in memory, decoder starts after the address array
      mstore(addressArray, add(calldataOffset, 1))
      mstore(decoder, add(add(calldataOffset, 1), mul(numAddresses, 20)))
    }
  }

  function notEmpty(uint256 decoder) internal pure returns (bool) {
    uint256 pos;
    assembly {
      pos := mload(decoder)
    }
    return pos < msg.data.length;
  }

  function readUint8(uint256 decoder) internal pure returns (uint8 res) {
    assembly {
      let pos := mload(decoder)
      res := shr(248, calldataload(pos))
      mstore(decoder, add(pos, 1))
    }
  }

  function readUint16(uint256 decoder) internal pure returns (uint16 res) {
    assembly {
      let pos := mload(decoder)
      res := shr(240, calldataload(pos))
      mstore(decoder, add(pos, 2))
    }
  }

  function readUint24(uint256 decoder) internal pure returns (uint24 res) {
    assembly {
      let pos := mload(decoder)
      res := shr(232, calldataload(pos))
      mstore(decoder, add(pos, 3))
    }
  }

  function readUint32(uint256 decoder) internal pure returns (uint32 res) {
    assembly {
      let pos := mload(decoder)
      res := shr(224, calldataload(pos))
      mstore(decoder, add(pos, 4))
    }
  }

  function readUint128(uint256 decoder) internal pure returns (uint128 res) {
    assembly {
      let pos := mload(decoder)
      res := shr(128, calldataload(pos))
      mstore(decoder, add(pos, 16))
    }
  }

  function readUint256(uint256 decoder) internal pure returns (uint256 res) {
    assembly {
      let pos := mload(decoder)
      res := calldataload(pos)
      mstore(decoder, add(pos, 32))
    }
  }

  function readUint256Compact(uint256 decoder) internal pure returns (uint256 res) {
    // very efficient way to store numbers representing up to uint256 in just 3 bytes with precision of 1/32k
    assembly {
      let pos := mload(decoder)
      let exponent := shr(248, calldataload(pos))
      let mantissa  := shr(240, calldataload(add(pos, 1)))
      res := shl(exponent, mantissa)
      mstore(decoder, add(pos, 3))
    }
  }

  function readBytes32(uint256 decoder) internal pure returns (bytes32 res) {
    assembly {
      let pos := mload(decoder)
      res := calldataload(pos)
      mstore(decoder, add(pos, 32))
    }
  }

  function readAddressRaw(uint256 decoder) internal pure returns (address res) {
    assembly {
      let pos := mload(decoder)
      res := shr(96, calldataload(pos))
      mstore(decoder, add(pos, 20))
    }
  }
  
  function readAddress(uint256 decoder) internal pure returns (address res) {
    // address is stored as uint8 index of the address array rather than in raw format
    assembly {
      let pos := mload(decoder)
      let addressIndex := shr(248, calldataload(pos))
      mstore(decoder, add(pos, 1))
      let addressArray := mload(add(decoder, 32))
      res := shr(96, calldataload(add(addressArray, mul(addressIndex, 20))))
    }
  }

  function readBytes(uint256 decoder, uint256 numBytes) internal pure returns (bytes memory res) {
    uint256 pos;
    assembly {
      pos := mload(decoder)
      mstore(decoder, add(pos, numBytes))
    }
    return msg.data[pos:pos+numBytes];
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "../libaries/BalanceDelta.sol";


struct PoolKey {
    /// @notice The lower currency of the pool, sorted numerically
    address currency0;
    /// @notice The higher currency of the pool, sorted numerically
    address 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
    address hooks;
}

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;
}


interface IUniswapV4PoolManager {
    /// @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 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 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(address 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 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);


    /// @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(address currency) external;

}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

interface IWeth {
    function deposit() external payable;
    function withdraw(uint256) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;


interface ICurve {
    function ma_exp_time() external view returns (uint256);
    function exchange(int128 i, int128 j, uint256 _dx, uint256 _min_dy) external returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;


interface IBalancer {
    function swap(uint8 tokenIndexFrom, uint8 tokenIndexTo, uint256 dx, uint256 minDy, uint256 deadline) external returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;


interface IStCoreEarn {
    function mint(address _validator) external payable;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;


interface IUniswapV3Pool {
    /// @notice The 0th storage slot in the pool stores many values, and is exposed as a single method to save gas
    /// when accessed externally.
    /// @return sqrtPriceX96 The current price of the pool as a sqrt(token1/token0) Q64.96 value
    /// tick The current tick of the pool, i.e. according to the last tick transition that was run.
    /// This value may not always be equal to SqrtTickMath.getTickAtSqrtRatio(sqrtPriceX96) if the price is on a tick
    /// boundary.
    /// observationIndex The index of the last oracle observation that was written,
    /// observationCardinality The current maximum number of observations stored in the pool,
    /// observationCardinalityNext The next maximum number of observations, to be updated when the observation.
    /// feeProtocol The protocol fee for both tokens of the pool.
    /// Encoded as two 4 bit values, where the protocol fee of token1 is shifted 4 bits and the protocol fee of token0
    /// is the lower 4 bits. Used as the denominator of a fraction of the swap fee, e.g. 4 means 1/4th of the swap fee.
    /// unlocked Whether the pool is currently locked to reentrancy
    function slot0()
        external
        view
        returns (
            uint160 sqrtPriceX96,
            int24 tick,
            uint16 observationIndex,
            uint16 observationCardinality,
            uint16 observationCardinalityNext,
            uint8 feeProtocol,
            bool unlocked
        );
    
    /// @notice Swap token0 for token1, or token1 for token0
    /// @dev The caller of this method receives a callback in the form of IUniswapV3SwapCallback#uniswapV3SwapCallback
    /// @param recipient The address to receive the output of the swap
    /// @param zeroForOne The direction of the swap, true for token0 to token1, false for token1 to token0
    /// @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
    /// @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this
    /// value after the swap. If one for zero, the price cannot be greater than this value after the swap
    /// @param data Any data to be passed through to the callback
    /// @return amount0 The delta of the balance of token0 of the pool, exact when negative, minimum when positive
    /// @return amount1 The delta of the balance of token1 of the pool, exact when negative, minimum when positive
    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bytes calldata data
    ) external returns (int256 amount0, int256 amount1);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;


interface IUniswapV2Pool {
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

interface IAggregatorExecutor {
    function executeSwap(bytes calldata swapData) external payable;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;


interface IERC20Unsafe {
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);

    // no return bool for backwards compatibility with older ERC20 tokens
    // caller need to make sure token transfers which do not revert on failure are tolerable
    function transfer(address recipient, uint256 amount) external;

    // same left out return bool as transfer
    function transferFrom(address sender, address recipient, uint256 amount) external;

    // same left out return bool as transfer
    function approve(address spender, uint256 value) external;
}