Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import {Predeploys} from '@eth-optimism-bedrock/src/libraries/Predeploys.sol';
import {SafeCall} from '@eth-optimism-bedrock/src/libraries/SafeCall.sol';

import {IFeeSplitter} from '../interfaces/FeeSplitter/IFeeSplitter.sol';
import {IFeeVault} from '../interfaces/optimism/IFeeVault.sol';

/// @title FeeSplitter
/// @dev Withdraws funds from system FeeVault contracts, shares revenue with Optimism, sends remaining revenue to L1 and net fee recipients
contract FeeSplitter is IFeeSplitter {
    // bytes32(uint256(keccak256('lock')) - 1);
    bytes32 private constant LOCK_STORAGE_SLOT = 0x6168652c307c1e813ca11cfb3a601f1cf3b22452021a5052d8b05f1f1f8a3e91;
    // bytes32(uint256(keccak256('net.revenue')) - 1);
    bytes32 private constant NET_REVENUE_STORAGE_SLOT =
        0x784be9e5da62c580888dd777e3d4e36ef68053ef5af2fc8f65c4050e4729e434;

    uint32 internal constant BASIS_POINT_SCALE = 1000;
    uint32 internal constant NET_REVENUE_SHARE = 150;
    uint32 internal constant GROSS_REVENUE_SHARE = 25;

    /// @dev The address of the Optimism wallet that will receive Optimism's revenue share.
    address public immutable OPTIMISM_WALLET;

    /// @dev The address of the Rewards Distributor that will receive a share of fees;
    address public immutable NET_FEE_RECIPIENT;

    /// @dev The address of the L1 wallet that will receive the OP chain runner's share of fees.
    address public immutable L1_FEE_RECIPIENT;

    /// @dev Constructor for the FeeSplitter contract which validates and sets immutable variables.
    /// @param optimismWallet The address which receives Optimism's revenue share.
    /// @param l1FeeRecipient The address which receives the L1 fee share.
    /// @param netFeeRecipient The address which receives the net fee share.
    constructor(address optimismWallet, address l1FeeRecipient, address netFeeRecipient) {
        if (optimismWallet == address(0) || netFeeRecipient == address(0) || l1FeeRecipient == address(0)) {
            revert AddressZero();
        }
        OPTIMISM_WALLET = optimismWallet;
        NET_FEE_RECIPIENT = netFeeRecipient;
        L1_FEE_RECIPIENT = l1FeeRecipient;
    }

    /// @inheritdoc IFeeSplitter
    function distributeFees() external virtual returns (bool feesDistributed) {
        if (
            Predeploys.SEQUENCER_FEE_WALLET.balance < IFeeVault(Predeploys.SEQUENCER_FEE_WALLET).minWithdrawalAmount()
                || Predeploys.BASE_FEE_VAULT.balance < IFeeVault(Predeploys.BASE_FEE_VAULT).minWithdrawalAmount()
                || Predeploys.L1_FEE_VAULT.balance < IFeeVault(Predeploys.L1_FEE_VAULT).minWithdrawalAmount()
        ) {
            // only collect fees if all fee vaults can be withdrawn from to guarantee accurate accounting of optimism revenue share
            emit NoFeesCollected();
            return false;
        }

        // unlock
        assembly ("memory-safe") {
            tstore(LOCK_STORAGE_SLOT, 1)
        }
        _feeVaultWithdrawal(Predeploys.SEQUENCER_FEE_WALLET);
        _feeVaultWithdrawal(Predeploys.BASE_FEE_VAULT);
        _feeVaultWithdrawal(Predeploys.L1_FEE_VAULT);

        // lock
        assembly ("memory-safe") {
            tstore(LOCK_STORAGE_SLOT, 0)
        }

        uint256 netFeeRevenue;
        uint256 grossFeeRevenue = address(this).balance;

        assembly ("memory-safe") {
            netFeeRevenue := tload(NET_REVENUE_STORAGE_SLOT)
            tstore(NET_REVENUE_STORAGE_SLOT, 0)
        }

        /// @audit gas savings if min withdrawal amount is set to 0
        if (grossFeeRevenue == 0) {
            emit NoFeesCollected();
            return false;
        }

        uint256 netRevenueShare = netFeeRevenue * NET_REVENUE_SHARE / BASIS_POINT_SCALE;
        uint256 grossRevenueShare = grossFeeRevenue * GROSS_REVENUE_SHARE / BASIS_POINT_SCALE;

        uint256 optimismRevenueShare;
        uint256 l1Fee;
        uint256 remainingNetRevenue;
        if (grossRevenueShare > netRevenueShare) {
            // if the gross revenue share is greater than the net revenue share, 2.5% of the gross revenue is sent to optimism
            // the remaining 97.5% of the L1 fees are sent to L1
            // the remaining 97.5% of the net fees are sent to the net fee recipient
            optimismRevenueShare = grossRevenueShare;
            l1Fee = (grossFeeRevenue - netFeeRevenue) * (BASIS_POINT_SCALE - GROSS_REVENUE_SHARE) / BASIS_POINT_SCALE;
            remainingNetRevenue = netFeeRevenue * (BASIS_POINT_SCALE - GROSS_REVENUE_SHARE) / BASIS_POINT_SCALE;
        } else {
            // if the net revenue share is greater than the gross revenue share, 15% of the net revenue is sent to optimism
            // the entire amount of L1 fees are sent to L1
            // the remaining 85% of the net fees are sent to the net fee recipient
            optimismRevenueShare = netRevenueShare;
            l1Fee = grossFeeRevenue - netFeeRevenue;
            remainingNetRevenue = netFeeRevenue - optimismRevenueShare;
        }

        if (!SafeCall.send(OPTIMISM_WALLET, gasleft(), optimismRevenueShare)) revert TransferFailed();

        if (!SafeCall.send(L1_FEE_RECIPIENT, gasleft(), l1Fee)) revert TransferFailed();

        if (!SafeCall.send(NET_FEE_RECIPIENT, gasleft(), remainingNetRevenue)) revert TransferFailed();

        emit FeesDistributed(optimismRevenueShare, l1Fee, remainingNetRevenue);
        return true;
    }

    /// @dev Receives ETH fees withdrawn from L2 FeeVaults and stores the net revenue in transient storage.
    /// @dev Will revert if ETH is not sent from L2 FeeVaults.
    /// @dev anyone can call the withdraw function on the vaults, the lock ensures that a withdrawal is only successful if the fee splitter is withdrawing the fees to ensure accurate accounting
    receive() external payable virtual {
        uint256 unlocked;
        assembly ("memory-safe") {
            unlocked := tload(LOCK_STORAGE_SLOT)
        }
        if (unlocked == 0) revert Locked();

        // TODO: explore whether the withdraw function can return a value indicating the amount of fees withdrawn
        if (msg.sender == Predeploys.SEQUENCER_FEE_WALLET || msg.sender == Predeploys.BASE_FEE_VAULT) {
            uint256 amount = msg.value;
            // combine the fees from the sequencer and base FeeVaults as net revenue
            assembly ("memory-safe") {
                tstore(NET_REVENUE_STORAGE_SLOT, add(tload(NET_REVENUE_STORAGE_SLOT), amount))
            }
        } else if (msg.sender == Predeploys.L1_FEE_VAULT) {
            // L1 Fee can be retrieved by subtracting the net fee revenue from address(this).balance
            // any dust not distributed in previous distributions is allocated towards L1 fee revenue automatically
        } else {
            revert OnlyVaults();
        }
    }

    function _feeVaultWithdrawal(address _feeVault) internal {
        if (IFeeVault(_feeVault).withdrawalNetwork() != IFeeVault.WithdrawalNetwork.L2) {
            revert MustWithdrawToL2();
        }
        if (IFeeVault(_feeVault).recipient() != address(this)) {
            revert MustWithdrawToFeeSplitter();
        }
        IFeeVault(_feeVault).withdraw();
    }
}

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

