Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import {IUniversalMinter} from "../interfaces/IUniversalMinter.sol";
import {IMinterAgent} from "../interfaces/IMinterAgent.sol";
import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

/// @title Universal Minter.
/// @notice Mints ERC721 or ERC1155 tokens on behalf of an account on any standard ER721 or ERC1155 contract. Optionally collects fees and rewards for a finder.
contract UniversalMinter is IUniversalMinter {
    /// @dev Default fee collects per token minted
    uint256 constant FEE_PER_TOKEN = 0.000222 ether;
    /// @dev Default reward finder collects per token minted
    uint256 constant FINDER_REWARD_PER_TOKEN = 0.000555 ether;
    /// @dev default fee collects per token minted when no finder is specified
    uint256 constant FEE_PER_TOKEN_WHEN_NO_FINDER = FEE_PER_TOKEN + FINDER_REWARD_PER_TOKEN;
    /// @dev Rewards allocated to addresses that can be withdran from later
    mapping(address => uint256) rewardAllocations;
    /// @dev How much has been withdrawn so far by each address
    mapping(address => uint256) withdrawn;

    /// @dev The address of the Protocol's fee recipient
    address public immutable feeRecipient;
    /// @dev The address of the minter agent implementation, which is cloned for each EOA
    address public immutable agentImpl;

    constructor(address _minterAgentImpl, address _feeRecipient) {
        feeRecipient = _feeRecipient;
        agentImpl = _minterAgentImpl;
    }

    /// Executes mint calls on a series of target ERC721 or ERC1155 contracts, then transfers the minted tokens to the calling account.
    /// Adds a mint fee to the msg.value sent to the contract.
    /// Assumes that the mint function for each target follows the ERC721 or ERC1155 standard for minting - which is that
    /// the a safe transfer is used to transfer tokens - and the corresponding safeTransfer callbacks on the receiving account are called AFTER minting the tokens.
    /// The value sent must include all the values to send to the minting contracts and the fees + reward amount.
    /// This can be determined by calling `fee`, and getting the requiredToSend parameter.
    /// @param _targets Addresses of contracts to call
    /// @param _calldatas Data to pass to the mint functions for each target
    /// @param _values Value to send to each target - must match the value required by the target's mint function.
    /// @param _tokensMinted Total number of tokens minted across all targets, used to calculate fees
    /// @param _finder Optional - address of finder that will receive a portion of the fees
    function mintBatch(
        address[] calldata _targets,
        bytes[] calldata _calldatas,
        uint256[] calldata _values,
        uint256 _tokensMinted,
        address _finder
    ) external payable {
        uint256 totalValue = _uncheckedSum(_values);

        // calculate fees
        (uint256 feeAmount, uint256 finderReward, uint256 totalWithFees) = fee(totalValue, _tokensMinted, _finder);

        emit MintedBatch(_targets, _values, _tokensMinted, _finder, msg.sender, totalWithFees, feeAmount, finderReward);

        // allocate the fees to the mint fee receiver and finder, which can be withdrawn against later.  Validates
        // that proper value has been sent.
        _allocateFeesAndRewards(feeAmount, finderReward, totalWithFees, _finder);

        _mintAll(msg.sender, totalValue, _targets, _calldatas, _values);
    }

    /// @notice Executes mint calls on a series of target ERC721 or ERC1155 contracts, then transfers the minted tokens to the calling account.
    /// Does not add a mint feee
    /// Assumes that the mint function for each target follows the ERC721 or ERC1155 standard for minting - which is that
    /// the a safe transfer is used to transfer tokens - and the corresponding safeTransfer callbacks on the receiving account are called AFTER minting the tokens.
    /// The value sent must equal the total values to send to the minting contracts.
    /// @param _targets Addresses of contracts to call
    /// @param _calldatas Data to pass to the mint functions for each target
    /// @param _values Value to send to each target - must match the value required by the target's mint function.
    function mintBatchWithoutFees(address[] calldata _targets, bytes[] calldata _calldatas, uint256[] calldata _values) external payable {
        uint256 totalValue = _uncheckedSum(_values);

        // make sure that enough value was sent to cover the fees + values needed to be sent to the contracts
        // Cannot realistically overflow
        if (totalValue != msg.value) {
            revert INSUFFICIENT_VALUE(totalValue, msg.value);
        }

        emit MintedBatch(_targets, _values, 0, address(0), msg.sender, 0, 0, 0);

        _mintAll(msg.sender, totalValue, _targets, _calldatas, _values);
    }

    /// Execute a mint call on a series a target ERC721 or ERC1155 contracts, then transfers the minted tokens to the calling account.
    /// Adds a mint fee to the msg.value sent to the contract.
    /// Assumes that the mint function for each target follows the ERC721 or ERC1155 standard for minting - which is that
    /// the a safe transfer is used to transfer tokens - and the corresponding safeTransfer callbacks on the receiving account are called AFTER minting the tokens.
    /// The value sent must include the value to send to the minting contract and the universal minter fee + finder reward amount.
    /// This can be determined by calling `fee`, and getting the requiredToSend parameter.
    /// @param _target Addresses of contract to call
    /// @param _calldata Data to pass to the mint function for the target
    /// @param _value Value to send to the target - must match the value required by the target's mint function.
    /// @param _tokensMinted Total number of tokens minted across all targets, used to calculate fees
    /// @param _finder Optional - address of finder that will receive a portion of the fees
    function mint(address _target, bytes calldata _calldata, uint256 _value, uint256 _tokensMinted, address _finder) external payable {
        IMinterAgent agent = _getOrCloneAgent(msg.sender);

        (uint256 feeAmount, uint256 finderReward, uint256 totalWithFees) = fee(_value, _tokensMinted, _finder);

        emit Minted(_target, _value, _tokensMinted, _finder, msg.sender, totalWithFees, feeAmount, finderReward);

        // allocate the fees to the mint fee receiver and rewards to the finder, which can be withdrawn against later
        _allocateFeesAndRewards(feeAmount, finderReward, totalWithFees, _finder);

        // mint the fokens for each target contract.  These will be transferred to the msg.caller.
        _mint(agent, _target, _calldata, _value);
    }

    /// Withdraws any fees that have been allocated to the caller's address to a specified address.
    /// @param to The address to withdraw to
    function withdraw(address to) external {
        uint256 feeAllocation = rewardAllocations[msg.sender];

        uint256 withdrawnSoFar = withdrawn[msg.sender];

        if (feeAllocation <= withdrawnSoFar) {
            revert NOTHING_TO_WITHDRAW();
        }

        uint256 toWithdraw = feeAllocation - withdrawnSoFar;

        withdrawn[msg.sender] = withdrawnSoFar + toWithdraw;

        _safeSend(toWithdraw, to);
    }

    /// Calculates the fees that will be collected for a given mint, based on the value and tokens minted.
    /// @param _mintValue Total value of the mint
    /// @param _tokensMinted Quantity of tokens minted
    /// @param _finderAddress Address of the finder, if any.  If the finder is the fee recipient, then the finder fee is 0.
    /// @return feeAmount The fee that will be allocated to the fee recipient
    /// @return finderReward The reward that will be allcoated to the finder
    /// @return requiredToSend The total value that must be sent to the contract, including fees
    function fee(
        uint256 _mintValue,
        uint256 _tokensMinted,
        address _finderAddress
    ) public view returns (uint256 feeAmount, uint256 finderReward, uint256 requiredToSend) {
        if (_finderAddress == address(0) || _finderAddress == feeRecipient) {
            unchecked {
                feeAmount = FEE_PER_TOKEN_WHEN_NO_FINDER * _tokensMinted;
                requiredToSend = feeAmount + _mintValue;
            }
        } else {
            unchecked {
                feeAmount = FEE_PER_TOKEN * _tokensMinted;
                finderReward = FINDER_REWARD_PER_TOKEN * _tokensMinted;
                requiredToSend = feeAmount + finderReward + _mintValue;
            }
        }
    }

    /// Has a minter agent execute a transaction on behalf of the calling acccount.  The minter
    /// agent's address will be the same for the calling account as the address that was
    /// used to mint the tokens.  Can be used to recover tokens that may get accidentally locked in
    /// the minter agent's contract address.
    /// @param _target Address of contract to call
    /// @param _calldata Calldata for arguments to call.
    function forwardCallFromAgent(address _target, bytes calldata _calldata, uint256 _additionalValue) external payable {
        IMinterAgent agent = _getOrCloneAgent(msg.sender);

        (bool success, bytes memory result) = agent.forwardCall{value: msg.value}(_target, _calldata, msg.value + _additionalValue);

        if (!success) {
            _handleForwardCallFail(result);
        }
    }

    /// @dev Unwraps a forward call failure to return the original error.  Useful
    /// for debugging failed minting calls.
    function _handleForwardCallFail(bytes memory result) private pure {
        // source: https://yos.io/2022/07/16/bubbling-up-errors-in-solidity/#:~:text=An%20inline%20assembly%20block%20is,object%20is%20returned%20in%20result%20.
        // if no error message, revert with generic error
        if (result.length == 0) {
            revert FORWARD_CALL_FAILED();
        }
        assembly {
            // We use Yul's revert() to bubble up errors from the target contract.
            revert(add(32, result), mload(result))
        }
    }

    /// Gets the deterministic address of the MinterAgent clone that gets created for a given recipient.
    /// @param recipient The account that the agent is cloned on behalf of.
    function agentAddress(address recipient) public view returns (address) {
        return Clones.predictDeterministicAddress(agentImpl, _agentSalt(recipient));
    }

    /// Creates a clone of an agent contract, which mints tokens on behalf of the msg.sender.  If a clone has already been created
    /// for that account, returns it.  Clone address is deterministic based on the recipient's address.
    /// Sends all tokens received as a result of minting to the recipient.
    /// @param callingAccount the account to receive tokens minted by this cloned agent.
    /// @return agent the created agent
    function _getOrCloneAgent(address callingAccount) private returns (IMinterAgent agent) {
        address targetAddress = agentAddress(callingAccount);
        if (targetAddress.code.length > 0) {
            return IMinterAgent(targetAddress);
        }

        address cloneAddress = Clones.cloneDeterministic(agentImpl, _agentSalt(callingAccount));
        agent = IMinterAgent(cloneAddress);
        agent.initialize(address(this), callingAccount);
    }

    /// @dev Unique salt generated from an address for a callingAccount that a MinterAgent is create for.
    function _agentSalt(address callingAccount) private pure returns (bytes32) {
        return bytes32(uint256(uint160(callingAccount)) << 96);
    }

    function _mint(IMinterAgent _agent, address _target, bytes calldata _calldata, uint256 _value) private {
        (bool success, bytes memory result) = _agent.forwardCall{value: _value}(_target, _calldata, _value);

        if (!success) {
            _handleForwardCallFail(result);
        }
    }

    /// @dev Iterates through minting calls and calls them each via a IMinterAgent.
    function _mintAll(
        address callingAccount,
        uint256 totalValueToSend,
        address[] calldata _targets,
        bytes[] calldata _calldatas,
        uint256[] calldata _values
    ) private {
        IMinterAgent _agent = _getOrCloneAgent(callingAccount);

        (bool success, bytes memory result) = _agent.forwardCallBatch{value: totalValueToSend}(_targets, _calldatas, _values);

        if (!success) {
            _handleForwardCallFail(result);
        }
    }

    /// Allocates fees and rewards which can be withdrawn against later.
    /// Validates that the proper value has been sent by the calling account.
    function _allocateFeesAndRewards(uint256 feeAmount, uint256 finderReward, uint256 requiredToBeSent, address finder) private {
        // make sure that the correct amount was sent
        if (requiredToBeSent != msg.value) {
            revert INSUFFICIENT_VALUE(requiredToBeSent, msg.value);
        }

        rewardAllocations[feeRecipient] += feeAmount;
        if (finderReward > 0) {
            rewardAllocations[finder] += finderReward;
        }
    }

    function _safeSend(uint256 amount, address to) private {
        (bool success, ) = to.call{value: amount}("");

        if (!success) revert FAILED_TO_SEND();
    }

    function _uncheckedSum(uint256[] calldata _values) private pure returns (uint256 totalValue) {
        unchecked {
            for (uint256 i = 0; i < _values.length; i++) {
                totalValue += _values[i];
            }
        }
    }
}

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


