Contract

// SPDX-License-Identifier: LGPL-3.0-only
// Created By: Art Blocks Inc.

// @dev fixed to specific solidity version for clarity and for more clear
// source code verification purposes.
pragma solidity 0.8.22;

import {ISplitAtomicV0, Split} from "../interfaces/v0.8.x/ISplitAtomicV0.sol";

import {IERC20} from "@openzeppelin-5.0/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin-5.0/contracts/token/ERC20/utils/SafeERC20.sol";

/**
 * @title SplitAtomicV0
 * @author Art Blocks Inc.
 * @notice This contract splits received funds according to the configured
 * `splits`, which are immutably configured at initialization time.
 * Each split is defined as a `recipient` address and a `basisPoints` value.
 * The total of all `basisPoints` values must add up to 10_000 (100%), which
 * is verified at initialization time. All splits must be non-zero.
 *
 * When the contract receives funds, it splits the funds according to the
 * configured `splits`. The contract can also manually split any funds that
 * were sent outside of the `receive` function via the `drainETH` function.
 * Additionally, a `drainERC20` function is provided to split any ERC20 tokens
 * that were sent to the contract.
 *
 * There may be a small amount of funds left behind when splitting funds, due
 * to integer division rounding down. This is conservatively safe (will always
 * run a split), but may leave a small amount of funds behind (e.g. a few wei).
 * The small amount of funds left behind can always be drained later, but
 * likely never worth the gas.
 */