/// @title Predeploys
/// @notice Contains constant addresses for protocol contracts that are pre-deployed to the L2 system.
//          This excludes the preinstalls (non-protocol contracts).
library Predeploys {
    /// @notice Number of predeploy-namespace addresses reserved for protocol usage.
    uint256 internal constant PREDEPLOY_COUNT = 2048;

    /// @custom:legacy
    /// @notice Address of the LegacyMessagePasser predeploy. Deprecate. Use the updated
    ///         L2ToL1MessagePasser contract instead.
    address internal constant LEGACY_MESSAGE_PASSER = 0x4200000000000000000000000000000000000000;

    /// @custom:legacy
    /// @notice Address of the L1MessageSender predeploy. Deprecated. Use L2CrossDomainMessenger
    ///         or access tx.origin (or msg.sender) in a L1 to L2 transaction instead.
    ///         Not embedded into new OP-Stack chains.
    address internal constant L1_MESSAGE_SENDER = 0x4200000000000000000000000000000000000001;

    /// @custom:legacy
    /// @notice Address of the DeployerWhitelist predeploy. No longer active.
    address internal constant DEPLOYER_WHITELIST = 0x4200000000000000000000000000000000000002;

    /// @notice Address of the canonical WETH contract.
    address internal constant WETH = 0x4200000000000000000000000000000000000006;

    /// @notice Address of the L2CrossDomainMessenger predeploy.
    address internal constant L2_CROSS_DOMAIN_MESSENGER = 0x4200000000000000000000000000000000000007;

    /// @notice Address of the GasPriceOracle predeploy. Includes fee information
    ///         and helpers for computing the L1 portion of the transaction fee.
    address internal constant GAS_PRICE_ORACLE = 0x420000000000000000000000000000000000000F;

    /// @notice Address of the L2StandardBridge predeploy.
    address internal constant L2_STANDARD_BRIDGE = 0x4200000000000000000000000000000000000010;

    //// @notice Address of the SequencerFeeWallet predeploy.
    address internal constant SEQUENCER_FEE_WALLET = 0x4200000000000000000000000000000000000011;

    /// @notice Address of the OptimismMintableERC20Factory predeploy.
    address internal constant OPTIMISM_MINTABLE_ERC20_FACTORY = 0x4200000000000000000000000000000000000012;

    /// @custom:legacy
    /// @notice Address of the L1BlockNumber predeploy. Deprecated. Use the L1Block predeploy
    ///         instead, which exposes more information about the L1 state.
    address internal constant L1_BLOCK_NUMBER = 0x4200000000000000000000000000000000000013;

    /// @notice Address of the L2ERC721Bridge predeploy.
    address internal constant L2_ERC721_BRIDGE = 0x4200000000000000000000000000000000000014;

    /// @notice Address of the L1Block predeploy.
    address internal constant L1_BLOCK_ATTRIBUTES = 0x4200000000000000000000000000000000000015;

    /// @notice Address of the L2ToL1MessagePasser predeploy.
    address internal constant L2_TO_L1_MESSAGE_PASSER = 0x4200000000000000000000000000000000000016;

    /// @notice Address of the OptimismMintableERC721Factory predeploy.
    address internal constant OPTIMISM_MINTABLE_ERC721_FACTORY = 0x4200000000000000000000000000000000000017;

    /// @notice Address of the ProxyAdmin predeploy.
    address internal constant PROXY_ADMIN = 0x4200000000000000000000000000000000000018;

    /// @notice Address of the BaseFeeVault predeploy.
    address internal constant BASE_FEE_VAULT = 0x4200000000000000000000000000000000000019;

    /// @notice Address of the L1FeeVault predeploy.
    address internal constant L1_FEE_VAULT = 0x420000000000000000000000000000000000001A;

    /// @notice Address of the SchemaRegistry predeploy.
    address internal constant SCHEMA_REGISTRY = 0x4200000000000000000000000000000000000020;

    /// @notice Address of the EAS predeploy.
    address internal constant EAS = 0x4200000000000000000000000000000000000021;

    /// @notice Address of the GovernanceToken predeploy.
    address internal constant GOVERNANCE_TOKEN = 0x4200000000000000000000000000000000000042;

    /// @custom:legacy
    /// @notice Address of the LegacyERC20ETH predeploy. Deprecated. Balances are migrated to the
    ///         state trie as of the Bedrock upgrade. Contract has been locked and write functions
    ///         can no longer be accessed.
    address internal constant LEGACY_ERC20_ETH = 0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000;

    /// @notice Address of the CrossL2Inbox predeploy.
    address internal constant CROSS_L2_INBOX = 0x4200000000000000000000000000000000000022;

    /// @notice Address of the L2ToL2CrossDomainMessenger predeploy.
    address internal constant L2_TO_L2_CROSS_DOMAIN_MESSENGER = 0x4200000000000000000000000000000000000023;

    /// @notice Address of the SuperchainWETH predeploy.
    address internal constant SUPERCHAIN_WETH = 0x4200000000000000000000000000000000000024;

    /// @notice Address of the ETHLiquidity predeploy.
    address internal constant ETH_LIQUIDITY = 0x4200000000000000000000000000000000000025;

    /// @notice Address of the OptimismSuperchainERC20Factory predeploy.
    address internal constant OPTIMISM_SUPERCHAIN_ERC20_FACTORY = 0x4200000000000000000000000000000000000026;

    /// @notice Address of the OptimismSuperchainERC20Beacon predeploy.
    address internal constant OPTIMISM_SUPERCHAIN_ERC20_BEACON = 0x4200000000000000000000000000000000000027;

    // TODO: Precalculate the address of the implementation contract
    /// @notice Arbitrary address of the OptimismSuperchainERC20 implementation contract.
    address internal constant OPTIMISM_SUPERCHAIN_ERC20 = 0xB9415c6cA93bdC545D4c5177512FCC22EFa38F28;

    /// @notice Address of the SuperchainTokenBridge predeploy.
    address internal constant SUPERCHAIN_TOKEN_BRIDGE = 0x4200000000000000000000000000000000000028;

    /// @notice Returns the name of the predeploy at the given address.
    function getName(address _addr) internal pure returns (string memory out_) {
        require(isPredeployNamespace(_addr), "Predeploys: address must be a predeploy");
        if (_addr == LEGACY_MESSAGE_PASSER) return "LegacyMessagePasser";
        if (_addr == L1_MESSAGE_SENDER) return "L1MessageSender";
        if (_addr == DEPLOYER_WHITELIST) return "DeployerWhitelist";
        if (_addr == WETH) return "WETH";
        if (_addr == L2_CROSS_DOMAIN_MESSENGER) return "L2CrossDomainMessenger";
        if (_addr == GAS_PRICE_ORACLE) return "GasPriceOracle";
        if (_addr == L2_STANDARD_BRIDGE) return "L2StandardBridge";
        if (_addr == SEQUENCER_FEE_WALLET) return "SequencerFeeVault";
        if (_addr == OPTIMISM_MINTABLE_ERC20_FACTORY) return "OptimismMintableERC20Factory";
        if (_addr == L1_BLOCK_NUMBER) return "L1BlockNumber";
        if (_addr == L2_ERC721_BRIDGE) return "L2ERC721Bridge";
        if (_addr == L1_BLOCK_ATTRIBUTES) return "L1Block";
        if (_addr == L2_TO_L1_MESSAGE_PASSER) return "L2ToL1MessagePasser";
        if (_addr == OPTIMISM_MINTABLE_ERC721_FACTORY) return "OptimismMintableERC721Factory";
        if (_addr == PROXY_ADMIN) return "ProxyAdmin";
        if (_addr == BASE_FEE_VAULT) return "BaseFeeVault";
        if (_addr == L1_FEE_VAULT) return "L1FeeVault";
        if (_addr == SCHEMA_REGISTRY) return "SchemaRegistry";
        if (_addr == EAS) return "EAS";
        if (_addr == GOVERNANCE_TOKEN) return "GovernanceToken";
        if (_addr == LEGACY_ERC20_ETH) return "LegacyERC20ETH";
        if (_addr == CROSS_L2_INBOX) return "CrossL2Inbox";
        if (_addr == L2_TO_L2_CROSS_DOMAIN_MESSENGER) return "L2ToL2CrossDomainMessenger";
        if (_addr == SUPERCHAIN_WETH) return "SuperchainWETH";
        if (_addr == ETH_LIQUIDITY) return "ETHLiquidity";
        if (_addr == OPTIMISM_SUPERCHAIN_ERC20_FACTORY) return "OptimismSuperchainERC20Factory";
        if (_addr == OPTIMISM_SUPERCHAIN_ERC20_BEACON) return "OptimismSuperchainERC20Beacon";
        if (_addr == SUPERCHAIN_TOKEN_BRIDGE) return "SuperchainTokenBridge";
        revert("Predeploys: unnamed predeploy");
    }

    /// @notice Returns true if the predeploy is not proxied.
    function notProxied(address _addr) internal pure returns (bool) {
        return _addr == GOVERNANCE_TOKEN || _addr == WETH;
    }

    /// @notice Returns true if the address is a defined predeploy that is embedded into new OP-Stack chains.
    function isSupportedPredeploy(address _addr, bool _useInterop) internal pure returns (bool) {
        return _addr == LEGACY_MESSAGE_PASSER || _addr == DEPLOYER_WHITELIST || _addr == WETH
            || _addr == L2_CROSS_DOMAIN_MESSENGER || _addr == GAS_PRICE_ORACLE || _addr == L2_STANDARD_BRIDGE
            || _addr == SEQUENCER_FEE_WALLET || _addr == OPTIMISM_MINTABLE_ERC20_FACTORY || _addr == L1_BLOCK_NUMBER
            || _addr == L2_ERC721_BRIDGE || _addr == L1_BLOCK_ATTRIBUTES || _addr == L2_TO_L1_MESSAGE_PASSER
            || _addr == OPTIMISM_MINTABLE_ERC721_FACTORY || _addr == PROXY_ADMIN || _addr == BASE_FEE_VAULT
            || _addr == L1_FEE_VAULT || _addr == SCHEMA_REGISTRY || _addr == EAS || _addr == GOVERNANCE_TOKEN
            || (_useInterop && _addr == CROSS_L2_INBOX) || (_useInterop && _addr == L2_TO_L2_CROSS_DOMAIN_MESSENGER)
            || (_useInterop && _addr == SUPERCHAIN_WETH) || (_useInterop && _addr == ETH_LIQUIDITY)
            || (_useInterop && _addr == OPTIMISM_SUPERCHAIN_ERC20_FACTORY)
            || (_useInterop && _addr == OPTIMISM_SUPERCHAIN_ERC20_BEACON)
            || (_useInterop && _addr == SUPERCHAIN_TOKEN_BRIDGE);
    }

    function isPredeployNamespace(address _addr) internal pure returns (bool) {
        return uint160(_addr) >> 11 == uint160(0x4200000000000000000000000000000000000000) >> 11;
    }

    /// @notice Function to compute the expected address of the predeploy implementation
    ///         in the genesis state.
    function predeployToCodeNamespace(address _addr) internal pure returns (address) {
        require(
            isPredeployNamespace(_addr), "Predeploys: can only derive code-namespace address for predeploy addresses"
        );
        return address(
            uint160(uint256(uint160(_addr)) & 0xffff | uint256(uint160(0xc0D3C0d3C0d3C0D3c0d3C0d3c0D3C0d3c0d30000)))
        );
    }
}

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