/// @title Universal Minter
/// @notice Mints ERC721 or ERC1155 tokens on behalf of an account on any standard ER721 or ERC1155 contract. Optionally collects fees and rewards for a finder.
interface IUniversalMinter {
    error MINT_EXECUTION_FAILED();
    error NOTHING_TO_WITHDRAW();
    error FORWARD_CALL_FAILED();
    error FAILED_TO_SEND();
    error INSUFFICIENT_VALUE(uint256 expectedValue, uint256 actualValue);

    event MintedBatch(
        address[] indexed targets,
        uint256[] values,
        uint256 tokensMinted,
        address finder,
        address indexed minter,
        uint256 indexed totalWithFees,
        uint256 fee,
        uint256 finderFee
    );

    event Minted(
        address indexed target,
        uint256 value,
        uint256 tokensMinted,
        address finder,
        address indexed minter,
        uint256 indexed totalWithFees,
        uint256 fee,
        uint256 finderFee
    );

    enum MintableTypes {
        NONE,
        ERC721,
        ERC1155,
        ERC1155_BATCH
    }

    /// Executes mint calls on a series of target ERC721 or ERC1155 contracts, then transfers the minted tokens to the calling account.
    /// Adds a mint fee to the msg.value sent to the contract.
    /// Assumes that the mint function for each target follows the ERC721 or ERC1155 standard for minting - which is that
    /// the a safe transfer is used to transfer tokens - and the corresponding safeTransfer callbacks on the receiving account are called AFTER minting the tokens.
    /// The value sent must include all the values to send to the minting contracts and the fees + reward amount.
    /// This can be determined by calling `fee`, and getting the requiredToSend parameter.
    /// @param _targets Addresses of contracts to call
    /// @param _calldatas Data to pass to the mint functions for each target
    /// @param _values Value to send to each target - must match the value required by the target's mint function.
    /// @param _tokensMinted Total number of tokens minted across all targets, used to calculate fees
    /// @param _finder Optional - address of finder that will receive a portion of the fees
    function mintBatch(
        address[] calldata _targets,
        bytes[] calldata _calldatas,
        uint256[] calldata _values,
        uint256 _tokensMinted,
        address _finder
    ) external payable;

