// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (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;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// pragma solidity >=0.5.0;
// pragma experimental ABIEncoderV2;
pragma solidity 0.8.20;

address constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;

/**
 * @title IMulticall3
 * @author Matt Solomon
 * @custom:url https://github.com/mds1
 * @dev multicall3 interface
 * check [multicall3.com](https://www.multicall3.com/) for more info
 */
interface IMulticall3 {
    struct Call {
        address target;
        bytes callData;
    }

    struct Call3 {
        address target;
        bool allowFailure;
        bytes callData;
    }

    struct Call3Value {
        address target;
        bool allowFailure;
        uint256 value;
        bytes callData;
    }

    struct Result {
        bool success;
        bytes returnData;
    }

    function aggregate(Call[] calldata calls)
        external
        payable
        returns (uint256 blockNumber, bytes[] memory returnData);

    function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);

    function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);

    function blockAndAggregate(Call[] calldata calls)
        external
        payable
        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);

    function getBasefee() external view returns (uint256 basefee);

    function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);

    function getBlockNumber() external view returns (uint256 blockNumber);

    function getChainId() external view returns (uint256 chainid);

    function getCurrentBlockCoinbase() external view returns (address coinbase);

    function getCurrentBlockDifficulty() external view returns (uint256 difficulty);

    function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);

    function getCurrentBlockTimestamp() external view returns (uint256 timestamp);

    function getEthBalance(address addr) external view returns (uint256 balance);

    function getLastBlockHash() external view returns (bytes32 blockHash);

    function tryAggregate(bool requireSuccess, Call[] calldata calls)
        external
        payable
        returns (Result[] memory returnData);

    function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)
        external
        payable
        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
}

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

