Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

//SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import {EIP712} from "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IAvatar, Part} from "../interfaces/IAvatar.sol";
import {IDava} from "../interfaces/IDava.sol";
import {IRandomBox} from "./IRandomBox.sol";

interface IPartCollection {
    function unsafeMintBatch(
        address account,
        uint256[] calldata partIds,
        uint256[] calldata amounts
    ) external;
}

contract ExclusiveSale is EIP712, Ownable {
    bytes32 public constant TYPE_HASH =
        keccak256("Ticket(uint256 price,uint16 amount,address beneficiary)");

    uint16 public constant PARTS_PER_AVATAR = 3;
    uint32 public constant CLOSING_TIME = 1638316800;

    uint16 internal _nextAvatarId = 499;

    // Parts
    IDava public dava;
    IPartCollection public davaOfficial;
    IRandomBox private _randomBox;

    mapping(address => bool) public participated;

    struct Ticket {
        uint256 price;
        uint16 amount;
        address beneficiary;
    }

    struct MintReq {
        uint8 vSig;
        bytes32 rSig;
        bytes32 sSig;
        Ticket ticket;
    }

    constructor(
        IDava dava_,
        IPartCollection davaOfficial_,
        IRandomBox randomBox_
    ) EIP712("ExclusiveSale", "V1") {
        dava = dava_;
        davaOfficial = davaOfficial_;
        _randomBox = randomBox_;
    }

    modifier onlyBeforeClosing() {
        require(block.timestamp < CLOSING_TIME, "ExclusiveSale: sale closed");
        _;
    }

    function mint(MintReq calldata mintReq) external payable onlyBeforeClosing {
        require(
            !participated[msg.sender],
            "ExclusiveSale: already participated"
        );
        require(
            msg.sender == mintReq.ticket.beneficiary,
            "ExclusiveSale: not authorized"
        );
        require(
            msg.value == mintReq.ticket.price,
            "ExclusiveSale: unmatched price"
        );
        _verifySig(mintReq);

        participated[msg.sender] = true;

        for (uint16 i = 0; i < mintReq.ticket.amount; i++) {
            _mintAvatarWithParts(_nextAvatarId - i);
        }
        _nextAvatarId -= mintReq.ticket.amount;
    }

    function withdrawFunds(address payable receiver) external onlyOwner {
        uint256 amount = address(this).balance;
        receiver.transfer(amount);
    }

    function _mintAvatarWithParts(uint16 avatarId) internal {
        address avatar = dava.mint(address(this), uint256(avatarId));

        uint256[] memory partIds = _randomBox.getPartIds(avatarId);
        uint256[] memory amounts = new uint256[](3);
        amounts[0] = 1;
        amounts[1] = 1;
        amounts[2] = 1;

        davaOfficial.unsafeMintBatch(avatar, partIds, amounts);
        Part[] memory parts = new Part[](PARTS_PER_AVATAR);
        for (uint16 i = 0; i < PARTS_PER_AVATAR; i += 1) {
            parts[i] = Part(address(davaOfficial), uint96(partIds[i]));
        }
        IAvatar(avatar).dress(parts, new bytes32[](0));
        dava.transferFrom(address(this), msg.sender, avatarId);
    }

    function _verifySig(MintReq calldata mintReq) internal view {
        bytes32 digest = _hashTypedDataV4(
            keccak256(
                abi.encode(
                    TYPE_HASH,
                    mintReq.ticket.price,
                    mintReq.ticket.amount,
                    msg.sender
                )
            )
        );

        address signer = ecrecover(
            digest,
            mintReq.vSig,
            mintReq.rSig,
            mintReq.sSig
        );
        require(signer == owner(), "ExclusiveSale: invalid signature");
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ECDSA.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

//SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.0;
pragma abicoder v2;

struct Part {
    address collection;
    uint96 id;
}

interface IAvatar {
    function dress(Part[] calldata partsOn, bytes32[] calldata partsOff)
        external;

    function version() external view returns (string memory);

    function dava() external view returns (address);

    function davaId() external view returns (uint256);

    function part(bytes32 categoryId) external view returns (Part memory);

    function allParts() external view returns (Part[] memory parts);

    function getPFP() external view returns (string memory);

    function getMetadata() external view returns (string memory);

    function externalImgUri() external view returns (string memory);
}

//SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.0;
pragma abicoder v2;

import {IERC721} from "@openzeppelin/contracts/interfaces/IERC721.sol";
import {IHost} from "../interfaces/IHost.sol";
import {Part} from "../interfaces/IAvatar.sol";

interface IDava is IERC721, IHost {
    function mint(address to, uint256 id) external returns (address);

    function registerCollection(address collection) external;

    function registerCategory(bytes32 categoryId) external;

    function registerFrameCollection(address collection) external;

    function deregisterCollection(address collection) external;

    function deregisterCategory(bytes32 categoryId) external;

    function zap(
        uint256 tokenId,
        Part[] calldata partsOn,
        bytes32[] calldata partsOff
    ) external;

    function frameCollection() external view returns (address);

    function isRegisteredCollection(address collection)
        external
        view
        returns (bool);

    function isSupportedCategory(bytes32 categoryId)
        external
        view
        returns (bool);

    function isDavaPart(address collection, bytes32 categoryId)
        external
        view
        returns (bool);

    function getAvatar(uint256 id) external view returns (address);

    function getAllSupportedCategories()
        external
        view
        returns (bytes32[] memory);

    function getRegisteredCollections()
        external
        view
        returns (address[] memory);

    function getPFP(uint256 id) external view returns (string memory);
}

//SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

interface IRandomBox {
    function getPartIds(uint256 index)
        external
        view
        returns (uint256[] memory partIds);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 27)
        }
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @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;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../token/ERC721/IERC721.sol";

//SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.0;
pragma abicoder v2;

interface IHost {
    function baseURI() external view returns (string memory);
}

// SPDX-License-Identifier: MIT

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`, 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 be 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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @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 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);

    /**
     * @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;
}

// SPDX-License-Identifier: MIT

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IDava","name":"dava_","type":"address"},{"internalType":"contract IPartCollection","name":"davaOfficial_","type":"address"},{"internalType":"contract IRandomBox","name":"randomBox_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"CLOSING_TIME","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PARTS_PER_AVATAR","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TYPE_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dava","outputs":[{"internalType":"contract IDava","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"davaOfficial","outputs":[{"internalType":"contract IPartCollection","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint8","name":"vSig","type":"uint8"},{"internalType":"bytes32","name":"rSig","type":"bytes32"},{"internalType":"bytes32","name":"sSig","type":"bytes32"},{"components":[{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint16","name":"amount","type":"uint16"},{"internalType":"address","name":"beneficiary","type":"address"}],"internalType":"struct ExclusiveSale.Ticket","name":"ticket","type":"tuple"}],"internalType":"struct ExclusiveSale.MintReq","name":"mintReq","type":"tuple"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"participated","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"receiver","type":"address"}],"name":"withdrawFunds","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x60806040526004361061009c5760003560e01c8063715018a611610064578063715018a61461018f5780638da5cb5b146101a45780639c40e799146101c2578063aa983890146101ea578063b3bd870a146101fd578063f2fde38b1461023d57600080fd5b80631fa4f86e146100a157806353865562146100de5780635ed25c061461010b57806364d4c8191461012b57806368742da61461016d575b600080fd5b3480156100ad57600080fd5b506001546100c1906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b3480156100ea57600080fd5b506100f66361a6bb0081565b60405163ffffffff90911681526020016100d5565b34801561011757600080fd5b506002546100c1906001600160a01b031681565b34801561013757600080fd5b5061015f7ffe01c2201ffc0613fb848e199b7e1d1c2fe0c79ddabb3891adb8250def33bb4781565b6040519081526020016100d5565b34801561017957600080fd5b5061018d610188366004610ce6565b61025d565b005b34801561019b57600080fd5b5061018d6102cd565b3480156101b057600080fd5b506000546001600160a01b03166100c1565b3480156101ce57600080fd5b506101d7600381565b60405161ffff90911681526020016100d5565b61018d6101f8366004610de5565b610303565b34801561020957600080fd5b5061022d610218366004610ce6565b60046020526000908152604090205460ff1681565b60405190151581526020016100d5565b34801561024957600080fd5b5061018d610258366004610ce6565b610547565b6000546001600160a01b031633146102905760405162461bcd60e51b815260040161028790610f32565b60405180910390fd5b60405147906001600160a01b0383169082156108fc029083906000818181858888f193505050501580156102c8573d6000803e3d6000fd5b505050565b6000546001600160a01b031633146102f75760405162461bcd60e51b815260040161028790610f32565b61030160006105e2565b565b6361a6bb0042106103565760405162461bcd60e51b815260206004820152601a60248201527f4578636c757369766553616c653a2073616c6520636c6f7365640000000000006044820152606401610287565b3360009081526004602052604090205460ff16156103c25760405162461bcd60e51b815260206004820152602360248201527f4578636c757369766553616c653a20616c7265616479207061727469636970616044820152621d195960ea1b6064820152608401610287565b6103d260c0820160a08301610ce6565b6001600160a01b0316336001600160a01b0316146104325760405162461bcd60e51b815260206004820152601d60248201527f4578636c757369766553616c653a206e6f7420617574686f72697a65640000006044820152606401610287565b346060820135146104855760405162461bcd60e51b815260206004820152601e60248201527f4578636c757369766553616c653a20756e6d61746368656420707269636500006044820152606401610287565b61048e81610632565b336000908152600460205260408120805460ff191660011790555b6104b960a0830160808401610dfc565b61ffff168161ffff1610156104fc576000546104ea906104e5908390600160a01b900461ffff16610f8d565b610792565b806104f481610fb0565b9150506104a9565b5061050d60a0820160808301610dfc565b6000805460149061052a908490600160a01b900461ffff16610f8d565b92506101000a81548161ffff021916908361ffff16021790555050565b6000546001600160a01b031633146105715760405162461bcd60e51b815260040161028790610f32565b6001600160a01b0381166105d65760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610287565b6105df816105e2565b50565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b60006106ac7ffe01c2201ffc0613fb848e199b7e1d1c2fe0c79ddabb3891adb8250def33bb47606084013561066d60a0860160808701610dfc565b60408051602081019490945283019190915261ffff16606082015233608082015260a00160405160208183030381529060405280519060200120610b9f565b905060006001826106c06020860186610e1e565b604080516000815260208181018084529490945260ff9092168282015291860135606082015290850135608082015260a0016020604051602081039080840390855afa158015610714573d6000803e3d6000fd5b5050506020604051035190506107326000546001600160a01b031690565b6001600160a01b0316816001600160a01b0316146102c85760405162461bcd60e51b815260206004820181905260248201527f4578636c757369766553616c653a20696e76616c6964207369676e61747572656044820152606401610287565b6001546040516340c10f1960e01b815230600482015261ffff831660248201526000916001600160a01b0316906340c10f1990604401602060405180830381600087803b1580156107e257600080fd5b505af11580156107f6573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061081a9190610d09565b60035460405163c33348bd60e01b815261ffff851660048201529192506000916001600160a01b039091169063c33348bd9060240160006040518083038186803b15801561086757600080fd5b505afa15801561087b573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526108a39190810190610d25565b6040805160038082526080820190925291925060009190602082016060803683370190505090506001816000815181106108ed57634e487b7160e01b600052603260045260246000fd5b60200260200101818152505060018160018151811061091c57634e487b7160e01b600052603260045260246000fd5b60200260200101818152505060018160028151811061094b57634e487b7160e01b600052603260045260246000fd5b6020908102919091010152600254604051637bd2799760e01b81526001600160a01b0390911690637bd279979061098a90869086908690600401610e79565b600060405180830381600087803b1580156109a457600080fd5b505af11580156109b8573d6000803e3d6000fd5b5060009250600391506109c89050565b604051908082528060200260200182016040528015610a0d57816020015b60408051808201909152600080825260208201528152602001906001900390816109e65790505b50905060005b600361ffff82161015610abd57604080518082019091526002546001600160a01b0316815284516020820190869061ffff8516908110610a6357634e487b7160e01b600052603260045260246000fd5b60200260200101516bffffffffffffffffffffffff16815250828261ffff1681518110610aa057634e487b7160e01b600052603260045260246000fd5b6020908102919091010152610ab6600182610f67565b9050610a13565b506040805160008152602081019182905263867cee7160e01b9091526001600160a01b0385169063867cee7190610af990849060248101610eb9565b600060405180830381600087803b158015610b1357600080fd5b505af1158015610b27573d6000803e3d6000fd5b50506001546040516323b872dd60e01b815230600482015233602482015261ffff891660448201526001600160a01b0390911692506323b872dd9150606401600060405180830381600087803b158015610b8057600080fd5b505af1158015610b94573d6000803e3d6000fd5b505050505050505050565b6000610bed610bac610bf3565b8360405161190160f01b6020820152602281018390526042810182905260009060620160405160208183030381529060405280519060200120905092915050565b92915050565b60007f0000000000000000000000000000000000000000000000000000000000000001461415610c4257507f7d814a33fc7111bb8722c6c3f71ff708c04fd6a0380b6116e5ee07facd8153ad90565b50604080517f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f6020808301919091527faaba7b8464dbe91dc9e3791a92acd5759b681328d608a5e4778c46644ec9c934828401527f4c23426613a5dc69e08fbd2787e6210aa679d4522e95a89d4dd88c4fd13a228360608301524660808301523060a0808401919091528351808403909101815260c0909201909252805191012090565b600060208284031215610cf7578081fd5b8135610d0281610ffe565b9392505050565b600060208284031215610d1a578081fd5b8151610d0281610ffe565b60006020808385031215610d37578182fd5b825167ffffffffffffffff80821115610d4e578384fd5b818501915085601f830112610d61578384fd5b815181811115610d7357610d73610fe8565b8060051b604051601f19603f83011681018181108582111715610d9857610d98610fe8565b604052828152858101935084860182860187018a1015610db6578788fd5b8795505b83861015610dd8578051855260019590950194938601938601610dba565b5098975050505050505050565b600060c08284031215610df6578081fd5b50919050565b600060208284031215610e0d578081fd5b813561ffff81168114610d02578182fd5b600060208284031215610e2f578081fd5b813560ff81168114610d02578182fd5b6000815180845260208085019450808401835b83811015610e6e57815187529582019590820190600101610e52565b509495945050505050565b6001600160a01b0384168152606060208201819052600090610e9d90830185610e3f565b8281036040840152610eaf8185610e3f565b9695505050505050565b60408082528351828201819052600091906020906060850190828801855b82811015610f1357815180516001600160a01b031685528501516bffffffffffffffffffffffff16858501529285019290840190600101610ed7565b50505084810382860152610f278187610e3f565b979650505050505050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b600061ffff808316818516808303821115610f8457610f84610fd2565b01949350505050565b600061ffff83811690831681811015610fa857610fa8610fd2565b039392505050565b600061ffff80831681811415610fc857610fc8610fd2565b6001019392505050565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052604160045260246000fd5b6001600160a01b03811681146105df57600080fdfea2646970667358221220befb5006c2dde10adf3ea3c0bef068b03499a403d298aad61b5db17a992ce65564736f6c63430008040033

000000000000000000000000c0cb97a0e22e9c14fb0b39da6cf6ccdab8078fa9000000000000000000000000ba3bdc36e751e2ffa2c216416666b909af7fb49b000000000000000000000000fa11f52848f220edff379d9367c0f2ca11adc61c

-----Decoded View---------------
Arg [0] : dava_ (address): 0xC0CB97a0e22E9c14fB0B39da6cF6ccdab8078fa9
Arg [1] : davaOfficial_ (address): 0xBa3BDc36e751E2Ffa2C216416666b909Af7fB49B
Arg [2] : randomBox_ (address): 0xFa11f52848F220EdFf379d9367c0F2cA11ADc61c

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000c0cb97a0e22e9c14fb0b39da6cf6ccdab8078fa9
Arg [1] : 000000000000000000000000ba3bdc36e751e2ffa2c216416666b909af7fb49b
Arg [2] : 000000000000000000000000fa11f52848f220edff379d9367c0f2ca11adc61c