    /// @notice Executes mint calls on a series of target ERC721 or ERC1155 contracts, then transfers the minted tokens to the calling account.
    /// Does not add a mint feee
    /// Assumes that the mint function for each target follows the ERC721 or ERC1155 standard for minting - which is that
    /// the a safe transfer is used to transfer tokens - and the corresponding safeTransfer callbacks on the receiving account are called AFTER minting the tokens.
    /// The value sent must equal the total values to send to the minting contracts.
    /// @param _targets Addresses of contracts to call
    /// @param _calldatas Data to pass to the mint functions for each target
    /// @param _values Value to send to each target - must match the value required by the target's mint function.
    function mintBatchWithoutFees(address[] calldata _targets, bytes[] calldata _calldatas, uint256[] calldata _values) external payable;

    /// Execute a mint call on a series a target ERC721 or ERC1155 contracts, then transfers the minted tokens to the calling account.
    /// Adds a mint fee to the msg.value sent to the contract.
    /// Assumes that the mint function for each target follows the ERC721 or ERC1155 standard for minting - which is that
    /// the a safe transfer is used to transfer tokens - and the corresponding safeTransfer callbacks on the receiving account are called AFTER minting the tokens.
    /// The value sent must include the value to send to the minting contract and the universal minter fee + finder reward amount.
    /// This can be determined by calling `fee`, and getting the requiredToSend parameter.
    /// @param _target Addresses of contract to call
    /// @param _calldata Data to pass to the mint function for the target
    /// @param _value Value to send to the target - must match the value required by the target's mint function.
    /// @param _tokensMinted Total number of tokens minted across all targets, used to calculate fees
    /// @param _finder Optional - address of finder that will receive a portion of the fees
    function mint(address _target, bytes calldata _calldata, uint256 _value, uint256 _tokensMinted, address _finder) external payable;

