1. 鑄造新代幣 function mint(address to, uint256 tokeId)
- 鑄造, 即無中生有
- 只有合約擁有者或這特殊權限的人才能呼叫
- 同時也是一種轉帳, 由address 0X0轉到目標帳號(to)
- 由於是轉帳, 因此也要觸發
Transfer
事件 - 限制
- 不能鑄造給address 0
- tokenID 不能重複
2. 安全地鑄造新代幣 function safemint(address to, uint256 tokenId, bytes memory data)
- 跟轉帳一樣, 安全版本就是在轉移發生後呼叫 onERC721Received的檢查
3. 安全地鑄造新代幣 function safemint(address to, uint256 tokenId)
- 跟轉帳一樣, 直接呼叫safemint(ot, tokenId, "")
pragma solidity ^0.8.23;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC721{
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address account) external view returns(uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalforAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns(bool);
function mint(address to, uint256 tokenId) external;
function safemint(address to, uint256 tokenId, bytes memory data) external;
function safemint(address to, uint256 tokenId) external;
function burn(uint256 tokenId) external;
}
contract ERC721 is IERC721 {
mapping(address => uint256) _balances;
mapping(uint256 => address) _owners;
mapping(uint256 => address) _tokenApprovals;
mapping(address => mapping(address => bool)) _operatorApprovals;
function balanceOf(address owner) public view returns(uint256){
require(owner != address(0), "ERROR: address 0 cannot be owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view returns (address){
address owner = _owners[tokenId];
require(owner != address(0), "ERROR: tokenId is not valid Id");
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = _owners[tokenId];
require(owner != to,"ERROR: owner == to");
require(owner == msg.sender || isApprovedForAll(owner, msg.sender), "Error: Caller is not token owner / approved for all");
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address){
address owner = _owners[tokenId];
require(owner != address(0), "ERROR: Token is not minted or is burn");
return _tokenApprovals[tokenId];
}
function setApprovalforAll(address operator, bool _approved) public {
require(msg.sender != operator, "ERROR: owner == operator");
_operatorApprovals[msg.sender][operator] = _approved;
emit ApprovalForAll(msg.sender, operator, _approved);
}
function isApprovedForAll(address owner, address operator) public view returns(bool){
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public {
_transfer(from, to, tokenId);
}
function _transfer(address from, address to, uint256 tokenId) internal {
address owner = _owners[tokenId];
require(owner == from, "ERROR: Owner is not the from address");
require(msg.sender == owner || isApprovedForAll(owner, msg.sender) || getApproved(tokenId) == msg.sender, "ERROR: Caller doesn't have permission to transfer");
delete _tokenApprovals[tokenId];
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) public {
_safeTransfer(from, to, tokenId, data);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
_safeTransfer(from, to, tokenId, "");
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERROR: ERCReceiver is not implemented");
}
function mint(address to, uint256 tokenId) public {
require(to != address(0), "ERROR: Mint to address 0");
address owner = _owners[tokenId];
require(owner == address(0), "ERROR: tokenId existed");
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function safemint(address to, uint256 tokenId, bytes memory data) public {
mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, data), "ERROR: ERCReceiver is not implemented");
}
function safemint(address to, uint256 tokenId) public {
safemint(to, tokenId, "");
}
function burn(uint256 tokenId) public {
address owner = _owners[tokenId];
require(msg.sender == owner, "ERROR: only owner can burn");
_balances[_owners[tokenId]] -= 1;
delete _owners[tokenId];
delete _tokenApprovals[tokenId];
emit Transfer(owner, address(0), tokenId);
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private returns (bool) {
if (to.code.length > 0 ) {
try IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
}