/// @title SafeCall
/// @notice Perform low level safe calls
library SafeCall {
    /// @notice Performs a low level call without copying any returndata.
    /// @dev Passes no calldata to the call context.
    /// @param _target   Address to call
    /// @param _gas      Amount of gas to pass to the call
    /// @param _value    Amount of value to pass to the call
    function send(address _target, uint256 _gas, uint256 _value) internal returns (bool success_) {
        assembly {
            success_ :=
                call(
                    _gas, // gas
                    _target, // recipient
                    _value, // ether value
                    0, // inloc
                    0, // inlen
                    0, // outloc
                    0 // outlen
                )
        }
    }

    /// @notice Perform a low level call with all gas without copying any returndata
    /// @param _target   Address to call
    /// @param _value    Amount of value to pass to the call
    function send(address _target, uint256 _value) internal returns (bool success_) {
        success_ = send(_target, gasleft(), _value);
    }

    /// @notice Perform a low level call without copying any returndata
    /// @param _target   Address to call
    /// @param _gas      Amount of gas to pass to the call
    /// @param _value    Amount of value to pass to the call
    /// @param _calldata Calldata to pass to the call
    function call(
        address _target,
        uint256 _gas,
        uint256 _value,
        bytes memory _calldata
    )
        internal
        returns (bool success_)
    {
        assembly {
            success_ :=
                call(
                    _gas, // gas
                    _target, // recipient
                    _value, // ether value
                    add(_calldata, 32), // inloc
                    mload(_calldata), // inlen
                    0, // outloc
                    0 // outlen
                )
        }
    }

    /// @notice Perform a low level call without copying any returndata
    /// @param _target   Address to call
    /// @param _value    Amount of value to pass to the call
    /// @param _calldata Calldata to pass to the call
    function call(address _target, uint256 _value, bytes memory _calldata) internal returns (bool success_) {
        success_ = call({ _target: _target, _gas: gasleft(), _value: _value, _calldata: _calldata });
    }

    /// @notice Perform a low level call without copying any returndata
    /// @param _target   Address to call
    /// @param _calldata Calldata to pass to the call
    function call(address _target, bytes memory _calldata) internal returns (bool success_) {
        success_ = call({ _target: _target, _gas: gasleft(), _value: 0, _calldata: _calldata });
    }

    /// @notice Helper function to determine if there is sufficient gas remaining within the context
    ///         to guarantee that the minimum gas requirement for a call will be met as well as
    ///         optionally reserving a specified amount of gas for after the call has concluded.
    /// @param _minGas      The minimum amount of gas that may be passed to the target context.
    /// @param _reservedGas Optional amount of gas to reserve for the caller after the execution
    ///                     of the target context.
    /// @return `true` if there is enough gas remaining to safely supply `_minGas` to the target
    ///         context as well as reserve `_reservedGas` for the caller after the execution of
    ///         the target context.
    /// @dev !!!!! FOOTGUN ALERT !!!!!
    ///      1.) The 40_000 base buffer is to account for the worst case of the dynamic cost of the
    ///          `CALL` opcode's `address_access_cost`, `positive_value_cost`, and
    ///          `value_to_empty_account_cost` factors with an added buffer of 5,700 gas. It is
    ///          still possible to self-rekt by initiating a withdrawal with a minimum gas limit
    ///          that does not account for the `memory_expansion_cost` & `code_execution_cost`
    ///          factors of the dynamic cost of the `CALL` opcode.
    ///      2.) This function should *directly* precede the external call if possible. There is an
    ///          added buffer to account for gas consumed between this check and the call, but it
    ///          is only 5,700 gas.
    ///      3.) Because EIP-150 ensures that a maximum of 63/64ths of the remaining gas in the call
    ///          frame may be passed to a subcontext, we need to ensure that the gas will not be
    ///          truncated.
    ///      4.) Use wisely. This function is not a silver bullet.
    function hasMinGas(uint256 _minGas, uint256 _reservedGas) internal view returns (bool) {
        bool _hasMinGas;
        assembly {
            // Equation: gas × 63 ≥ minGas × 64 + 63(40_000 + reservedGas)
            _hasMinGas := iszero(lt(mul(gas(), 63), add(mul(_minGas, 64), mul(add(40000, _reservedGas), 63))))
        }
        return _hasMinGas;
    }

    /// @notice Perform a low level call without copying any returndata. This function
    ///         will revert if the call cannot be performed with the specified minimum
    ///         gas.
    /// @param _target   Address to call
    /// @param _minGas   The minimum amount of gas that may be passed to the call
    /// @param _value    Amount of value to pass to the call
    /// @param _calldata Calldata to pass to the call
    function callWithMinGas(
        address _target,
        uint256 _minGas,
        uint256 _value,
        bytes memory _calldata
    )
        internal
        returns (bool)
    {
        bool _success;
        bool _hasMinGas = hasMinGas(_minGas, 0);
        assembly {
            // Assertion: gasleft() >= (_minGas * 64) / 63 + 40_000
            if iszero(_hasMinGas) {
                // Store the "Error(string)" selector in scratch space.
                mstore(0, 0x08c379a0)
                // Store the pointer to the string length in scratch space.
                mstore(32, 32)
                // Store the string.
                //
                // SAFETY:
                // - We pad the beginning of the string with two zero bytes as well as the
                // length (24) to ensure that we override the free memory pointer at offset
                // 0x40. This is necessary because the free memory pointer is likely to
                // be greater than 1 byte when this function is called, but it is incredibly
                // unlikely that it will be greater than 3 bytes. As for the data within
                // 0x60, it is ensured that it is 0 due to 0x60 being the zero offset.
                // - It's fine to clobber the free memory pointer, we're reverting.
                mstore(88, 0x0000185361666543616c6c3a204e6f7420656e6f75676820676173)

                // Revert with 'Error("SafeCall: Not enough gas")'
                revert(28, 100)
            }

            // The call will be supplied at least ((_minGas * 64) / 63) gas due to the
            // above assertion. This ensures that, in all circumstances (except for when the
            // `_minGas` does not account for the `memory_expansion_cost` and `code_execution_cost`
            // factors of the dynamic cost of the `CALL` opcode), the call will receive at least
            // the minimum amount of gas specified.
            _success :=
                call(
                    gas(), // gas
                    _target, // recipient
                    _value, // ether value
                    add(_calldata, 32), // inloc
                    mload(_calldata), // inlen
                    0x00, // outloc
                    0x00 // outlen
                )
        }
        return _success;
    }
}

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