    /// Has a minter agent execute a transaction on behalf of the calling acccount.  The minter
    /// agent's address will be the same for the calling account as the address that was
    /// used to mint the tokens.  Can be used to recover tokens that may get accidentally locked in
    /// the minter agent's contract address.
    /// @param _target Address of contract to call
    /// @param _calldata Calldata for arguments to call.
    function forwardCallFromAgent(address _target, bytes calldata _calldata, uint256 _additionalValue) external payable;

    /// Withdraws any fees or rewards that have been allocated to the caller's address.  Fees can be withdrawn to any other specified address.
    /// @param to The address to withdraw to
    function withdraw(address to) external;

    /// Calculates the fees that will be collected for a given mint, based on the value and tokens minted.
    /// @param _mintValue Total value of the mint that is to be sent to external minting contracts
    /// @param _tokensMinted Quantity of tokens minted
    /// @param _finderAddress Address of the finder, if any.  If the finder is the fee recipient, then the finder fee is 0.
    /// @return fee The fee that will be sent to the fee recipient
    /// @return finderReward The fee that will be sent to the finder
    /// @return requiredToSend The total value that must be sent to the contract, including fees
    function fee(
        uint256 _mintValue,
        uint256 _tokensMinted,
        address _finderAddress
    ) external view returns (uint256 fee, uint256 finderReward, uint256 requiredToSend);

    /// Gets the deterministic address of the MinterAgent clone that gets created for a given recipient.
    /// @param recipient The account that the agent is cloned on behalf of.
    function agentAddress(address recipient) external view returns (address);
}

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

interface IMinterAgent {
    error ALREADY_INITIALIZED();
    error ONLY_OWNER();
    error ARRAY_LENGTH_MISMATCH();

    function initialize(address _owner, address _receiver) external;