import {IMulticall3} from "@interfaces/IMulticall3.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title Multicall3Restricted
 * @author Metaxona
 * @custom:github https://github.com/Metaxona
 * @custom:version 0.0.1
 *
 * @dev This is a modified version of the Multicall3 by Matt Solomon
 * check [multicall3.com](https://www.multicall3.com/) for more info
 *
 * with modifications to restrict access on calls to prevent unauthorized users
 * from calling the aggregate functions which can be exploited when for example
 * a token gives allowance to this contract making any account able to call transferFrom
 * using the multicall contract.
 *
 * This modification makes the multicall contract a private contract allowing only authorized
 * accounts to call it to avoid cases like the one stated above.
 */
contract Multicall3Restricted is Ownable, IMulticall3 {
    mapping(address => bool) permissions;

    error CanNotBeZeroAddress();
    error UnAuthorizedAccess();
    error RenounceDisabled();

    event PermissionGranted(address indexed caller, address indexed account);
    event PermissionRevoked(address indexed caller, address indexed account);

    constructor(address initialOwner) Ownable(initialOwner) {
        _grantPermission(initialOwner);
    }

    /**
     * @param account account to check the permission of
     *
     * @notice this function is used to check if an account has permission to access
     * the write functions on the contract
     */
    function hasPermission(address account) public view returns (bool) {
        return permissions[account];
    }

    /**
     * @param account account to grant the permission to
     *
     * @notice this is an internal function used to grant permission to an account
     * allowing them to access the restricted functions
     */
    function _grantPermission(address account) internal {
        if (account == address(0)) revert CanNotBeZeroAddress();
        permissions[account] = true;
        emit PermissionGranted(msg.sender, account);
    }

    /**
     * @param account account to revoke the permission from
     *
     * @notice this is an internal function used to revoke permission from an account
     * preventing them from accessing restricted functions
     */
    function _revokePermission(address account) internal {
        permissions[account] = false;
        emit PermissionRevoked(msg.sender, account);
    }

    /**
     * @param account account to grant the permission to
     *
     * @notice this function is used to wrap the `_grantPermission` function
     * and restricting access to it to only the contract owner
     */
    function grantPermission(address account) external onlyOwner {
        _grantPermission(account);
    }

    /**
     * @param account account to revoke the permission from
     *
     * @notice this function is used to wrap the `_revokePermission` function
     * and restricting access to it to only the contract owner
     */
    function revokePermission(address account) external onlyOwner {
        _revokePermission(account);
    }

    /**
     * @param newOwner the account whoc will become the new contract owner
     *
     * @notice this function also revokes permission from the previous owner
     * and grants permission to the new owner
     */
    function transferOwnership(address newOwner) public override(Ownable) onlyOwner {
        address previousOwner = owner();
        _revokePermission(previousOwner);
        super.transferOwnership(newOwner);
        _grantPermission(newOwner);
    }

    /**
     * @notice this function is disabled to prevent accidentally renouncing the contract's
     * ownership
     */
    function renounceOwnership() public override(Ownable) onlyOwner {
        _transferOwnership(owner());
        revert RenounceDisabled();
    }

    // MULTICALL3 BELOW <- [multicall3.com](https://www.multicall3.com/) For More Info

    /**
     * @notice Backwards-compatible call aggregation with Multicall
     * @param calls An array of Call structs
     * @return blockNumber The block number where the calls were executed
     * @return returnData An array of bytes containing the responses
     */
    function aggregate(Call[] calldata calls)
        public
        payable
        requiresPermission
        returns (uint256 blockNumber, bytes[] memory returnData)
    {
        blockNumber = block.number;
        uint256 length = calls.length;
        returnData = new bytes[](length);
        Call calldata call;
        for (uint256 i = 0; i < length;) {
            bool success;
            call = calls[i];
            (success, returnData[i]) = call.target.call(call.callData);
            require(success, "Multicall3: call failed");
            unchecked {
                ++i;
            }
        }
    }

    /**
     * @notice Backwards-compatible with Multicall2
     * @notice Aggregate calls without requiring success
     * @param requireSuccess If true, require all calls to succeed
     * @param calls An array of Call structs
     * @return returnData An array of Result structs
     */
    function tryAggregate(bool requireSuccess, Call[] calldata calls)
        public
        payable
        requiresPermission
        returns (Result[] memory returnData)
    {
        uint256 length = calls.length;
        returnData = new Result[](length);
        Call calldata call;
        for (uint256 i = 0; i < length;) {
            Result memory result = returnData[i];
            call = calls[i];
            (result.success, result.returnData) = call.target.call(call.callData);
            if (requireSuccess) require(result.success, "Multicall3: call failed");
            unchecked {
                ++i;
            }
        }
    }

    /**
     * @notice Backwards-compatible with Multicall2
     * @notice Aggregate calls and allow failures using tryAggregate
     * @param calls An array of Call structs
     * @return blockNumber The block number where the calls were executed
     * @return blockHash The hash of the block where the calls were executed
     * @return returnData An array of Result structs
     */
    function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)
        public
        payable
        requiresPermission
        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)
    {
        blockNumber = block.number;
        blockHash = blockhash(block.number);
        returnData = tryAggregate(requireSuccess, calls);
    }

    /**
     * @notice Backwards-compatible with Multicall2
     * @notice Aggregate calls and allow failures using tryAggregate
     * @param calls An array of Call structs
     * @return blockNumber The block number where the calls were executed
     * @return blockHash The hash of the block where the calls were executed
     * @return returnData An array of Result structs
     */
    function blockAndAggregate(Call[] calldata calls)
        public
        payable
        requiresPermission
        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)
    {
        (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
    }

    /**
     * @notice Aggregate calls, ensuring each returns success if required
     * @param calls An array of Call3 structs
     * @return returnData An array of Result structs
     */
    function aggregate3(Call3[] calldata calls)
        public
        payable
        requiresPermission
        returns (Result[] memory returnData)
    {
        uint256 length = calls.length;
        returnData = new Result[](length);
        Call3 calldata calli;
        for (uint256 i = 0; i < length;) {
            Result memory result = returnData[i];
            calli = calls[i];
            (result.success, result.returnData) = calli.target.call(calli.callData);
            assembly {
                // Revert if the call fails and failure is not allowed
                // `allowFailure := calldataload(add(calli, 0x20))` and `success := mload(result)`
                if iszero(or(calldataload(add(calli, 0x20)), mload(result))) {
                    // set "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
                    mstore(0x00, 0x08c379a000000000000000000000000000000000000000000000000000000000)
                    // set data offset
                    mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)
                    // set length of revert string
                    mstore(0x24, 0x0000000000000000000000000000000000000000000000000000000000000017)
                    // set revert string: bytes32(abi.encodePacked("Multicall3: call failed"))
                    mstore(0x44, 0x4d756c746963616c6c333a2063616c6c206661696c6564000000000000000000)
                    revert(0x00, 0x64)
                }
            }
            unchecked {
                ++i;
            }
        }
    }

    /**
     * @notice Aggregate calls with a msg value
     * @notice Reverts if msg.value is less than the sum of the call values
     * @param calls An array of Call3Value structs
     * @return returnData An array of Result structs
     */
    function aggregate3Value(Call3Value[] calldata calls)
        public
        payable
        requiresPermission
        returns (Result[] memory returnData)
    {
        uint256 valAccumulator;
        uint256 length = calls.length;
        returnData = new Result[](length);
        Call3Value calldata calli;
        for (uint256 i = 0; i < length;) {
            Result memory result = returnData[i];
            calli = calls[i];
            uint256 val = calli.value;
            // Humanity will be a Type V Kardashev Civilization before this overflows - andreas
            // ~ 10^25 Wei in existence << ~ 10^76 size uint fits in a uint256
            unchecked {
                valAccumulator += val;
            }
            (result.success, result.returnData) = calli.target.call{value: val}(calli.callData);
            assembly {
                // Revert if the call fails and failure is not allowed
                // `allowFailure := calldataload(add(calli, 0x20))` and `success := mload(result)`
                if iszero(or(calldataload(add(calli, 0x20)), mload(result))) {
                    // set "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
                    mstore(0x00, 0x08c379a000000000000000000000000000000000000000000000000000000000)
                    // set data offset
                    mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)
                    // set length of revert string
                    mstore(0x24, 0x0000000000000000000000000000000000000000000000000000000000000017)
                    // set revert string: bytes32(abi.encodePacked("Multicall3: call failed"))
                    mstore(0x44, 0x4d756c746963616c6c333a2063616c6c206661696c6564000000000000000000)
                    revert(0x00, 0x84)
                }
            }
            unchecked {
                ++i;
            }
        }
        // Finally, make sure the msg.value = SUM(call[0...i].value)
        require(msg.value == valAccumulator, "Multicall3: value mismatch");
    }

    /**
     * @notice Returns the block hash for the given block number
     * @param blockNumber The block number
     */
    function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash) {
        blockHash = blockhash(blockNumber);
    }

    /**
     * @notice Returns the block number
     */
    function getBlockNumber() public view returns (uint256 blockNumber) {
        blockNumber = block.number;
    }

    /**
     * @notice Returns the block coinbase
     */
    function getCurrentBlockCoinbase() public view returns (address coinbase) {
        coinbase = block.coinbase;
    }

    /**
     * @notice Returns the block difficulty
     */
    function getCurrentBlockDifficulty() public view returns (uint256 difficulty) {
        difficulty = block.prevrandao;
    }

    /**
     * @notice Returns the block gas limit
     */
    function getCurrentBlockGasLimit() public view returns (uint256 gaslimit) {
        gaslimit = block.gaslimit;
    }

    /**
     * @notice Returns the block timestamp
     */
    function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
        timestamp = block.timestamp;
    }

    /**
     * @notice Returns the (ETH) balance of a given address
     */
    function getEthBalance(address addr) public view returns (uint256 balance) {
        balance = addr.balance;
    }

    /**
     * @notice Returns the block hash of the last block
     */
    function getLastBlockHash() public view returns (bytes32 blockHash) {
        unchecked {
            blockHash = blockhash(block.number - 1);
        }
    }

    /**
     * @notice Gets the base fee of the given block
     * @notice Can revert if the BASEFEE opcode is not implemented by the given chain
     */
    function getBasefee() public view returns (uint256 basefee) {
        basefee = block.basefee;
    }

    /**
     * @notice Returns the chain id
     */
    function getChainId() public view returns (uint256 chainid) {
        chainid = block.chainid;
    }

    modifier requiresPermission() {
        if (!hasPermission(msg.sender)) revert UnAuthorizedAccess();
        _;
    }
}

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

{
  "compilationTarget": {
    "src/contracts/multicall/Multicall3Restricted.sol": "Multicall3Restricted"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@common/=src/common/",
    ":@contracts/=src/contracts/",
    ":@helpers/=helpers/",
    ":@interfaces/=src/interfaces/",
    ":@openzeppelin-foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/",
    ":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    ":@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",
    ":@test-utils/=test/common/",
    ":@types/=src/types/",
    ":ds-test/=lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/",
    ":openzeppelin-foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/",
    ":sizeChecker/=lib/Solidity_Contract_Size_Checker/",
    ":solidity-stringutils/=lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/"
  ]
}