0

i have tried to change compiler version in all source files but it is still not getting compiled optimization is enabled and I have flattened the contract as well

i have tried to change compiler version in all source files but it is still not getting compiled optimization is enabled and I have flattened the contract as well

//SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

import "contracts/token/ERC721/extensions/ERC721Enumerable.sol"; import "contracts/access/Ownable.sol";

contract EYES is ERC721Enumerable, Ownable { using Strings for uint256;

string public baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.01 ether;
uint256 public presaleCost = 0.02 ether;
uint256 public maxSupply = 36;
uint256 public maxMintAmount = 2;
bool public paused = false;
mapping(address => bool) public whitelisted;
mapping(address => bool) public presaleWallets;

constructor(
    string memory _name,
    string memory _symbol,
    string memory _initBaseURI
) ERC721(_name, _symbol) {
    setBaseURI(_initBaseURI);
    mint(msg.sender, 2);
}

// internal
function _baseURI() internal view virtual override returns (string memory) {
    return baseURI;
}

// public
function mint(address _to, uint256 _mintAmount) public payable {
    uint256 supply = totalSupply();
    require(!paused);
    require(_mintAmount > 0);
    require(_mintAmount <= maxMintAmount);
    require(supply + _mintAmount <= maxSupply);

    if (msg.sender != owner()) {
        if (whitelisted[msg.sender] != true) {
            if (presaleWallets[msg.sender] != true) {
                //general public
                require(msg.value >= cost * _mintAmount);
            } else {
                //presale
                require(msg.value >= presaleCost * _mintAmount);
            }
        }
    }

    for (uint256 i = 1; i <= _mintAmount; i++) {
        _safeMint(_to, supply + i);
    }
}

function walletOfOwner(address _owner)
    public
    view
    returns (uint256[] memory)
{
    uint256 ownerTokenCount = balanceOf(_owner);
    uint256[] memory tokenIds = new uint256[](ownerTokenCount);
    for (uint256 i; i < ownerTokenCount; i++) {
        tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
    }
    return tokenIds;
}

function tokenURI(uint256 tokenId)
    public
    view
    virtual
    override
    returns (string memory)
{
    require(
        _exists(tokenId),
        "ERC721Metadata: URI query for nonexistent token"
    );

    string memory currentBaseURI = _baseURI();
    return
        bytes(currentBaseURI).length > 0
            ? string(
                abi.encodePacked(
                    currentBaseURI,
                    tokenId.toString(),
                    baseExtension
                )
            )
            : "";
}

//only owner
function setCost(uint256 _newCost) public onlyOwner {
    cost = _newCost;
}

function setPresaleCost(uint256 _newCost) public onlyOwner {
    presaleCost = _newCost;
}

function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
    maxMintAmount = _newmaxMintAmount;
}

function setBaseURI(string memory _newBaseURI) public onlyOwner {
    baseURI = _newBaseURI;
}

function setBaseExtension(string memory _newBaseExtension)
    public
    onlyOwner
{
    baseExtension = _newBaseExtension;
}

function pause(bool _state) public onlyOwner {
    paused = _state;
}

function whitelistUser(address _user) public onlyOwner {
    whitelisted[_user] = true;
}

function removeWhitelistUser(address _user) public onlyOwner {
    whitelisted[_user] = false;
}

function addPresaleUser(address _user) public onlyOwner {
    presaleWallets[_user] = true;
}

function add100PresaleUsers(address[100] memory _users) public onlyOwner {
    for (uint256 i = 0; i < 2; i++) {
        presaleWallets[_users[i]] = true;
    }
}

function removePresaleUser(address _user) public onlyOwner {
    presaleWallets[_user] = false;
}

function withdraw() public payable onlyOwner {
    (bool success, ) = payable(msg.sender).call{
        value: address(this).balance
    }("");
    require(success);
}

}

1 Answer 1

0

You can check your contract using the Truffle plugin truffle-plugin-verify. Install the plugin using this command

npm install -D truffle-plugin-verify

When it is installed, you should add the following to your truffle-config.js file to enable the plugin with truffle:

module.exports = {
  /* ... others configurations truffle-config */

  plugins: [
    'truffle-plugin-verify'
  ]
}

After you have compiled the contract on the network, for example on the Ropsten network, you can use the command

truffle run verify EYES --network ropsten

You can also pass the address of the contract you are deploying to the network using the command.

truffle run verify EYES@0x000000000000 --network ropsten

I believe the truffle check makes it much easier and avoids any kind of error.

1

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.