    function forwardCall(address _target, bytes calldata _cd, uint256 _value) external payable returns (bool success, bytes memory data);

    function forwardCallBatch(
        address[] calldata _targets,
        bytes[] calldata _calldatas,
        uint256[] calldata _values
    ) external payable returns (bool success, bytes memory data);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/Clones.sol)

pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 *
 * _Available since v3.4._
 */
library Clones {
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create(0, 0x09, 0x37)
        }
        require(instance != address(0), "ERC1167: create failed");
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create2(0, 0x09, 0x37, salt)
        }
        require(instance != address(0), "ERC1167: create2 failed");
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(add(ptr, 0x38), deployer)
            mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
            mstore(add(ptr, 0x14), implementation)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
            mstore(add(ptr, 0x58), salt)
            mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
            predicted := keccak256(add(ptr, 0x43), 0x55)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt
    ) internal view returns (address predicted) {
        return predictDeterministicAddress(implementation, salt, address(this));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

{
  "remappings": [
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "erc721a-upgradeable/=lib/ERC721A-Upgradeable/contracts/",
    "forge-std/=lib/forge-std/src/",
    "ERC721A-Upgradeable/=lib/ERC721A-Upgradeable/contracts/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/openzeppelin-contracts/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": true,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_minterAgentImpl","type":"address"},{"internalType":"address","name":"_feeRecipient","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"FAILED_TO_SEND","type":"error"},{"inputs":[],"name":"FORWARD_CALL_FAILED","type":"error"},{"inputs":[{"internalType":"uint256","name":"expectedValue","type":"uint256"},{"internalType":"uint256","name":"actualValue","type":"uint256"}],"name":"INSUFFICIENT_VALUE","type":"error"},{"inputs":[],"name":"MINT_EXECUTION_FAILED","type":"error"},{"inputs":[],"name":"NOTHING_TO_WITHDRAW","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokensMinted","type":"uint256"},{"indexed":false,"internalType":"address","name":"finder","type":"address"},{"indexed":true,"internalType":"address","name":"minter","type":"address"},{"indexed":true,"internalType":"uint256","name":"totalWithFees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"finderFee","type":"uint256"}],"name":"Minted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address[]","name":"targets","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"tokensMinted","type":"uint256"},{"indexed":false,"internalType":"address","name":"finder","type":"address"},{"indexed":true,"internalType":"address","name":"minter","type":"address"},{"indexed":true,"internalType":"uint256","name":"totalWithFees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"finderFee","type":"uint256"}],"name":"MintedBatch","type":"event"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"agentAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"agentImpl","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintValue","type":"uint256"},{"internalType":"uint256","name":"_tokensMinted","type":"uint256"},{"internalType":"address","name":"_finderAddress","type":"address"}],"name":"fee","outputs":[{"internalType":"uint256","name":"feeAmount","type":"uint256"},{"internalType":"uint256","name":"finderReward","type":"uint256"},{"internalType":"uint256","name":"requiredToSend","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_target","type":"address"},{"internalType":"bytes","name":"_calldata","type":"bytes"},{"internalType":"uint256","name":"_additionalValue","type":"uint256"}],"name":"forwardCallFromAgent","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_target","type":"address"},{"internalType":"bytes","name":"_calldata","type":"bytes"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"uint256","name":"_tokensMinted","type":"uint256"},{"internalType":"address","name":"_finder","type":"address"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_targets","type":"address[]"},{"internalType":"bytes[]","name":"_calldatas","type":"bytes[]"},{"internalType":"uint256[]","name":"_values","type":"uint256[]"},{"internalType":"uint256","name":"_tokensMinted","type":"uint256"},{"internalType":"address","name":"_finder","type":"address"}],"name":"mintBatch","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_targets","type":"address[]"},{"internalType":"bytes[]","name":"_calldatas","type":"bytes[]"},{"internalType":"uint256[]","name":"_values","type":"uint256[]"}],"name":"mintBatchWithoutFees","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000659905d5ebbdb4f38a53a87e0db5d2e2c69e4e4f00000000000000000000000026c8ca628f088d11f37c66c9f87ac0fa87edab05

-----Decoded View---------------
Arg [0] : _minterAgentImpl (address): 0x659905D5ebBDb4F38A53A87E0dB5d2E2C69e4e4F
Arg [1] : _feeRecipient (address): 0x26C8Ca628F088D11F37C66C9F87ac0Fa87edaB05

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000659905d5ebbdb4f38a53a87e0db5d2e2c69e4e4f
Arg [1] : 00000000000000000000000026c8ca628f088d11f37c66c9f87ac0fa87edab05