안녕하세요.
테스트넷에선 잘되던 화이트리스트민팅이
메인넷에선 처음에 성공하다가 갑자기 evm: execution reverted 에러가 발생합니다…
pragma solidity ^0.5.0;
contract KIP17Kbirdz is KIP17, KIP17Enumerable, KIP17Metadata, MinterRole, KIP17HaveNFT {
// To prevent bot attack, we record the last contract call block number.
mapping (address => uint256) private _lastCallBlockNumber;
uint256 private _antibotInterval;
// If someone burns NFT in the middle of minting,
// the tokenId will go wrong, so use the index instead of totalSupply().
uint256 private _mintIndexForSale;
uint256 private _mintLimitPerBlock; // Maximum purchase nft per person per block
uint256 private _mintLimitPerSale; // Maximum purchase nft per person per sale
string private _tokenBaseURI;
uint256 private _mintStartBlockNumber; // In blockchain, blocknumber is the standard of time.
uint256 private _maxSaleAmount; // Maximum purchase volume of normal sale.
uint256 private _mintPrice; // 1 KLAY = 1000000000000000000
string baseURI;
string notRevealedUri;
bool public revealed = false;
bool public publicMintEnabled = false;
bool public NFTCheckMint = false;
function _baseURI() internal view returns (string memory) {
return baseURI;
}
function _notRevealedURI() internal view returns (string memory) {
return notRevealedUri;
}
function setBaseURI(string memory _newBaseURI) public onlyMinter {
baseURI = _newBaseURI;
}
function setNotRevealedURI(string memory _newNotRevealedURI) public onlyMinter {
notRevealedUri = _newNotRevealedURI;
}
function reveal(bool _state) public onlyMinter {
revealed = _state;
}
function NFTCheckMintEnabled(bool _state) public onlyMinter {
NFTCheckMint = _state;
}
function tokenURI(uint256 tokenId)
public
view
returns (string memory)
{
require(
_exists(tokenId),
"KIP17Metadata: URI query for nonexistent token"
);
if(revealed == false) {
string memory currentNotRevealedUri = _notRevealedURI();
return bytes(currentNotRevealedUri).length > 0
? string(abi.encodePacked(currentNotRevealedUri, String.uint2str(tokenId), ".json"))
: "";
}
string memory currentBaseURI = _baseURI();
return bytes(currentBaseURI).length > 0
? string(abi.encodePacked(currentBaseURI, String.uint2str(tokenId), ".json"))
: "";
}
constructor () public {
//init explicitly.
_mintIndexForSale = 1;
}
function mintingInformation() external view returns (uint256[7] memory){
uint256[7] memory info =
[_antibotInterval, _mintIndexForSale, _mintLimitPerBlock, _mintLimitPerSale,
_mintStartBlockNumber, _maxSaleAmount, _mintPrice];
return info;
}
function setPublicMintEnabled(bool _state) public onlyMinter {
publicMintEnabled = _state;
}
function setupSale(uint256 newAntibotInterval,
uint256 newMintLimitPerBlock,
uint256 newMintLimitPerSale,
uint256 newMintStartBlockNumber,
uint256 newMintIndexForSale,
uint256 newMaxSaleAmount,
uint256 newMintPrice) external onlyMinter{
_antibotInterval = newAntibotInterval;
_mintLimitPerBlock = newMintLimitPerBlock;
_mintLimitPerSale = newMintLimitPerSale;
_mintStartBlockNumber = newMintStartBlockNumber;
_mintIndexForSale = newMintIndexForSale;
_maxSaleAmount = newMaxSaleAmount;
_mintPrice = newMintPrice;
}
//Public Mint
function publicMint(uint256 requestedCount) external payable {
if (NFTCheckMint == true) {
require(balanceOfFrom(msg.sender) > 0, "Doesn't have NFT");
}
require(publicMintEnabled, "The public sale is not enabled!");
require(_lastCallBlockNumber[msg.sender].add(_antibotInterval) < block.number, "Bot is not allowed");
require(block.number >= _mintStartBlockNumber, "Not yet started");
require(requestedCount > 0 && requestedCount <= _mintLimitPerBlock, "Too many requests or zero request");
require(msg.value == _mintPrice.mul(requestedCount), "Not enough Klay");
require(_mintIndexForSale.add(requestedCount) <= _maxSaleAmount + 1, "Exceed max amount");
require(balanceOf(msg.sender) + requestedCount <= _mintLimitPerSale, "Exceed max amount per person");
for(uint256 i = 0; i < requestedCount; i++) {
_mint(msg.sender, _mintIndexForSale);
_mintIndexForSale = _mintIndexForSale.add(1);
}
_lastCallBlockNumber[msg.sender] = block.number;
0x2c193dB09Abf67B53C07854c695D122a491759b1.transfer(address(this).balance);
}
//Whitelist Mint
bytes32 public merkleRoot;
bool public whitelistMintEnabled = false;
function setMerkleRoot(bytes32 _merkleRoot) public onlyMinter {
merkleRoot = _merkleRoot;
}
function setWhitelistMintEnabled(bool _state) public onlyMinter {
whitelistMintEnabled = _state;
}
function whitelistMint(uint256 requestedCount, bytes32[] calldata _merkleProof) external payable {
require(whitelistMintEnabled, "The whitelist sale is not enabled!");
require(msg.value == _mintPrice.mul(requestedCount), "Not enough Klay");
require(requestedCount > 0 && requestedCount <= _mintLimitPerBlock, "Too many requests or zero request");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
for(uint256 i = 0; i < requestedCount; i++) {
_mint(msg.sender, _mintIndexForSale);
_mintIndexForSale = _mintIndexForSale.add(1);
}
0x2c193dB09Abf67B53C07854c695D122a491759b1.transfer(address(this).balance);
}
//Airdrop Mint
function airDropMint(address user, uint256 requestedCount) external onlyMinter {
require(requestedCount > 0, "zero request");
for(uint256 i = 0; i < requestedCount; i++) {
_mint(user, _mintIndexForSale);
_mintIndexForSale = _mintIndexForSale.add(1);
}
}
}
// File: contracts\KIP17Full.sol
pragma solidity ^0.5.0;
/**
* @title Full KIP-17 Token
* This implementation includes all the required and some optional functionality of the KIP-17 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see http://kips.klaytn.com/KIPs/kip-17-non_fungible_token
*/
contract KIP17Full is KIP17, KIP17Enumerable, KIP17Metadata, Ownable, KIP17Kbirdz {
constructor (string memory name, string memory symbol) public KIP17Metadata(name, symbol) {
// solhint-disable-previous-line no-empty-blocks
}
}
// File: contracts\KIP17MetadataMintable.sol
pragma solidity ^0.5.0;
/**
* @title KIP17MetadataMintable
* @dev KIP17 minting logic with metadata.
*/
contract KIP17MetadataMintable is KIP13, KIP17, KIP17Metadata, MinterRole {
/*
* bytes4(keccak256('mintWithTokenURI(address,uint256,string)')) == 0x50bb4e7f
* bytes4(keccak256('isMinter(address)')) == 0xaa271e1a
* bytes4(keccak256('addMinter(address)')) == 0x983b2d56
* bytes4(keccak256('renounceMinter()')) == 0x98650275
*
* => 0x50bb4e7f ^ 0xaa271e1a ^ 0x983b2d56 ^ 0x98650275 == 0xfac27f46
*/
bytes4 private constant _INTERFACE_ID_KIP17_METADATA_MINTABLE = 0xfac27f46;
/**
* @dev Constructor function.
*/
constructor () public {
// register the supported interface to conform to KIP17Mintable via KIP13
_registerInterface(_INTERFACE_ID_KIP17_METADATA_MINTABLE);
}
/**
* @dev Function to mint tokens.
* @param to The address that will receive the minted tokens.
* @param tokenId The token id to mint.
* @param tokenURI The token URI of the minted token.
* @return A boolean that indicates if the operation was successful.
*/
function mintWithTokenURI(address to, uint256 tokenId, string memory tokenURI) public onlyMinter returns (bool) {
_mint(to, tokenId);
_setTokenURI(tokenId, tokenURI);
return true;
}
}
// File: contracts\KIP17Mintable.sol
pragma solidity ^0.5.0;
/**
* @title KIP17Mintable
* @dev KIP17 minting logic.
*/
contract KIP17Mintable is KIP17, MinterRole {
/*
* bytes4(keccak256('isMinter(address)')) == 0xaa271e1a
* bytes4(keccak256('addMinter(address)')) == 0x983b2d56
* bytes4(keccak256('renounceMinter()')) == 0x98650275
* bytes4(keccak256('mint(address,uint256)')) == 0x40c10f19
*
* => 0xaa271e1a ^ 0x983b2d56 ^ 0x98650275 ^ 0x40c10f19 == 0xeab83e20
*/
bytes4 private constant _INTERFACE_ID_KIP17_MINTABLE = 0xeab83e20;
/**
* @dev Constructor function.
*/
constructor () public {
// register the supported interface to conform to KIP17Mintable via KIP13
_registerInterface(_INTERFACE_ID_KIP17_MINTABLE);
}
/**
* @dev Function to mint tokens.
* @param to The address that will receive the minted tokens.
* @param tokenId The token id to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address to, uint256 tokenId) public onlyMinter returns (bool) {
_mint(to, tokenId);
return true;
}
}
// File: contracts\KIP17Burnable.sol
pragma solidity ^0.5.0;
/**
* @title KIP17 Burnable Token
* @dev KIP17 Token that can be irreversibly burned (destroyed).
* See http://kips.klaytn.com/KIPs/kip-17-non_fungible_token
*/
contract KIP17Burnable is KIP13, KIP17 {
/*
* bytes4(keccak256('burn(uint256)')) == 0x42966c68
*
* => 0x42966c68 == 0x42966c68
*/
bytes4 private constant _INTERFACE_ID_KIP17_BURNABLE = 0x42966c68;
/**
* @dev Constructor function.
*/
constructor () public {
// register the supported interface to conform to KIP17Burnable via KIP13
_registerInterface(_INTERFACE_ID_KIP17_BURNABLE);
}
/**
* @dev Burns a specific KIP17 token.
* @param tokenId uint256 id of the KIP17 token to be burned.
*/
function burn(uint256 tokenId) public {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(msg.sender, tokenId), "KIP17Burnable: caller is not owner nor approved");
_burn(tokenId);
}
}
// File: contracts\roles\PauserRole.sol
pragma solidity ^0.5.0;
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
// File: contracts\lifecycle\Pausable.sol
pragma solidity ^0.5.0;
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
contract Pausable is PauserRole {
/**
* @dev Emitted when the pause is triggered by a pauser (`account`).
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by a pauser (`account`).
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state. Assigns the Pauser role
* to the deployer.
*/
constructor () internal {
_paused = false;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view returns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
/**
* @dev Called by a pauser to pause, triggers stopped state.
*/
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
/**
* @dev Called by a pauser to unpause, returns to normal state.
*/
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
// File: contracts\KIP17Pausable.sol
pragma solidity ^0.5.0;
/**
* @title KIP17 Non-Fungible Pausable token
* @dev KIP17 modified with pausable transfers.
*/
contract KIP17Pausable is KIP13, KIP17, Pausable {
/*
* bytes4(keccak256('paused()')) == 0x5c975abb
* bytes4(keccak256('pause()')) == 0x8456cb59
* bytes4(keccak256('unpause()')) == 0x3f4ba83a
* bytes4(keccak256('isPauser(address)')) == 0x46fbf68e
* bytes4(keccak256('addPauser(address)')) == 0x82dc1ec4
* bytes4(keccak256('renouncePauser()')) == 0x6ef8d66d
*
* => 0x5c975abb ^ 0x8456cb59 ^ 0x3f4ba83a ^ 0x46fbf68e ^ 0x82dc1ec4 ^ 0x6ef8d66d == 0x4d5507ff
*/
bytes4 private constant _INTERFACE_ID_KIP17_PAUSABLE = 0x4d5507ff;
/**
* @dev Constructor function.
*/
constructor () public {
// register the supported interface to conform to KIP17Pausable via KIP13
_registerInterface(_INTERFACE_ID_KIP17_PAUSABLE);
}
function approve(address to, uint256 tokenId) public whenNotPaused {
super.approve(to, tokenId);
}
function setApprovalForAll(address to, bool approved) public whenNotPaused {
super.setApprovalForAll(to, approved);
}
function transferFrom(address from, address to, uint256 tokenId) public whenNotPaused {
super.transferFrom(from, to, tokenId);
}
}
// File: contracts\KIP17MakeNFT.sol
pragma solidity ^0.5.0;
contract KIP17MakeNFT is KIP17Full, KIP17Mintable, KIP17MetadataMintable, KIP17Burnable, KIP17Pausable {
constructor (string memory name, string memory symbol) public KIP17Full(name, symbol) {
}
}
처음에 화이트리스트 민팅이 성공하다가 갑자기 컨트랙트에 모든 함수가 execution reverted 에러가 나오고… require 부분에 에러메시지가 나오는것도아니라 어디가문젠지도 모르겠습니다…
기존 코드는
이 코드를 변형해서 만들었습니다.
(화리민팅시 한번만 민팅가능한걸 빼고, withdraw 함수를 실행해야 컨트랙트에 쌓인 클레이튼이 들어오는데 이 부분을 제거하고 민팅할때마다 제 지갑주소로 클레이튼이 전송되게 수정했습니다.)
0x66ec220fcd448ca0741d9a5773ab1619820f3a19
이게 8번까지 화리 성공한 컨트렉트주소입니다.
그 이후로는 모든기능이 다 Evm: execution reverted 에러가 발생합니다…
답변 부탁드리겠습니다ㅠㅠ