File size: 3,977 Bytes
cc183a1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {IERC4907} from "./interfaces/IERC4907.sol";
import {IERC5192} from "./interfaces/IERC5192.sol";
import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract PermitLockCollection13 is ERC721, IERC4907, IERC5192, EIP712 {
struct UserInfo {
address user;
uint64 expires;
}
address public immutable issuer;
mapping(uint256 => UserInfo) private _users;
mapping(uint256 => bool) private _locked;
mapping(uint256 => uint256) private _nonces;
bytes32 public constant PERMIT_TYPEHASH =
keccak256("Permit(address spender,uint256 tokenId,uint256 nonce,uint256 deadline)");
constructor() ERC721("Collection", "NFT") EIP712("Collection", "1") {
issuer = msg.sender;
}
function mint(address to, uint256 tokenId) external {
require(msg.sender == issuer, "only issuer");
_mint(to, tokenId);
}
function setLocked(uint256 tokenId, bool value) external {
require(msg.sender == _requireOwned(tokenId), "only owner");
require(value, "lock is permanent");
_locked[tokenId] = true;
emit Locked(tokenId);
}
function locked(uint256 tokenId) public view returns (bool) {
_requireOwned(tokenId);
return _locked[tokenId];
}
function setUser(uint256 tokenId, address user, uint64 expires) external {
require(!_locked[tokenId], "token is locked");
require(_isAuthorized(_requireOwned(tokenId), msg.sender, tokenId), "caller is not owner nor approved");
require(expires > block.timestamp, "expiry must be in the future");
_users[tokenId] = UserInfo(user, expires);
emit UpdateUser(tokenId, user, expires);
}
function userOf(uint256 tokenId) public view returns (address) {
return block.timestamp < _users[tokenId].expires ? _users[tokenId].user : address(0);
}
function userExpires(uint256 tokenId) external view returns (uint256) {
return _users[tokenId].expires;
}
function nonces(uint256 tokenId) external view returns (uint256) {
_requireOwned(tokenId);
return _nonces[tokenId];
}
function DOMAIN_SEPARATOR() external view returns (bytes32) {
return _domainSeparatorV4();
}
function permit(
address spender,
uint256 tokenId,
uint256 deadline,
bytes memory sig
) external {
require(block.timestamp <= deadline, "permit expired");
address owner = _requireOwned(tokenId);
bytes32 structHash = keccak256(
abi.encode(
PERMIT_TYPEHASH,
spender,
tokenId,
_nonces[tokenId]++,
deadline
)
);
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, sig);
require(signer == owner, "invalid permit signature");
_approve(spender, tokenId, address(0), true);
}
function _update(address to, uint256 tokenId, address auth) internal override returns (address from) {
from = super._update(to, tokenId, auth);
if (from != address(0)) {
require(!_locked[tokenId], "token is locked");
_nonces[tokenId]++;
if (from != to && _users[tokenId].user != address(0)) {
delete _users[tokenId];
emit UpdateUser(tokenId, address(0), 0);
}
}
}
function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
return interfaceId == bytes4(0x5604e225)
|| interfaceId == type(IERC4907).interfaceId
|| interfaceId == type(IERC5192).interfaceId
|| super.supportsInterface(interfaceId);
}
}
|