Adil chain Explorer

Contract Address

Contract Name

Compiler

Enter the Vyper Contract Code

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./libraries/MetadataLibrary.sol";
import "./libraries/OwnerOperator.sol";
import "./interfaces/IHorseNFT.sol";
import "./libraries/EarningsManager.sol";

contract HorseIINFT is ERC721, ERC721Enumerable, Pausable, IHorseNFT, OwnerOperator, EarningsManager {
    using SafeMath for uint256;
    using MetadataLibrary for MetadataLibrary.Metadata;

// Base URI of all token
    string public baseURI;
    address[] public earners;
    uint256[] public ratesEarning;

// Mapping from token ID to token metadata
    mapping(uint256 => MetadataLibrary.Metadata) private metadatas;
    // Mapping from meta url to check url used
    mapping(string => bool) private usedUrl;
    // Mapping from meta url to token id
    mapping(string => uint256) private idOfUrl;

constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_) {}

function pause() external onlyOwner {
        _pause();
    }

function unpause() external onlyOwner {
        _unpause();
    }

function setBaseURI(string memory _baseURIMetadata) external onlyOwner {
        baseURI = _baseURIMetadata;
    }

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

function isExists(uint256 tokenId) external view override returns (bool) {
        return _exists(tokenId);
    }

function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_exists(tokenId), "HorseNFT: URI query for nonexistent token");
        string memory base = _baseURI();
        string memory metaUrl = metadatas[tokenId].getMetadataUrl();
        return bytes(base).length > 0 ? string(abi.encodePacked(base, metaUrl)) : "";
    }

function getTokenMetadata(uint256 tokenId) external view returns (MetadataLibrary.Metadata memory) {
        require(_exists(tokenId), "HorseNFT: Metadata query for nonexistent token");
        return metadatas[tokenId];
    }

function tokenIdOfMetaUrl(string memory metaUrl) external view returns (uint256) {
        require(usedUrl[metaUrl], "HorseNFT: nonexistent token");
        return idOfUrl[metaUrl];
    }

function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override(ERC721, ERC721Enumerable) {
        super._beforeTokenTransfer(from, to, tokenId);
        require(!paused(), "HorseNFT: token transfer while paused");
    }

function _mintInternal(address to, uint256 tokenId, string memory metaUrl) internal {
        require(!usedUrl[metaUrl], "HorseNFT: metaUrl existed");
        usedUrl[metaUrl] = true;
        idOfUrl[metaUrl] = tokenId;
        metadatas[tokenId].setMetadataUrl(metaUrl);
        _safeMint(to, tokenId);
        emit AddNewToken(tokenId, to);
    }

function mint(address to, uint256 tokenId, string memory metaUrl) external override onlyOwner {
        _mintInternal(to, tokenId, metaUrl);
    }

function mintBatch(address to, uint256[] memory tokenIds, string[] memory metaUrls) public operatorOrOwner {
        for (uint256 i = 0; i < tokenIds.length; i++) {
            _mintInternal(to, tokenIds[i], metaUrls[i]);
        }
    }

function multiMint(address to, uint256[] memory ids, string[] memory metaUrls) external virtual operatorOrOwner {
        uint256 len = ids.length;
        require(len == metaUrls.length, "HorseNFTII: metaUrls.length != ids.length");
        for (uint256 i = 0; i < len; i++) {
            _mintInternal(to, ids[i], metaUrls[i]);
        }
    }

function burnBatch(uint256[] memory ids) public {
        uint256 len = ids.length;
        for (uint256 i = 0; i < len; i++) {
            _burn(ids[i]);
        }
    }

function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(ERC721, ERC721Enumerable, IERC165) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

function burn(uint256 tokenId) external override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "Caller is not owner nor approved");
        _burn(tokenId);
    }

function setEarning(address[] memory _earners, uint256[] memory _rates) public onlyOwner {
        _validateEarningInputs(_earners, _rates);

_restoreEarners(_earners);
        _calculateTotalRate(_earners, _rates);

earners = _earners;
        ratesEarning = _rates;

_emitEarningEvents(_earners, _rates);
    }

function getEarnersAndRates() public view returns (address[] memory, uint256[] memory) {
        return (earners, ratesEarning);
    }

function getLenEarnersAndRates() public view returns (uint256, uint256) {
        return (earners.length, ratesEarning.length);
    }
}

ABI-encoded Constructor Arguments (if required by the contract)

New Vyper Smart Contract Verification