interface IFeeSplitter {
    /// @notice Emitted when `distributeFees` is called and no fees are collected
    event NoFeesCollected();

    /// @notice Emitted when `distributeFees` is called and fees are distributed
    /// @param optimismShare The amount of fees sent to Optimism
    /// @param l1Fees The amount of fees sent to L1 distributor
    /// @param netShare The amount of fees sent to the net fee distributor
    event FeesDistributed(uint256 optimismShare, uint256 l1Fees, uint256 netShare);

    /// @notice Thrown when an address provided in the constructor is zero
    error AddressZero();

    /// @notice Thrown when a transfer fails
    error TransferFailed();

    /// @notice Thrown an address other than the fee splitter tries to withdraw fees from vaults
    error Locked();

    /// @notice Thrown when an address that is not a vault tries to deposit fees
    error OnlyVaults();

    /// @notice Thrown when a fee vault is configured to withdraw to L2
    error MustWithdrawToL2();

    /// @notice Thrown when a fee vault is not configured to withdraw to the fee splitter
    error MustWithdrawToFeeSplitter();

    /// @notice Distributes the fees collected from the fee vaults to their respective destinations
    /// @return feesDistributed Whether any fees were distributed
    function distributeFees() external returns (bool feesDistributed);
}

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

/// @notice from https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/universal/FeeVault.sol
interface IFeeVault {
    /// @notice Enum representing where the FeeVault withdraws funds to.
    /// @custom:value L1 FeeVault withdraws funds to L1.
    /// @custom:value L2 FeeVault withdraws funds to L2.
    enum WithdrawalNetwork {
        L1,
        L2
    }

