Feat/nft collection

packages/avatar/contracts/common/BaseWithStorage/ERC2771/ERC2771HandlerUpgradeable.sol

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: MIT
-// solhint-disable-next-line compiler-version
 pragma solidity 0.8.15;
 
 /// @dev minimal ERC2771 handler to keep bytecode-size down

packages/avatar/contracts/mocks/MockERC20.sol

@@ -1,10 +1,151 @@
 // SPDX-License-Identifier: MIT
+// solhint-disable one-contract-per-file
 pragma solidity 0.8.15;
 
+import {Ownable} from "@openzeppelin/contracts-0.8.15/access/Ownable.sol";
 import {ERC20} from "@openzeppelin/contracts-0.8.15/token/ERC20/ERC20.sol";
 
-contract MockERC20 is ERC20 {
-    constructor(string memory _name, string memory _symbol, uint256 _initialSupply) ERC20(_name, _symbol) {
+contract MockERC20 is ERC20, Ownable {
+    struct MintArgs {
+        address target;
+        address wallet;
+        uint256 amount;
+        uint256 waveIndex;
+        uint256 signatureId;
+        bytes signature;
+    }
+
+    MintArgs public mintArgs;
+
+    constructor(uint256 _initialSupply) ERC20("MOCKTOKEN", "MOCK") {
         _mint(msg.sender, _initialSupply * 1e18);
     }
+
+    function donateTo(address recipient, uint256 amount) external onlyOwner {
+        _mint(recipient, amount);
+    }
+
+    /// @dev instead of using approve and call we use this method directly for testing.
+    function mint(
+        MintInterface target,
+        address _wallet,
+        uint256 _amount,
+        uint256 _signatureId,
+        bytes calldata _signature
+    ) external {
+        target.mint(_wallet, _amount, _signatureId, _signature);
+    }
+
+    function mintReenter(
+        address _target,
+        address _wallet,
+        uint256 _amount,
+        uint256 _signatureId,
+        bytes calldata _signature
+    ) external {
+        mintArgs = MintArgs({target : _target, wallet : _wallet, amount : _amount, waveIndex : 0, signatureId : _signatureId, signature : _signature});
+        MintInterface(_target).mint(_wallet, _amount, _signatureId, _signature);
+    }
+
+    /// @dev instead of using approve and call we use this method directly for testing.
+    function waveMint(
+        MintInterface target,
+        address _wallet,
+        uint256 _amount,
+        uint256 _waveIndex,
+        uint256 _signatureId,
+        bytes calldata _signature
+    ) external {
+        target.waveMint(_wallet, _amount, _waveIndex, _signatureId, _signature);
+    }
+
+    function waveMintReenter(
+        address _target,
+        address _wallet,
+        uint256 _amount,
+        uint256 _waveIndex,
+        uint256 _signatureId,
+        bytes calldata _signature
+    ) external {
+        mintArgs = MintArgs({target : _target, wallet : _wallet, amount : _amount, waveIndex : _waveIndex, signatureId : _signatureId, signature : _signature});
+        MintInterface(_target).waveMint(_wallet, _amount, _waveIndex, _signatureId, _signature);
+    }
+
+    /// @notice Approve `target` to spend `amount` and call it with data.
+    /// @param target The address to be given rights to transfer and destination of the call.
+    /// @param amount The number of tokens allowed.
+    /// @param data The bytes for the call.
+    /// @return The data of the call.
+    function approveAndCall(
+        address target,
+        uint256 amount,
+        bytes calldata data
+    ) external payable returns (bytes memory) {
+        require(doFirstParamEqualsAddress(data, _msgSender()), "FIRST_PARAM_NOT_SENDER");
+
+        _approve(_msgSender(), target, amount);
+
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, bytes memory returnData) = target.call{value : msg.value}(data);
+        if (success) {
+            return returnData;
+        }
+        if (returnData.length > 0) {
+            // The easiest way to bubble the revert reason is using memory via assembly
+            /// @solidity memory-safe-assembly
+            assembly {
+                let returndata_size := mload(returnData)
+                revert(add(32, returnData), returndata_size)
+            }
+        } else {
+            revert("Empty error from destination");
+        }
+    }
+
+    function doFirstParamEqualsAddress(bytes memory data, address _address)
+    internal
+    pure
+    returns (bool)
+    {
+        if (data.length < (36 + 32)) {
+            return false;
+        }
+        uint256 value;
+        assembly {
+            value := mload(add(data, 36))
+        }
+        return value == uint160(_address);
+    }
+
+
+    // reenter mint
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) public virtual override returns (bool) {
+        if (mintArgs.target != address(0)) {
+            MintInterface(mintArgs.target).mint(mintArgs.wallet, mintArgs.amount, mintArgs.signatureId, mintArgs.signature);
+            mintArgs.target = address(0);
+        }
+        return super.transferFrom(from, to, amount);
+    }
+
 }
+
+interface MintInterface {
+    function mint(
+        address _wallet,
+        uint256 _amount,
+        uint256 _signatureId,
+        bytes calldata _signature
+    ) external;
+
+    function waveMint(
+        address wallet,
+        uint256 amount,
+        uint256 waveIndex,
+        uint256 signatureId,
+        bytes calldata signature
+    ) external;
+}

