Solidity | ERC721Upgradeable
Привет всем! Сегодня пойдет о самом популярном стандарте который есть на данный момент, это ERC721 или в простонародье NFT. Так как я понимаю, что это ну уж очень заезженная тема, я решил раскрыть ее немного с другой стороны, а именно, через upgrades.
Да я понимаю, что уже третья статья про proxy и upgradeable СК, но все таки тут будет достаточно полезно это улучшение. Ведь может быть случай, что вы создали свою коллекцию и она так завирусилась, что вы хотите например добавить функционал холдерам NFT и выдавать разные бонусы за их активность. Но если вы не сделали вашу NFT коллекцию обновляемой, то могут возникнуть сложности.
Расскажу одну вещь для общего развития. Из за своей популярности NFT, многие стали думать, что NFT это картинка. НО, я хочу быть уверенным, что вы так не думаете. Потому что NFT, это non-fungible token или невзаимозаменяемые токены. То есть это токены, которые не могут быть поделены на части, и поэтому у них нет decemals, как у ЕРС20. Да, эта особенность позволила нам прикреплять за токеном какое то изображение, звук, видео или еще что-то, а можно и не прикреплять, в любом случае, это не меняет его сущность этих токенов
К чему я вел это долгое вступление?
Очень много людей стали хейтить разработчиков NFT за то, что они хранят данные прикреплённые к токену, например изображения, на внешних платформах, таких как filecoin и другие. Мол это ни фига не NFT. Они же их хранят в базе данных и каждый может получить к ним доступ. Формально это так, но нужно понимать, что хранение изображений в блокчейне будет стоить космических денег. Поэтому была и предложена эта реализация хранения. Причем если смотреть глубже, то чаще всего используется протокол ipfs, который генерирует ссылку через хэшировние криптографическими методами, для получения уникального и не повторимого cid, который уже используется в NFT. Сорян подгорело. У меня все.
IERC721Upgradeable
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
interface IERC721Upgradeable is IERC165Upgradeable {
event Transfer(address indexed from, address indexed to, uint256 indexed 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 owner) 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);}Это обычный интерфейс ERC721 ни чего особенного. Даже чем то похож на ERC20. Я не буду объяснять что здесь за функции, и сделаю это по мере реализации стандарта дальше. Думаю так будет понятнее.
ERC721Upgradeable
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC721Upgradeable.sol";
import "./IERC721ReceiverUpgradeable.sol";
import "./IERC721MetadataUpgradeable.sol";
import "./utils/AddressUpgradeable.sol";
import "./utils/ContextUpgradeable.sol";
import "./utils/StringsUpgradeable.sol";
import "./ERC165Upgradeable.sol";
import "./utils/Initializable.sol";
contract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable { using AddressUpgradeable for address; using StringsUpgradeable for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC721_init_unchained(name_, symbol_);
}
function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC721Upgradeable).interfaceId ||
interfaceId == type(IERC721MetadataUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721Upgradeable.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all" );
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(tokenId) != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721Upgradeable.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId, 1);
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721Upgradeable.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
owner = ERC721Upgradeable.ownerOf(tokenId);
delete _tokenApprovals[tokenId];
unchecked {
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); delete _tokenApprovals[tokenId];
unchecked {
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.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;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
function __unsafe_increaseBalance(address account, uint256 amount) internal {
_balances[account] += amount;
}
uint256[44] private __gap;
}mapping(uint256 => address) private _owners; mapping(address => uint256) private _balances; mapping(uint256 => address) private _tokenApprovals; mapping(address => mapping(address => bool)) private _operatorApprovals;
Первый маппинг будет хранить адрес владельца токена по его индексу.
Второй маппинг будет хранить баланс токенов у владельца
Третий маппинг будет хранить индекс токена на перевод по адресу
Четвертый маппинг будет хранить разрешение на перевод всех токенов сразу у его владельца (этих токенов), какому то человеку.
Пройдемся по функциям основного контракта:
function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC721_init_unchained(name_, symbol_);
}
function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}Эти функции нам нужны для определения названия и символа токенов, потому что в обновляемых смарт-контрактах как мы знаем нельзя использовать конструктор.
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC721Upgradeable).interfaceId ||
interfaceId == type(IERC721MetadataUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}Регистрирует контракт как средство реализации интерфейса, определенного селектора interfaceId. Просто вернет информацию о том, что СК поддерживает интерфейсы IERC721Upgradeable и IERC721MetadataUpgradeable.
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(tokenId) != address(0);
}Функция balanceOf вернет баланс токенов у адреса. Функция ownerOf вернет владельца токена, вызвав _ownerOf и проверит, что адрес не нулевой. Все происходит через маппинги.
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}Вернут имя и символ токена как в ERC20
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}_baseURI это общее начало у ссылки на вашу картинку если простым языком. tokenURI возвращает картинку к которой прикреплен данный токен. Это так сказать наши метаданные. Ведь все любят NFT не за то, что они являются не взаимозаменяемыми токенами, а за то, что они дают нам возможность прикреплять за ними свое "искусство" и делать его уникальным. Функцию _requireMinted напишем позже, но она просто проверяет, что такой токен существует.
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721Upgradeable.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721Upgradeable.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}approve функция как и в ERC20 дает нам разрешение на списывание токенов с нашего аккаунта. В начале передаем переменной owner владельца токена, который мы передали, после чего мы проверяем является ли человек, который вызвал функцию владельцем данного токена. Если да то вызывается функция _approve, где мы даем разрешение адресу to.
getApproved просто вернет адрес, кому был дан апрув. С проверкой, что такой токен существует.
setApprovalForAll устанавливает разрешение на перевод всех токенов, которые есть у человека. То есть если у вас 5 nft данного проекта, то вы даете разрешение на перевод всех пяти токенов. Вызывает внутри функцию _setApprovalForAll, где мы можем либо дать разрешение на все токены, либо убрать. (По маппингу это делаем)
_isApprovedOrOwner будет проверять: дано разращение или нет. Обращается к getApproved и к isApprovedForAll, таким образом мы узнаем информацию сразу про все случаи разрешения. И так же узнает является ли владелец токена его владельцем как не странно.
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); delete _tokenApprovals[tokenId];
unchecked {
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
transferFrom Переводит токен, и проверяет дано было разрешение или нет через _isApprovedOrOwner. Ну и вызывает _transfer. Там снова идет проверка, что данный вызов от овенра токена и то, что получатель не нулевой адрес. _beforeTokenTransfer это функция каких то идей перед переводом, но их нет, и дальше смотрим, что эти идеи не привели к тому, что владелец токена поменялся (а вдруг идеи есть). После просто переводим токен. В маппенге владельцев мы меняем владельца токена. Сорри за многочисленную тавтологию. Ну и там мы можем вызвать функцию _afterTokenTransfer идей, которых нет после перевода как всегда.
safeTransferFrom делает все тоже самое, но эту функцию рекомендуют использовать по возможности вместо transferFrom из за одной особенности:
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.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;
}
}Данная особенность в safeTransferFrom заключается в том, что мы проверяем случай перевода на другой СК, так как мы помнем, что смарт-контракты также как и адресы кошельков могут владеть токенами. И если такой случай произошел. (isContract из прошлой статьи). Мы будем смотреть, что смарт-контракт, который хочет перевести токены поддерживает интерфейс IERC721ReceiverUpgradeable. Если да, то вызывается функция onERC721Received, и возвращается селектор, этот селектор должен быть равен селектору onERC721Received, если это не произошло, то мы откатываем транзакцию. И через ассемблер получаем причину отката. Это нужно для того, чтоб мы внутри СК, который делает этот вызов не делали разные пакости при переводе.
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId, 1);
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721Upgradeable.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
owner = ERC721Upgradeable.ownerOf(tokenId);
delete _tokenApprovals[tokenId];
unchecked {
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}_safeMint это функция чеканки новых токенов. Мы можем делать ограничение или его не делать (supply). Но это уже надо в своем СК если хотите. А мы же вызываем _mint, где и происходит чеканка. Так же мы не забываем проверить, что функцию минт не хотят хакнуть, через _checkOnERC721Received
Второй _safeMint дает нам возможность еще передать данные data при минте
Минт работает по принципу: кто вызвал, тот и получил токен. Перед пополнением баланса мы должны сделать ряд проверок, что вызываемый адрес не нулевой, что такой токен по id не был уже заминчен. Ну и установить владельца данного токена через маппинг.
_burn логично, что удаляет токены у того, кто вызвал эту функцию.
_requireMinted, функция, которая помогает нам определить является ли этот токен уже заминченым.
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}exists вернет true или false, если токен существует или нет.
В целом весь стандарт реализован
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Upgradeable.sol";
import "./utils/Initializable.sol";
abstract contract ERC721URIStorageUpgradeable is Initializable, ERC721Upgradeable {
function __ERC721URIStorage_init() internal onlyInitializing {
}
function __ERC721URIStorage_init_unchained() internal onlyInitializing {
}
using StringsUpgradeable for uint256;
mapping(uint256 => string) private _tokenURIs;
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory _tokenURI = _tokenURIs[tokenId];
string memory base = _baseURI();
if (bytes(base).length == 0) {
return _tokenURI;
}
if (bytes(_tokenURI).length > 0) {
return string(abi.encodePacked(base, _tokenURI));
}
return super.tokenURI(tokenId);
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
function _burn(uint256 tokenId) internal virtual override {
super._burn(tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
uint256[49] private __gap;
}Этот контракт помогает нам хранить метаданные по id токена.
mapping(uint256 => string) private _tokenURIs;
Хранит по маппингу ссылку на метаданные токена.
tokenURI делает тоже самое, что и в самом стандарте.
_setTokenURI устанавливает токену ссылку на метаданные.
_burn стирает метаданные из токена. Таким образом можно перезаписать их в случае необходимости.
В целом это весь стандарт. Конечно тут можно добавить кучу дополнений, но мы говорим про сам стандарт, поэтому без воды.
Пишем свой ERC721Upgradeabl проект.
Так как я уже говорил ранее, что не вижу смысла изобретать велосипед в proxy СК, то мы будем брать готовое решение из openzeppelin.
Для создания своего проекта будем использовать Wizard
// SPDX-License-Identifier: MIT pragma solidity ^0.8.9;
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721URIStorageUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
contract MyToken is Initializable, ERC721Upgradeable, ERC721URIStorageUpgradeable, OwnableUpgradeable, UUPSUpgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
CountersUpgradeable.Counter private _tokenIdCounter;
function initialize() initializer public {
__ERC721_init("MyToken", "MTK");
__ERC721URIStorage_init();
__Ownable_init();
__UUPSUpgradeable_init();
}
function _baseURI() internal pure override returns (string memory) {
return "https://";
}
function safeMint(address to, string memory uri) public onlyOwner {
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(to, tokenId);
_setTokenURI(tokenId, uri);
}
function _authorizeUpgrade(address newImplementation) internal onlyOwner override {}
function _burn(uint256 tokenId) internal override(ERC721Upgradeable, ERC721URIStorageUpgradeable) {
super._burn(tokenId);
}
function tokenURI(uint256 tokenId) public view override(ERC721Upgradeable, ERC721URIStorageUpgradeable) returns (string memory) {
return super.tokenURI(tokenId);
}
}Чтоб все библиотеки подтянулись мы должны импортировать их
npm install @openzeppelin/contracts-upgradeable
Так же, чтоб работали скрипты для деплоя
npm install --save-dev @openzeppelin/hardhat-upgrades
И импортируем в hardhat.config.js
require('@openzeppelin/hardhat-upgrades');Я надеюсь что такое hardhat объяснять не надо, но если что, то у меня есть уже статьи про это. Или посмотрите документация про деплой через hardhat тут
Так вот сверху уже готовый NFT смарт-контракт для деплоя.
Первая переменная будет счетчиком наших токенов. Это структура Counter с одной переменной uint из СК CounterUpgradeable. И так же мы для нее подключили библиотеку c математическими операциями.
Вместо конструктора для деплоя мы используем функцию initialize, где передаем название и символ токена.
_baseURI вернет начало ссылки на токен. Ну я поставил https:// но можно и свое.
safeMint функция покупки нфт, или чеканка. Можно ее использовать для своих минтинг сайтов. Внутри мы прибавляем на один _tokenIdCounter и разумеется в переменную tokenId передаем номер NFT. После мы просто вызываем функцию safeMint, где привязываем к адресу to текущий id NFT. Ну и устанавливаем uri для того, чтоб мы могли ей передать метаданные.
_authorizeUpgrade обязательная функция для UUPS proxy как мы помним.
tokenURI возвращает метаданные токена по id, например чтоб вывести их на экран на сайте.
super означает вызвать функцию из дочернего контракта, где она есть.
В целом как деплоить обновляемые контракты я показывал в прошлой статье, поэтому не буду повторяться, но могу сказать что тут все ровно тоже самое
Думаю на этом все. Сегодня я рассказал про ERC721, но не про обычную его реализацию а про upgradeable. Дальше больше. Я считаю это на много интереснее, чем читать про обычный заезженный стандарт, который уже каждый второй об шерстил вдоль и поперек. Удачи!
tg: мой телеграмчик)