Aspecta Builders Achievement

// contracts/Achievement.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.0/contracts/access/Ownable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.0/contracts/token/ERC721/ERC721.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.0/contracts/utils/cryptography/EIP712.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.0/contracts/utils/Counters.sol";
import { ECDSA } from "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.0/contracts/utils/cryptography/ECDSA.sol";
import {
    AccessDenied,
    EIP712Signature,
    InvalidEAS,
    InvalidLength,
    InvalidSignature,
    NotFound,
    NO_EXPIRATION_TIME
} from "./Common.sol";
import { TrustedForwarderManager } from "./TrustedForwarderManager.sol";


/**
 * @dev A struct representing the arguments of the claiming request.
 */
struct ClaimingRequestData {
    address recipient; // The recipient of the claiming.
    uint256 identifier; // The identifier of the NFT.
    bytes data; // Custom claiming data.
}
 
/**
 * @dev A struct representing the full arguments of the claiming request.
 */
struct ClaimingRequest {
    ClaimingRequestData data; // The arguments of the claiming request.
    EIP712Signature signature; // The EIP712 signature data.
    uint64 deadline; // The deadline of the signature/request.
}

/**
 * @title Achievement
 * @author Dingning-aspecta
 * @notice This contract aims to provide an ownable ERC721 that supports ERC2771
 * @dev Only ClaimingRequest that signed by the owner will be executed successfully
 */