    /// @notice Network which the recipient will receive fees on.
    ///         Use the `withdrawalNetwork()` getter as this is deprecated
    ///         and is subject to be removed in the future.
    /// @custom:legacy
    function WITHDRAWAL_NETWORK() external view returns (WithdrawalNetwork);
    function withdrawalNetwork() external view returns (WithdrawalNetwork);

    /// @notice Account that will receive the fees. Can be located on L1 or L2.
    ///         Use the `recipient()` getter as this is deprecated
    ///         and is subject to be removed in the future.
    /// @custom:legacy
    function RECIPIENT() external view returns (address);
    function recipient() external view returns (address);

    /// @notice Minimum balance before a withdrawal can be triggered.
    ///         Use the `minWithdrawalAmount()` getter as this is deprecated
    ///         and is subject to be removed in the future.
    /// @custom:legacy
    function MIN_WITHDRAWAL_AMOUNT() external view returns (uint256);
    function minWithdrawalAmount() external view returns (uint256);

    /// @notice Triggers a withdrawal of funds to the fee wallet on L1 or L2.
    function withdraw() external;
}

{
  "remappings": [
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@eth-optimism-bedrock/=lib/optimism/packages/contracts-bedrock/",
    "forge-std/=lib/forge-std/src/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@eth-optimism-bedrock/=lib/optimism/packages/contracts-bedrock/",
    "automate/=lib/optimism/packages/contracts-bedrock/lib/automate/contracts/",
    "ds-test/=lib/openzeppelin-contracts-upgradeable/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "forge-gas-snapshot/=lib/forge-gas-snapshot/src/",
    "forge-std/=lib/forge-std/src/",
    "kontrol-cheatcodes/=lib/optimism/packages/contracts-bedrock/lib/kontrol-cheatcodes/src/",
    "lib-keccak/=lib/optimism/packages/contracts-bedrock/lib/lib-keccak/contracts/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts-v5/=lib/optimism/packages/contracts-bedrock/lib/openzeppelin-contracts-v5/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "optimism/=lib/optimism/",
    "prb-test/=lib/optimism/packages/contracts-bedrock/lib/automate/lib/prb-test/src/",
    "safe-contracts/=lib/optimism/packages/contracts-bedrock/lib/safe-contracts/contracts/",
    "solady/=lib/optimism/packages/contracts-bedrock/lib/solady/",
    "solmate/=lib/optimism/packages/contracts-bedrock/lib/solmate/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 999999
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"optimismWallet","type":"address"},{"internalType":"address","name":"l1FeeRecipient","type":"address"},{"internalType":"address","name":"netFeeRecipient","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AddressZero","type":"error"},{"inputs":[],"name":"Locked","type":"error"},{"inputs":[],"name":"MustWithdrawToFeeSplitter","type":"error"},{"inputs":[],"name":"MustWithdrawToL2","type":"error"},{"inputs":[],"name":"OnlyVaults","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"optimismShare","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"l1Fees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"netShare","type":"uint256"}],"name":"FeesDistributed","type":"event"},{"anonymous":false,"inputs":[],"name":"NoFeesCollected","type":"event"},{"inputs":[],"name":"L1_FEE_RECIPIENT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NET_FEE_RECIPIENT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPTIMISM_WALLET","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distributeFees","outputs":[{"internalType":"bool","name":"feesDistributed","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

513:6734:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5965:17;5959:24;5882:16;6006:13;;;6002:34;;6028:8;;;;;;;;;;;;;;6002:34;6165:10;2063:42:0;6165:45:2;;:88;;-1:-1:-1;6214:10:2;3461:42:0;6214:39:2;6165:88;6161:705;;;6286:9;6480:24;6474:31;;6470:44;;;6437:78;6419:110;6161:705;6549:37;:10;:37;6545:321;;;6843:12;;;;;;;;;;;;;;6545:321;5872:1000;513:6734;;;;1166:40;;;;;;;;;;;;;;;;;;190:42:5;178:55;;;160:74;;148:2;133:18;1166:40:2;;;;;;;;1300:42;;;;;;;;;;;;;;;1446:41;;;;;;;;;;;;;;;2243:3223;;;;;;;;;;;;;:::i;:::-;;;410:14:5;;403:22;385:41;;373:2;358:18;2243:3223:2;245:187:5;2243:3223:2;2295:20;2063:42:0;2386:62:2;;;:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2063:42:0;2344:39:2;:106;;:220;;;3461:42:0;2506:56:2;;;:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3461:42:0;2470:33:2;:94;2344:220;:330;;;;3604:42:0;2618:54:2;;;:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3604:42:0;2584:31:2;:90;2344:330;2327:563;;;2836:17;;;;;;;-1:-1:-1;2874:5:2;;2243:3223::o;2327:563::-;2983:1;2964:17;2957:28;3004:52;2063:42:0;3004:19:2;:52::i;:::-;3066:46;3461:42:0;3066:19:2;:46::i;:::-;3122:44;3604:42:0;3122:19:2;:44::i;:::-;3258:1;3239:17;3232:28;3431:24;3425:31;;;3337:21;;3280;;3469:35;3596:15;3615:1;3596:20;3592:99;;3637:17;;;;;;;3675:5;3668:12;;;;2243:3223;:::o;3592:99::-;3701:23;954:4;3727:33;1009:3;3727:13;:33;:::i;:::-;:53;;;;:::i;:::-;3701:79;-1:-1:-1;3790:25:2;954:4;3818:37;1065:2;3818:15;:37;:::i;:::-;:57;;;;:::i;:::-;3790:85;;3886:28;3924:13;3947:27;4008:15;3988:17;:35;3984:1075;;;4339:17;;-1:-1:-1;954:4:2;4415:39;1065:2;954:4;4415:39;:::i;:::-;4378:77;;4379:31;4397:13;4379:15;:31;:::i;:::-;4378:77;;;;:::i;:::-;:97;;;;:::i;:::-;4370:105;-1:-1:-1;954:4:2;4528:39;1065:2;954:4;4528:39;:::i;:::-;4511:57;;;;:13;:57;:::i;:::-;:77;;;;:::i;:::-;4489:99;;3984:1075;;;4908:15;;-1:-1:-1;4945:31:2;4963:13;4945:15;:31;:::i;:::-;4937:39;-1:-1:-1;5012:36:2;5028:20;5012:13;:36;:::i;:::-;4990:58;;3984:1075;5074:63;5088:15;5105:9;5116:20;5074:13;:63::i;:::-;5069:93;;5146:16;;;;;;;;;;;;;;5069:93;5178:49;5192:16;5210:9;5221:5;5178:13;:49::i;:::-;5173:79;;5236:16;;;;;;;;;;;;;;5173:79;5268:64;5282:17;5301:9;5312:19;5268:13;:64::i;:::-;5263:94;;5341:16;;;;;;;;;;;;;;5263:94;5373:65;;;1777:25:5;;;1833:2;1818:18;;1811:34;;;1861:18;;;1854:34;;;5373:65:2;;1765:2:5;1750:18;5373:65:2;;;;;;;5455:4;5448:11;;;;;;;;;2243:3223;:::o;6878:367::-;6993:30;6959:9;6949:38;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:74;;;;;;;;:::i;:::-;;6945:130;;7046:18;;;;;;;;;;;;;;6945:130;7132:4;7088:49;;7098:9;7088:30;;;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;;;7084:114;;7160:27;;;;;;;;;;;;;;7084:114;7217:9;7207:29;;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6878:367;:::o;429:441:1:-;508:13;825:1;792;760;728;685:6;643:7;610:4;584:270;556:298;429:441;-1:-1:-1;;;;429:441:1:o;437:184:5:-;507:6;560:2;548:9;539:7;535:23;531:32;528:52;;;576:1;573;566:12;528:52;-1:-1:-1;599:16:5;;437:184;-1:-1:-1;437:184:5:o;626:::-;678:77;675:1;668:88;775:4;772:1;765:15;799:4;796:1;789:15;815:168;888:9;;;919;;936:15;;;930:22;;916:37;906:71;;957:18;;:::i;:::-;815:168;;;;:::o;988:274::-;1028:1;1054;1044:189;;1089:77;1086:1;1079:88;1190:4;1187:1;1180:15;1218:4;1215:1;1208:15;1044:189;-1:-1:-1;1247:9:5;;988:274::o;1267:170::-;1364:10;1357:18;;;1337;;;1333:43;;1388:20;;1385:46;;;1411:18;;:::i;1442:128::-;1509:9;;;1530:11;;;1527:37;;;1544:18;;:::i;1899:184::-;1951:77;1948:1;1941:88;2048:4;2045:1;2038:15;2072:4;2069:1;2062:15;2088:282;2180:6;2233:2;2221:9;2212:7;2208:23;2204:32;2201:52;;;2249:1;2246;2239:12;2201:52;2281:9;2275:16;2320:1;2313:5;2310:12;2300:40;;2336:1;2333;2326:12;2300:40;2359:5;2088:282;-1:-1:-1;;;2088:282:5:o;2375:313::-;2445:6;2498:2;2486:9;2477:7;2473:23;2469:32;2466:52;;;2514:1;2511;2504:12;2466:52;2546:9;2540:16;2596:42;2589:5;2585:54;2578:5;2575:65;2565:93;;2654:1;2651;2644:12

ipfs://84f46dd053649380056d74a2d5cc302f0f11be0dcfcdd48a27693c1cdc5a21bf