contract SplitAtomicV0 is ISplitAtomicV0 {
    // simplified, initializable reentrancy guard
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;
    uint256 private constant _NOT_INITIALIZED = 0;
    uint256 private _status; // initial value: _NOT_INITIALIZED (0)

    // public type
    bytes32 public constant type_ = "SplitAtomicV0";

    // private array of Splits
    Split[] private _splits;

    /**
     * @dev Prevents 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.
     * @dev prefer to use modifier here due to wrapped function behavior
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    /**
     * @notice receive function splits received funds according to the
     * configured `splits`.
     * Reverts if contract is not yet initialized.
     * Non-reentrant function.
     * @dev This function automatically splits funds when the native token of a
     * blockchain is sent to the contract. It is important to note that this
     * function uses an unspecified amount of gas, and therefore sending funds
     * to this contract via the deprecated `transfer` method is not supported.
     * @dev This function relies on being non-reentrant for security.
     */
    receive() external payable nonReentrant {
        // split received funds
        // @dev reverts if not already initialized
        _splitETH(msg.value);
    }

    /**
     * @notice Initializes the contract with the provided `splits`.
     * This function should be called atomically, immediately after deployment.
     * Only callable once.
     * @param splits Splits to configure the contract with. Must add up to
     * 10_000 BPS.
     */
    function initialize(Split[] calldata splits) external {
        // initialize reentrancy guard
        // @dev this reverts if already initialized, preventing this function
        // from ever being called more than once
        _reentrancyGuardInit();
        // validate splits
        uint256 totalBasisPoints = 0;
        uint256 splitsLength = splits.length;
        // @dev splits length implicitly checked to be > 0 via totalBasisPoints
        // check after loop
        for (uint256 i; i < splitsLength; ) {
            Split memory split = splits[i];
            uint256 bps = split.basisPoints;
            require(bps > 0 && bps <= 10_000, "Invalid basis points");
            // push the splits to the storage array
            _splits.push(split);
            // track total basis points for totals validation after loop
            // @dev overflow checked automatically in solidity 0.8
            totalBasisPoints += bps;
            // @dev efficient unchecked increment
            unchecked {
                ++i;
            }
        }
        require(totalBasisPoints == 10_000, "Invalid total basis points");
        // emit initialized event
        emit Initialized(type_);
    }

    /**
     * @notice Drains the contract's balance to the configured `splits`.
     * Reverts if not initialized.
     * @dev This function is useful for draining the contract's balance to the
     * configured `splits` in the event that the contract receives funds via
     * a force-send (e.g. `SELFDESTRUCT` or `SENDALL`) operation.
     * @dev This function relies on being non-reentrant for security.
     */
    function drainETH() external nonReentrant {
        // split contract balance
        uint256 balance = address(this).balance;
        if (balance > 0) {
            // @dev reverts if not initialized
            _splitETH(balance);
        }
        emit DrainedETH();
    }

    /**
     * @notice Drains the contract's balance of an input ERC20 token to the
     * configured `splits`.
     * Reverts if not initialized
     * @dev This function is useful for draining the contract's balance of an
     * ERC20 token to the configured `splits`. ERC20 tokens are not split upon
     * receiving (due to transfers not always calling a receive hook),
     * therefore this function provides critical functionality for this
     * contract.
     * @dev This function relies on being non-reentrant for security.
     * @param ERC20TokenAddress The address of the ERC20 token to split.
     */
    function drainERC20(address ERC20TokenAddress) external nonReentrant {
        // split contract balance of ERC20 token
        uint256 balance = IERC20(ERC20TokenAddress).balanceOf(address(this));
        if (balance > 0) {
            // @dev reverts if not initialized
            _splitERC20({ERC20TokenAddress: ERC20TokenAddress, value: balance});
        }
        emit DrainedERC20(ERC20TokenAddress);
    }

    /**
     * @notice Returns the configured `splits`.
     * @return Split[] memory The configured `splits`.
     */
    function getSplits() external view returns (Split[] memory) {
        return _splits;
    }

    /**
     * @notice Splits the input `valueInWei` of ETH to the configured `splits`.
     * Reverts if any transfers fail. Reverts if called outside of a
     * non-reentrant function. Reverts if not initialized.
     * @param valueInWei The amount of ETH to split.
     */
    function _splitETH(uint256 valueInWei) internal {
        // require only called in the context of a non-reentrant function
        // @dev this provides fault-tolerant behavior for reentrancy guards
        // @dev this also implicitly verifies contract is initialized
        // @dev no cover on next line else banch due to fault-tolerant check
        require(_status == _ENTERED, "only in non-reentrant function");
        // split funds
        uint256 splitsLength = _splits.length;
        for (uint256 i; i < splitsLength; ) {
            Split memory split = _splits[i];
            // @dev overflow checked automatically in solidity 0.8
            // @dev integer division rounds down, which is conservatively safe
            // when splitting funds. Will not run out of funds, but may leave a
            // small amount behind (e.g. a few wei). Can always be drained
            // later, but likely never worth the gas.
            uint256 splitValue = (valueInWei * split.basisPoints) / 10_000;
            // send funds
            (bool success, ) = split.recipient.call{value: splitValue}("");
            require(success, "Payment failed");
            // @dev efficient unchecked increment
            unchecked {
                ++i;
            }
        }
    }

    /**
     * @notice Splits the input `value` of ERC20 token at `ERC20TokenAddress`
     * to the configured `splits`.
     * Reverts if any transfers fail. Reverts if called outside of a
     * non-reentrant function. Reverts if not initialized.
     * @param ERC20TokenAddress The address of the ERC20 token to split.
     * @param value The amount of the ERC20 token to split.
     */
    function _splitERC20(address ERC20TokenAddress, uint256 value) internal {
        // require only called in the context of a non-reentrant function
        // @dev this provides fault-tolerant behavior for reentrancy guards
        // @dev this also implicitly verifies contract is initialized
        // @dev no cover on next line else banch due to fault-tolerant check
        require(_status == _ENTERED, "only in non-reentrant function");
        // split funds
        uint256 splitsLength = _splits.length;
        IERC20 token = IERC20(ERC20TokenAddress);
        for (uint256 i; i < splitsLength; ) {
            Split memory split = _splits[i];
            // @dev overflow checked automatically in solidity 0.8
            // @dev integer division rounds down, which is conservatively safe
            // when splitting funds. Will not run out of funds, but may leave a
            // small amount behind (e.g. a few wei). Can always be drained
            // later, but likely never worth the gas.
            uint256 splitValue = (value * split.basisPoints) / 10_000;
            // transfer ERC20 tokens
            // @dev use SafeERC20 to only revert if ERC20 transfer returns
            // false, not if it returns nothing (which is the behavior of some
            // ERC20 tokens, and we don't want to forever lock those tokens)
            SafeERC20.safeTransfer({
                token: token,
                to: split.recipient,
                value: splitValue
            });
            // @dev efficient unchecked increment
            unchecked {
                ++i;
            }
        }
    }

    /**
     * @notice Initializes the reentrancy guard. This function will revert if
     * the contract is already initialized.
     */
    function _reentrancyGuardInit() private {
        // require not already initialized
        require(_status == _NOT_INITIALIZED, "Already initialized");
        // set status to not entered
        _status = _NOT_ENTERED;
    }

    /**
     * @notice Sets the reentrancy guard status to `_ENTERED`.
     * Reverts if the guard is already entered.
     */
    function _nonReentrantBefore() private {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    /**
     * @notice Sets the reentrancy guard status to `_NOT_ENTERED`, allowing
     * calls to `nonReentrant` functions again.
     */
    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;
    }
}