contract Achievement is ERC721, EIP712, Ownable, TrustedForwarderManager {
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIds;

    error DeadlineExpired();
    error UsedSignature();

    // Emitted when a new NFT is claimed to help off-chain services to identify the NFT.
    event ClaimToken(uint256 indexed tokenId, uint256 indexed identifier);    

    // Replay protection signatures.
    mapping(bytes signature => bool used) private _signatures;

    // Mapping from user address to claimed tokens.
    mapping(address => uint256[]) private _userTokens;

    string public baseURI;

    // Claiming cost, in wei
    uint256 public claimCost;

    /**
     * @notice Contract constructor.
     *
     * @param initialBaseURI initial base URI of tokens.
     * 
     * @param trustedForwarder initial address of trusted forwarder.
     */
    constructor(string memory initialBaseURI, address trustedForwarder) ERC721("Aspecta Builders Achievement", "ASP") EIP712("Aspecta Builder Achievement Regularly", "0.1") Ownable() {
        baseURI = initialBaseURI;
        claimCost = 0.00 ether;
        _setTrustedForwarder(trustedForwarder);
    }

    /**
     * @dev Only the owner can set new trusted forwarder.
     *
     * @param _trustedForwarder The arguments of the new trusted forwarder.
     */
    function setTrustedForwarder(address _trustedForwarder) public onlyOwner {
        _setTrustedForwarder(_trustedForwarder);
    }

    /**
     * @dev Only owner can set new base URI.
     *
     * @param _newBaseURI The arguments of the new base URI.
     */
    function setBaseURI(string memory _newBaseURI) public onlyOwner {
        baseURI = _newBaseURI;
    }

    /**
     * @dev Returns the tokens claimed by the user.
     *
     * @param user The address of the user.
     */
    function userTokens(address user) public view onlyOwner returns (uint256[] memory) {
        return _userTokens[user];
    }

    /**
     * @dev Only owner can set new claim cost.
     *
     * @param _newClaimCost The arguments of the new claim cost.
     */
    function setClaimCost(uint256 _newClaimCost) public onlyOwner {
        claimCost = _newClaimCost;
    }

    /**
     * @dev Withdraw contract balance to owner.
     */
    function withdraw() public onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }

    /**
     * @dev Returns the base URI used in the contract.
     */
    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    /**
     * @notice Claim NFT.
     *
     * @dev ClaimingRequest that must be signed by the owner can be executed successfully.
     *
     * @param request The arguments of the claiming request.
     */
    function claim(ClaimingRequest calldata request)
        public
        payable
        returns (uint256)
    {
        require(msg.value >= claimCost, "Claiming cost is not enough");

        _verifyClaiming(request);

        uint256 newItemId = _tokenIds.current();
        _mint(request.data.recipient, newItemId);
        _userTokens[request.data.recipient].push(newItemId);

        _tokenIds.increment();
        
        // Emit an event to let off-chain services know that the token has been claimed.
        emit ClaimToken(newItemId, request.data.identifier);

        return newItemId;
    }

    /**
     * @dev Returns the domain separator used in the encoding of the signatures for attest, and revoke.
     */
    function getDomainSeparator() external view returns (bytes32) {
        return _domainSeparatorV4();
    }

    /**
     * @dev Verifies claiming request.
     *
     * @param request The arguments of the claiming request.
     */
    function _verifyClaiming(ClaimingRequest memory request) internal {
        if (request.deadline != NO_EXPIRATION_TIME && request.deadline <= _time()) {
            revert DeadlineExpired();
        }

        ClaimingRequestData memory data = request.data;
        EIP712Signature memory signature = request.signature;

        _verifyUnusedSignature(signature);

        bytes32 digest = _hashTypedDataV4(
            keccak256(            
                abi.encode(
                    data.recipient,
                    data.identifier,
                    keccak256(data.data),
                    request.deadline
                )
            )
        );

        if (ECDSA.recover(digest, signature.v, signature.r, signature.s) != owner()) {
            revert InvalidSignature();
        }
    }

    /**
     * @dev Ensures that the provided EIP712 signature wasn't already used.
     *
     * @param signature The EIP712 signature data.
     */
    function _verifyUnusedSignature(EIP712Signature memory signature) internal {
        bytes memory packedSignature = abi.encodePacked(signature.v, signature.r, signature.s);

        if (_signatures[packedSignature]) {
            revert UsedSignature();
        }

        _signatures[packedSignature] = true;
    }

    /**
     * @dev Returns the current's block timestamp. This method is overridden during tests and used to simulate the
     * current block time.
     */
    function _time() internal view virtual returns (uint64) {
        return uint64(block.timestamp);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// A representation of an empty/uninitialized UID.
bytes32 constant EMPTY_UID = 0;

// A zero expiration represents an non-expiring attestation.
uint64 constant NO_EXPIRATION_TIME = 0;

error AccessDenied();
error InvalidEAS();
error InvalidLength();
error InvalidSignature();
error NotFound();

/**
 * @dev A struct representing EIP712 signature data.
 */
struct EIP712Signature {
    uint8 v; // The recovery ID.
    bytes32 r; // The x-coordinate of the nonce R.
    bytes32 s; // The signature data.
}

/**
 * @dev A struct representing a single attestation.
 */
struct Attestation {
    bytes32 uid; // A unique identifier of the attestation.
    bytes32 schema; // The unique identifier of the schema.
    uint64 time; // The time when the attestation was created (Unix timestamp).
    uint64 expirationTime; // The time when the attestation expires (Unix timestamp).
    uint64 revocationTime; // The time when the attestation was revoked (Unix timestamp).
    bytes32 refUID; // The UID of the related attestation.
    address recipient; // The recipient of the attestation.
    address attester; // The attester/sender of the attestation.
    bool revocable; // Whether the attestation is revocable.
    bytes data; // Custom attestation data.
}

// SPDX-License-Identifier: MIT
// solhint-disable no-inline-assembly
pragma solidity >=0.6.9;

/**
 * @title TrustedForwarderManager
 *
 * @notice This contract provides the function of receiving relayed transactions for functions that do not access msg.sender and msg.data.
 */
abstract contract TrustedForwarderManager {

    /*
     * Forwarder singleton we accept calls from
     */
    address private _trustedForwarder;

    /**
     * :warning: **Warning** :warning: The Forwarder can have a full control over your Recipient. Only trust verified Forwarder.
     * @notice Method is not a required method to allow Recipients to trust multiple Forwarders. Not recommended yet.
     * @return forwarder The address of the Forwarder contract that is being used.
     */
    function getTrustedForwarder() public virtual view returns (address forwarder){
        return _trustedForwarder;
    }

    function _setTrustedForwarder(address _forwarder) internal {
        _trustedForwarder = _forwarder;
    }

    function isTrustedForwarder(address forwarder) public virtual view returns(bool) {
        return forwarder == _trustedForwarder;
    }
}

{
  "compilationTarget": {
    "Achievement.sol": "Achievement"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}