packages/avatar/contracts/mocks/MockERC721Holder.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
+
+import {ERC721Holder} from "@openzeppelin/contracts-0.8.15/token/ERC721/utils/ERC721Holder.sol";
+
+contract MockERC721Holder is ERC721Holder {
+    bool public doReject;
+    bool public doRevert;
+    bool public doEmptyRevert;
+    string public revertMsg;
+
+    function setReject(bool enable) external {
+        doReject = enable;
+    }
+
+    function setRevert(bool enable, string calldata _revertMsg) external {
+        doRevert = enable;
+        revertMsg = _revertMsg;
+    }
+
+    function setEmptyRevert(bool enable) external {
+        doEmptyRevert = enable;
+    }
+
+    function onERC721Received(
+        address from,
+        address to,
+        uint256 tokenId,
+        bytes memory data
+    ) public virtual override returns (bytes4) {
+        if (doReject) {
+            return 0;
+        }
+        if (doEmptyRevert) {
+            // solhint-disable reason-string
+            revert();
+        }
+        if (doRevert) {
+            revert (revertMsg);
+        }
+        return super.onERC721Received(from, to, tokenId, data);
+    }
+}

packages/avatar/contracts/mocks/MockOperatorFilterRegistry.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
+
+import {Ownable} from "@openzeppelin/contracts-0.8.15/access/Ownable.sol";
+
+contract MockOperatorFilterRegistry {
+    /// @notice Emitted when a registration is updated.
+    event RegistrationUpdated(address indexed registrant, bool indexed registered);
+
+    /// @notice Emitted when the caller is not the address or EIP-173 "owner()"
+    error OnlyAddressOrOwner();
+    /// @notice Emitted when trying to register and the contract is not ownable (EIP-173 "owner()")
+    error NotOwnable();
+    /// @notice Emitted when the registrant is already registered.
+    error AlreadyRegistered();
+    /// @notice Emitted when an address is filtered.
+    error AddressFiltered(address filtered);
+    /// @notice Emitted when a codeHash is filtered.
+    error CodeHashFiltered(address account, bytes32 codeHash);
+
+    mapping(address => address) private _registrations;
+
+    bool public revertWithAddressFiltered;
+
+    bool public revertWithCodeHashFiltered;
+
+    bool public returnFalse;
+    /**
+     * @notice Restricts method caller to the address or EIP-173 "owner()"
+     */
+    modifier onlyAddressOrOwner(address addr) {
+        if (msg.sender != addr) {
+            try Ownable(addr).owner() returns (address owner) {
+                if (msg.sender != owner) {
+                    revert OnlyAddressOrOwner();
+                }
+            } catch (bytes memory reason) {
+                if (reason.length == 0) {
+                    revert NotOwnable();
+                } else {
+                    /// @solidity memory-safe-assembly
+                    assembly {
+                        revert(add(32, reason), mload(reason))
+                    }
+                }
+            }
+        }
+        _;
+    }
+
+    function doRevert(bool _revertWithAddressFiltered, bool _revertWithCodeHashFiltered) external {
+        revertWithAddressFiltered = _revertWithAddressFiltered;
+        revertWithCodeHashFiltered = _revertWithCodeHashFiltered;
+    }
+
+    function doFalse(bool _returnFalse) external {
+        returnFalse = _returnFalse;
+    }
+
+
+    /**
+     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
+     */
+    function register(address registrant) external onlyAddressOrOwner(registrant) {
+        _register(registrant);
+    }
+
+    /**
+     * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
+     * @param registrant the address of the contract to check for (usually address(this))
+     * @param subscription address to subscribe to
+     */
+    function registerAndSubscribe(address registrant, address subscription) external onlyAddressOrOwner(registrant) {
+        require(subscription!=address(0), "invalid address");
+        _register(registrant);
+    }
+
+    /**
+     * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
+     *         address without subscribing.
+     * @param registrant the address of the contract to check for (usually address(this))
+     * @param registrantToCopy address to copy entries from
+     */
+    function registerAndCopyEntries(address registrant, address registrantToCopy) external onlyAddressOrOwner(registrant) {
+        require(registrantToCopy!=address(0), "invalid address");
+        _register(registrant);
+    }
+
+    /**
+     * @notice Returns true if an address has registered
+     */
+    function isRegistered(address registrant) external view returns (bool) {
+        return _registrations[registrant] != address(0);
+    }
+
+    /**
+     * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
+     *         true if supplied registrant address is not registered.
+     *         Note that this method will *revert* if an operator or its codehash is filtered with an error that is
+     *         more informational than a false boolean, so smart contracts that query this method for informational
+     *         purposes will need to wrap in a try/catch or perform a low-level staticcall in order to handle the case
+     *         that an operator is filtered.
+     */
+    function isOperatorAllowed(address registrant, address operator) external view returns (bool) {
+        address registration = _registrations[registrant];
+        if (registration != address(0)) {
+            if (revertWithAddressFiltered) {
+                revert AddressFiltered(operator);
+            } else if (revertWithCodeHashFiltered) {
+                bytes32 codeHash = operator.codehash;
+                revert CodeHashFiltered(operator, codeHash);
+            } else if (returnFalse) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @dev Convenience method to compute the code hash of an arbitrary contract
+     */
+    function codeHashOf(address a) external view returns (bytes32) {
+        return a.codehash;
+    }
+
+    /**
+     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
+     */
+    function _register(address registrant) internal {
+        if (_registrations[registrant] != address(0)) {
+            revert AlreadyRegistered();
+        }
+        _registrations[registrant] = registrant;
+        emit RegistrationUpdated(registrant, true);
+    }
+
+}