// 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
// 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
// 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
// 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: LGPL-3.0-only
// Creatd By: Art Blocks Inc.

pragma solidity ^0.8.0;

/**
 * @notice Struct representing a split.
 * @param recipient The address to send funds to.
 * @param basisPoints The basis points to allocate to recipient (1-10_000).
 */
struct Split {
    // address to send funds to
    address payable recipient;
    // basis points to allocate to recipient (1-10_000)
    uint16 basisPoints;
}

interface ISplitAtomicV0 {
    /**
     * @notice Indicates that the contract has been initialized.
     * @param type_ The type of the contract.
     */
    event Initialized(bytes32 type_);

    /**
     * @notice Indicates that the contract's balance manually was drained of
     * ETH.
     */
    event DrainedETH();

    /**
     * @notice Indicates that the contract's balance manually was drained of
     * ERC20 token at address `ERC20TokenAddress`.
     * @param ERC20TokenAddress The address of the ERC20 token that was
     * drained.
     */
    event DrainedERC20(address ERC20TokenAddress);

    /**
     * @notice Initializes the contract with the provided `splits`.
     * This function should be called atomically, immediately after deployment.
     * Only callable once.
     * @param splits Splits to configure the contract with. Must add up to
     * 10_000 BPS.
     */
    function initialize(Split[] calldata splits) external;

    /**
     * @notice Drains the contract's ETH balance to the configured `splits`.
     * Reverts if not initialized.
     */
    function drainETH() external;

    /**
     * @notice Drains the contract's balance of an input ERC20 token to the
     * configured `splits`. Reverts if not initialized.
     * @param ERC20TokenAddress The address of the ERC20 token to split.
     */
    function drainERC20(address ERC20TokenAddress) external;

    /**
     * @notice Returns the configured `splits`.
     * @return Split[] memory The configured `splits`.
     */
    function getSplits() external view returns (Split[] memory);

    /**
     * @notice Indicates the type of the contract, e.g. `SplitAtomicV0`.
     * @return type_ The type of the contract.
     */
    function type_() external pure returns (bytes32);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 25
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

[{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"ERC20TokenAddress","type":"address"}],"name":"DrainedERC20","type":"event"},{"anonymous":false,"inputs":[],"name":"DrainedETH","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"type_","type":"bytes32"}],"name":"Initialized","type":"event"},{"inputs":[{"internalType":"address","name":"ERC20TokenAddress","type":"address"}],"name":"drainERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"drainETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getSplits","outputs":[{"components":[{"internalType":"address payable","name":"recipient","type":"address"},{"internalType":"uint16","name":"basisPoints","type":"uint16"}],"internalType":"struct Split[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address payable","name":"recipient","type":"address"},{"internalType":"uint16","name":"basisPoints","type":"uint16"}],"internalType":"struct Split[]","name":"splits","type":"tuple[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"type_","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]