Contract

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.22;

// Contracts
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { Pausable } from "@openzeppelin/contracts/utils/Pausable.sol";

// Interfaces
import { IAugustusFeeVault } from "../interfaces/IAugustusFeeVault.sol";
import { IERC20 } from "@openzeppelin/token/ERC20/IERC20.sol";

// Libraries
import { ERC20Utils } from "../libraries/ERC20Utils.sol";

/// @title Augstus Fee Vault
/// @notice Allows partners to collect fees stored in the vault, and allows augustus contracts to register fees
contract AugustusFeeVault is IAugustusFeeVault, Ownable, Pausable {
    /*//////////////////////////////////////////////////////////////
                                LIBRARIES
    //////////////////////////////////////////////////////////////*/

    using ERC20Utils for IERC20;

    /*//////////////////////////////////////////////////////////////
                                VARIABLES
    //////////////////////////////////////////////////////////////*/

    /// @dev A mapping of augustus contract addresses to their approval status
    mapping(address augustus => bool approved) public augustusContracts;

    // @dev Mapping of fee tokens to stored fee amounts
    mapping(address account => mapping(IERC20 token => uint256 amount)) public fees;

    // @dev Mapping of fee tokens to allocated fee amounts
    mapping(IERC20 token => uint256 amount) public allocatedFees;

    /*//////////////////////////////////////////////////////////////
                              CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(address[] memory _augustusContracts, address owner) Ownable(owner) {
        // Set augustus verifier contracts
        for (uint256 i = 0; i < _augustusContracts.length; i++) {
            augustusContracts[_augustusContracts[i]] = true;
            emit AugustusApprovalSet(_augustusContracts[i], true);
        }
    }

    /*//////////////////////////////////////////////////////////////
                               MODIFIERS
    //////////////////////////////////////////////////////////////*/

    /// @dev Modifier to check if the caller is an approved augustus contract
    modifier onlyApprovedAugustus() {
        if (!augustusContracts[msg.sender]) {
            revert UnauthorizedCaller();
        }
        _;
    }

    /// @dev Verifies that the withdraw amount is not zero
    modifier validAmount(uint256 amount) {
        // Check if amount is zero
        if (amount == 0) {
            revert InvalidWithdrawAmount();
        }
        _;
    }

    /*//////////////////////////////////////////////////////////////
                                 PUBLIC
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc IAugustusFeeVault
    function withdrawSomeERC20(
        IERC20 token,
        uint256 amount,
        address recipient
    )
        public
        validAmount(amount)
        whenNotPaused
        returns (bool success)
    {
        /// Check recipient
        recipient = _checkRecipient(recipient);

        // Update fees mapping
        _updateFees(token, msg.sender, amount);

        // Transfer tokens to recipient
        token.safeTransfer(recipient, amount);

        // Return success
        return true;
    }

    /// @inheritdoc IAugustusFeeVault
    function getUnallocatedFees(IERC20 token) public view returns (uint256 unallocatedFees) {
        // Get the allocated fees for the given token
        uint256 allocatedFee = allocatedFees[token];

        // Get the balance of the given token
        uint256 balance = token.getBalance(address(this));

        // If the balance is bigger than the allocated fee, then the unallocated fees should
        // be equal to the balance minus the allocated fee
        if (balance > allocatedFee) {
            // Set the unallocated fees to the balance minus the allocated fee
            unallocatedFees = balance - allocatedFee;
        }
    }

    /*///////////////////////////////////////////////////////////////
                                EXTERNAL
    //////////////////////////////////////////////////////////////*/

    /// @inheritdoc IAugustusFeeVault
    function batchWithdrawSomeERC20(
        IERC20[] calldata tokens,
        uint256[] calldata amounts,
        address recipient
    )
        external
        whenNotPaused
        returns (bool success)
    {
        // Check if the length of the tokens and amounts arrays are the same
        if (tokens.length != amounts.length) {
            revert InvalidParameterLength();
        }

        // Loop through the tokens and amounts arrays
        for (uint256 i; i < tokens.length; ++i) {
            // Collect fees for the given token
            if (!withdrawSomeERC20(tokens[i], amounts[i], recipient)) {
                // Revert if collect fails
                revert BatchCollectFailed();
            }
        }

        // Return success
        return true;
    }

    /// @inheritdoc IAugustusFeeVault
    function withdrawAllERC20(IERC20 token, address recipient) public whenNotPaused returns (bool success) {
        // Check recipient
        recipient = _checkRecipient(recipient);

        // Get the total fees for msg.sender in the given token
        uint256 totalBalance = fees[msg.sender][token];

        // Make sure the amount is not zero
        if (totalBalance == 0) {
            revert InvalidWithdrawAmount();
        }

        // Update fees mapping
        _updateFees(token, msg.sender, totalBalance);

        // Transfer tokens to recipient
        token.safeTransfer(recipient, totalBalance);

        // Return success
        return true;
    }

    /// @inheritdoc IAugustusFeeVault
    function batchWithdrawAllERC20(
        IERC20[] calldata tokens,
        address recipient
    )
        external
        whenNotPaused
        returns (bool success)
    {
        // Loop through the tokens array
        for (uint256 i; i < tokens.length; ++i) {
            // Collect all fees for the given token
            if (!withdrawAllERC20(tokens[i], recipient)) {
                // Revert if withdrawAllERC20 fails
                revert BatchCollectFailed();
            }
        }

        // Return success
        return true;
    }

    /// @inheritdoc IAugustusFeeVault
    function registerFees(FeeRegistration memory feeData) external onlyApprovedAugustus {
        // Get the addresses, tokens, and feeAmounts from the feeData struct
        address[] memory addresses = feeData.addresses;
        IERC20 token = feeData.token;
        uint256[] memory feeAmounts = feeData.fees;

        // Make sure the length of the addresses and feeAmounts arrays are the same
        if (addresses.length != feeAmounts.length) {
            revert InvalidParameterLength();
        }

        // Loop through the addresses and fees arrays
        for (uint256 i; i < addresses.length; ++i) {
            // Register the fees for the given address and token if the fee and address are not zero
            if (feeAmounts[i] != 0 && addresses[i] != address(0)) {
                _registerFee(addresses[i], token, feeAmounts[i]);
            }
        }
    }

    /// @inheritdoc IAugustusFeeVault
    function setAugustusApproval(address augustus, bool approved) external onlyOwner {
        // Set the approval status for the given augustus contract
        augustusContracts[augustus] = approved;
        // Emit an event
        emit AugustusApprovalSet(augustus, approved);
    }

    /// @inheritdoc IAugustusFeeVault
    function setContractPauseState(bool _isPaused) external onlyOwner {
        // Set the pause state
        if (_isPaused) {
            _pause();
        } else {
            _unpause();
        }
    }

    /// @inheritdoc IAugustusFeeVault
    function getBalance(IERC20 token, address partner) external view returns (uint256 feeBalance) {
        // Get the fees for the given token and partner
        return fees[partner][token];
    }

    /// @inheritdoc IAugustusFeeVault
    function batchGetBalance(
        IERC20[] calldata tokens,
        address partner
    )
        external
        view
        returns (uint256[] memory feeBalances)
    {
        // Initialize the feeBalances array
        feeBalances = new uint256[](tokens.length);

        // Loop through the tokens array
        for (uint256 i; i < tokens.length; ++i) {
            // Get the fees for the given token and partner
            feeBalances[i] = fees[partner][tokens[i]];
        }
    }

    /*//////////////////////////////////////////////////////////////
                                PRIVATE
    //////////////////////////////////////////////////////////////*/

    /// @notice Register fees for a given account and token
    /// @param account The account to register the fees for
    /// @param token The token to register the fees for
    /// @param fee The amount of fees to register
    function _registerFee(address account, IERC20 token, uint256 fee) private {
        // Get the unallocated fees for the given token
        uint256 unallocatedFees = getUnallocatedFees(token);

        // Make sure the fee is not bigger than the unallocated fees
        if (fee > unallocatedFees) {
            // If it is, set the fee to the unallocated fees
            fee = unallocatedFees;
        }

        // Update the fees mapping
        fees[account][token] += fee;

        // Update the allocated fees mapping
        allocatedFees[token] += fee;
    }

    /// @notice Update fees and allocatedFees for a given token and claimer
    /// @param token The token to update the fees for
    /// @param claimer The address to withdraw the fees for
    /// @param withdrawAmount The amount of fees to withdraw
    function _updateFees(IERC20 token, address claimer, uint256 withdrawAmount) private {
        // get the fees for the claimer
        uint256 feesForClaimer = fees[claimer][token];

        // revert if withdraw amount is bigger than the fees for the claimer
        if (withdrawAmount > feesForClaimer) {
            revert InvalidWithdrawAmount();
        }

        // update the allocated fees
        allocatedFees[token] -= withdrawAmount;

        // update the fees for the claimer
        fees[claimer][token] -= withdrawAmount;
    }

    /// @notice Check if recipient is zero address and set it to msg sender if it is, otherwise return recipient
    /// @param recipient The recipient address
    /// @return recipient The updated recipient address
    function _checkRecipient(address recipient) private view returns (address) {
        // Allow arbitrary recipient unless it is zero address
        if (recipient == address(0)) {
            recipient = msg.sender;
        }

        // Return recipient
        return recipient;
    }

    /*//////////////////////////////////////////////////////////////
                                RECEIVE
    //////////////////////////////////////////////////////////////*/

    /// @notice Reverts if the caller is one of the following:
    //         - an externally-owned account
    //         - a contract in construction
    //         - an address where a contract will be created
    //         - an address where a contract lived, but was destroyed
    receive() external payable {
        address addr = msg.sender;
        // solhint-disable-next-line no-inline-assembly
        assembly ("memory-safe") {
            if iszero(extcodesize(addr)) { revert(0, 0) }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

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

// Interfaces
import { IERC20 } from "@openzeppelin/token/ERC20/IERC20.sol";

/// @title IAugustusFeeVault
/// @notice Interface for the AugustusFeeVault contract
interface IAugustusFeeVault {
    /*//////////////////////////////////////////////////////////////
                                 ERRORS
    //////////////////////////////////////////////////////////////*/

    /// @notice Error emitted when withdraw amount is zero or exceeds the stored amount
    error InvalidWithdrawAmount();

    /// @notice Error emmitted when caller is not an approved augustus contract
    error UnauthorizedCaller();

    /// @notice Error emitted when an invalid parameter length is passed
    error InvalidParameterLength();

    /// @notice Error emitted when batch withdraw fails
    error BatchCollectFailed();

    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    /// @notice Emitted when an augustus contract approval status is set
    /// @param augustus The augustus contract address
    /// @param approved The approval status
    event AugustusApprovalSet(address indexed augustus, bool approved);

    /*//////////////////////////////////////////////////////////////
                                STRUCTS
    //////////////////////////////////////////////////////////////*/

    /// @notice Struct to register fees
    /// @param addresses The addresses to register fees for
    /// @param token The token to register fees for
    /// @param fees The fees to register
    struct FeeRegistration {
        address[] addresses;
        IERC20 token;
        uint256[] fees;
    }

    /*//////////////////////////////////////////////////////////////
                                COLLECT
    //////////////////////////////////////////////////////////////*/

    /// @notice Allows partners to withdraw fees allocated to them and stored in the vault
    /// @param token The token to withdraw fees in
    /// @param amount The amount of fees to withdraw
    /// @param recipient The address to send the fees to
    /// @return success Whether the transfer was successful or not
    function withdrawSomeERC20(IERC20 token, uint256 amount, address recipient) external returns (bool success);

    /// @notice Allows partners to withdraw all fees allocated to them and stored in the vault for a given token
    /// @param token The token to withdraw fees in
    /// @param recipient The address to send the fees to
    /// @return success Whether the transfer was successful or not
    function withdrawAllERC20(IERC20 token, address recipient) external returns (bool success);

    /// @notice Allows partners to withdraw all fees allocated to them and stored in the vault for multiple tokens
    /// @param tokens The tokens to withdraw fees i
    /// @param recipient The address to send the fees to
    /// @return success Whether the transfer was successful or not
    function batchWithdrawAllERC20(IERC20[] calldata tokens, address recipient) external returns (bool success);

    /// @notice Allows partners to withdraw fees allocated to them and stored in the vault
    /// @param tokens The tokens to withdraw fees in
    /// @param amounts The amounts of fees to withdraw
    /// @param recipient The address to send the fees to
    /// @return success Whether the transfer was successful or not
    function batchWithdrawSomeERC20(
        IERC20[] calldata tokens,
        uint256[] calldata amounts,
        address recipient
    )
        external
        returns (bool success);

    /*//////////////////////////////////////////////////////////////
                            BALANCE GETTERS
    //////////////////////////////////////////////////////////////*/

    /// @notice Get the balance of a given token for a given partner
    /// @param token The token to get the balance of
    /// @param partner The partner to get the balance for
    /// @return feeBalance The balance of the given token for the given partner
    function getBalance(IERC20 token, address partner) external view returns (uint256 feeBalance);

    /// @notice Get the balances of a given partner for multiple tokens
    /// @param tokens The tokens to get the balances of
    /// @param partner The partner to get the balances for
    /// @return feeBalances The balances of the given tokens for the given partner
    function batchGetBalance(
        IERC20[] calldata tokens,
        address partner
    )
        external
        view
        returns (uint256[] memory feeBalances);

    /// @notice Returns the unallocated fees for a given token
    /// @param token The token to get the unallocated fees for
    /// @return unallocatedFees The unallocated fees for the given token
    function getUnallocatedFees(IERC20 token) external view returns (uint256 unallocatedFees);

    /*//////////////////////////////////////////////////////////////
                                 OWNER
    //////////////////////////////////////////////////////////////*/

    /// @notice Registers the given feeData to the vault
    /// @param feeData The fee registration data
    function registerFees(FeeRegistration memory feeData) external;

    /// @notice Sets the augustus contract approval status
    /// @param augustus The augustus contract address
    /// @param approved The approval status
    function setAugustusApproval(address augustus, bool approved) external;

    /// @notice Sets the contract pause state
    /// @param _isPaused The new pause state
    function setContractPauseState(bool _isPaused) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

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

// Interfaces
import { IERC20 } from "@openzeppelin/token/ERC20/IERC20.sol";

/// @title ERC20Utils
/// @notice Optimized functions for ERC20 tokens
library ERC20Utils {
    /*//////////////////////////////////////////////////////////////
                                ERRORS
    //////////////////////////////////////////////////////////////*/

    error IncorrectEthAmount();
    error PermitFailed();
    error TransferFromFailed();
    error TransferFailed();
    error ApprovalFailed();

    /*//////////////////////////////////////////////////////////////
                               CONSTANTS
    //////////////////////////////////////////////////////////////*/

    IERC20 internal constant ETH = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);

    /*//////////////////////////////////////////////////////////////
                                APPROVE
    //////////////////////////////////////////////////////////////*/

    /// @dev Vendored from Solady by @vectorized - SafeTransferLib.approveWithRetry
    /// https://github.com/Vectorized/solady/src/utils/SafeTransferLib.sol#L325
    /// Instead of approving a specific amount, this function approves for uint256(-1) (type(uint256).max).
    function approve(IERC20 token, address to) internal {
        // solhint-disable-next-line no-inline-assembly
        assembly ("memory-safe") {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // Store the `amount`
                // argument (type(uint256).max).
            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
            // Perform the approval, retrying upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                mstore(0x34, 0) // Store 0 for the `amount`.
                mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
                pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.
                mstore(0x34, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // Store
                    // type(uint256).max for the `amount`.
                // Retry the approval, reverting upon failure.
                if iszero(
                    and(
                        or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                        call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                    )
                ) {
                    mstore(0, 0x8164f84200000000000000000000000000000000000000000000000000000000)
                    // store the selector (error ApprovalFailed())
                    revert(0, 4) // revert with error selector
                }
            }
            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
        }
    }

    /*//////////////////////////////////////////////////////////////
                                PERMIT
    //////////////////////////////////////////////////////////////*/

    /// @dev Executes an ERC20 permit and reverts if invalid length is provided
    function permit(IERC20 token, bytes calldata data) internal {
        // solhint-disable-next-line no-inline-assembly
        assembly ("memory-safe") {
            // check the permit length
            switch data.length
            // 32 * 7 = 224 EIP2612 Permit
            case 224 {
                let x := mload(64) // get the free memory pointer
                mstore(x, 0xd505accf00000000000000000000000000000000000000000000000000000000) // store the selector
                    // function permit(address owner, address spender, uint256
                    // amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
                calldatacopy(add(x, 4), data.offset, 224) // store the args
                pop(call(gas(), token, 0, x, 228, 0, 32)) // call ERC20 permit, skip checking return data
            }
            // 32 * 8 = 256 DAI-Style Permit
            case 256 {
                let x := mload(64) // get the free memory pointer
                mstore(x, 0x8fcbaf0c00000000000000000000000000000000000000000000000000000000) // store the selector
                    // function permit(address holder, address spender, uint256
                    // nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s)
                calldatacopy(add(x, 4), data.offset, 256) // store the args
                pop(call(gas(), token, 0, x, 260, 0, 32)) // call ERC20 permit, skip checking return data
            }
            default {
                mstore(0, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the selector
                    // (error PermitFailed())
                revert(0, 4)
            }
        }
    }

    /*//////////////////////////////////////////////////////////////
                                 ETH
    //////////////////////////////////////////////////////////////*/

    /// @dev Returns 1 if the token is ETH, 0 if not ETH
    function isETH(IERC20 token, uint256 amount) internal view returns (uint256 fromETH) {
        // solhint-disable-next-line no-inline-assembly
        assembly ("memory-safe") {
            // If token is ETH
            if eq(token, 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
                // if msg.value is not equal to fromAmount, then revert
                if xor(amount, callvalue()) {
                    mstore(0, 0x8b6ebb4d00000000000000000000000000000000000000000000000000000000) // store the selector
                        // (error IncorrectEthAmount())
                    revert(0, 4) // revert with error selector
                }
                // return 1 if ETH
                fromETH := 1
            }
            // If token is not ETH
            if xor(token, 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
                // if msg.value is not equal to 0, then revert
                if gt(callvalue(), 0) {
                    mstore(0, 0x8b6ebb4d00000000000000000000000000000000000000000000000000000000) // store the selector
                    // (error IncorrectEthAmount())
                    revert(0, 4) // revert with error selector
                }
            }
        }
        // return 0 if not ETH
    }

    /*//////////////////////////////////////////////////////////////
                                TRANSFER
    //////////////////////////////////////////////////////////////*/

    /// @dev Executes transfer and reverts if it fails, works for both ETH and ERC20 transfers
    function safeTransfer(IERC20 token, address recipient, uint256 amount) internal returns (bool success) {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            switch eq(token, 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
            // ETH
            case 1 {
                // transfer ETH
                // Cap gas at 10000 to avoid reentrancy
                success := call(10000, recipient, amount, 0, 0, 0, 0)
            }
            // ERC20
            default {
                let x := mload(64) // get the free memory pointer
                mstore(x, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) // store the selector
                    // (function transfer(address recipient, uint256 amount))
                mstore(add(x, 4), recipient) // store the recipient
                mstore(add(x, 36), amount) // store the amount
                success := call(gas(), token, 0, x, 68, 0, 32) // call transfer
                if success {
                    switch returndatasize()
                    // check the return data size
                    case 0 { success := gt(extcodesize(token), 0) }
                    default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }
                }
            }
            if iszero(success) {
                mstore(0, 0x90b8ec1800000000000000000000000000000000000000000000000000000000) // store the selector
                    // (error TransferFailed())
                revert(0, 4) // revert with error selector
            }
        }
    }

    /*//////////////////////////////////////////////////////////////
                             TRANSFER FROM
    //////////////////////////////////////////////////////////////*/

    /// @dev Executes transferFrom and reverts if it fails
    function safeTransferFrom(
        IERC20 srcToken,
        address sender,
        address recipient,
        uint256 amount
    )
        internal
        returns (bool success)
    {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            let x := mload(64) // get the free memory pointer
            mstore(x, 0x23b872dd00000000000000000000000000000000000000000000000000000000) // store the selector
                // (function transferFrom(address sender, address recipient,
                // uint256 amount))
            mstore(add(x, 4), sender) // store the sender
            mstore(add(x, 36), recipient) // store the recipient
            mstore(add(x, 68), amount) // store the amount
            success := call(gas(), srcToken, 0, x, 100, 0, 32) // call transferFrom
            if success {
                switch returndatasize()
                // check the return data size
                case 0 { success := gt(extcodesize(srcToken), 0) }
                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }
            }
            if iszero(success) {
                mstore(x, 0x7939f42400000000000000000000000000000000000000000000000000000000) // store the selector
                    // (error TransferFromFailed())
                revert(x, 4) // revert with error selector
            }
        }
    }

    /*//////////////////////////////////////////////////////////////
                                BALANCE
    //////////////////////////////////////////////////////////////*/

    /// @dev Returns the balance of an account, works for both ETH and ERC20 tokens
    function getBalance(IERC20 token, address account) internal view returns (uint256 balanceOf) {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            switch eq(token, 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
            // ETH
            case 1 { balanceOf := balance(account) }
            // ERC20
            default {
                let x := mload(64) // get the free memory pointer
                mstore(x, 0x70a0823100000000000000000000000000000000000000000000000000000000) // store the selector
                    // (function balanceOf(address account))
                mstore(add(x, 4), account) // store the account
                let success := staticcall(gas(), token, x, 36, x, 32) // call balanceOf
                if success { balanceOf := mload(x) } // load the balance
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

{
  "remappings": [
    "@prb/test/=lib/prb-test/src/",
    "forge-std/=lib/forge-std/src/",
    "@openzeppelin/=lib/openzeppelin-contracts/contracts/",
    "@solady/=lib/solady/src/",
    "@create3/=lib/create3-factory/src/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "create3-factory/=lib/create3-factory/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "foundry-huff/=lib/foundry-huff/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "prb-test/=lib/prb-test/src/",
    "solady/=lib/solady/",
    "solidity-bytes-utils/=lib/solidity-bytes-utils/contracts/",
    "solidity-stringutils/=lib/foundry-huff/lib/solidity-stringutils/",
    "solmate/=lib/create3-factory/lib/solmate/src/",
    "stringutils/=lib/foundry-huff/lib/solidity-stringutils/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "shanghai",
  "viaIR": true,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address[]","name":"_augustusContracts","type":"address[]"},{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BatchCollectFailed","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"InvalidParameterLength","type":"error"},{"inputs":[],"name":"InvalidWithdrawAmount","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"UnauthorizedCaller","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"augustus","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"AugustusApprovalSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"allocatedFees","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"augustus","type":"address"}],"name":"augustusContracts","outputs":[{"internalType":"bool","name":"approved","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"internalType":"address","name":"partner","type":"address"}],"name":"batchGetBalance","outputs":[{"internalType":"uint256[]","name":"feeBalances","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"internalType":"address","name":"recipient","type":"address"}],"name":"batchWithdrawAllERC20","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"address","name":"recipient","type":"address"}],"name":"batchWithdrawSomeERC20","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"fees","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"partner","type":"address"}],"name":"getBalance","outputs":[{"internalType":"uint256","name":"feeBalance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"getUnallocatedFees","outputs":[{"internalType":"uint256","name":"unallocatedFees","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256[]","name":"fees","type":"uint256[]"}],"internalType":"struct IAugustusFeeVault.FeeRegistration","name":"feeData","type":"tuple"}],"name":"registerFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"augustus","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setAugustusApproval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isPaused","type":"bool"}],"name":"setContractPauseState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"recipient","type":"address"}],"name":"withdrawAllERC20","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"withdrawSomeERC20","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000d7e24a49944f7972ceb826c7557580658f9c33030000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 000000000000000000000000d7e24a49944f7972ceb826c7557580658f9c3303
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000