pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract ReentrancyGuard { uint256 private guardCounter = 1; modifier nonReentrant() { guardCounter += 1; uint256 localCounter = guardCounter; _; require(localCounter == guardCounter); } } interface ERC165 { function supportsInterface(bytes4 _interfaceId) external view returns (bool); } contract ERC721Receiver { bytes4 internal constant ERC721_RECEIVED = 0x150b7a02; function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) public returns(bytes4); } library AddressUtils { function isContract(address addr) internal view returns (bool) { uint256 size; assembly { size := extcodesize(addr) } return size > 0; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract SupportsInterfaceWithLookup is ERC165 { bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7; mapping(bytes4 => bool) internal supportedInterfaces; constructor() public {_registerInterface(InterfaceId_ERC165);} function supportsInterface(bytes4 _interfaceId) external view returns (bool) {return supportedInterfaces[_interfaceId]; } function _registerInterface(bytes4 _interfaceId) internal { require(_interfaceId != 0xffffffff); supportedInterfaces[_interfaceId] = true; } } contract ERC721Basic is ERC165 { 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) public view returns (uint256 _balance); function ownerOf(uint256 _tokenId) public view returns (address _owner); function exists(uint256 _tokenId) public view returns (bool _exists); function approve(address _to, uint256 _tokenId) public; function getApproved(uint256 _tokenId) public view returns (address _operator); function setApprovalForAll(address _operator, bool _approved) public; function isApprovedForAll(address _owner, address _operator) public view returns (bool); function transferFrom(address _from, address _to, uint256 _tokenId) public; function safeTransferFrom(address _from, address _to, uint256 _tokenId) public; function safeTransferFrom( address _from, address _to, uint256 _tokenId, bytes _data) public; } contract ERC721Enumerable is ERC721Basic { function totalSupply() public view returns (uint256); function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256 _tokenId); function tokenByIndex(uint256 _index) public view returns (uint256); } contract ERC721Metadata is ERC721Basic { function name() external view returns (string _name); function symbol() external view returns (string _symbol); function tokenURI(uint256 _tokenId) public view returns (string); } contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {} contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic { bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd; bytes4 private constant InterfaceId_ERC721Exists = 0x4f558e79; using SafeMath for uint256; using AddressUtils for address; bytes4 private constant ERC721_RECEIVED = 0x150b7a02; mapping (uint256 => address) internal tokenOwner; mapping (uint256 => address) internal tokenApprovals; mapping (address => uint256) internal ownedTokensCount; mapping (address => mapping (address => bool)) internal operatorApprovals; modifier onlyOwnerOf(uint256 _tokenId) { require(ownerOf(_tokenId) == msg.sender); _; } modifier canTransfer(uint256 _tokenId) { require(isApprovedOrOwner(msg.sender, _tokenId)); _; } constructor() public { _registerInterface(InterfaceId_ERC721); _registerInterface(InterfaceId_ERC721Exists); } function balanceOf(address _owner) public view returns (uint256) { require(_owner != address(0)); return ownedTokensCount[_owner]; } function ownerOf(uint256 _tokenId) public view returns (address) { address owner = tokenOwner[_tokenId]; require(owner != address(0)); return owner; } function exists(uint256 _tokenId) public view returns (bool) { address owner = tokenOwner[_tokenId]; return owner != address(0); } function approve(address _to, uint256 _tokenId) public { address owner = ownerOf(_tokenId); require(_to != owner); require(msg.sender == owner || isApprovedForAll(owner, msg.sender)); tokenApprovals[_tokenId] = _to; emit Approval(owner, _to, _tokenId); } function getApproved(uint256 _tokenId) public view returns (address) { return tokenApprovals[_tokenId]; } function setApprovalForAll(address _to, bool _approved) public { require(_to != msg.sender); operatorApprovals[msg.sender][_to] = _approved; emit ApprovalForAll(msg.sender, _to, _approved); } function isApprovedForAll(address _owner, address _operator) public view returns (bool) {return operatorApprovals[_owner][_operator]; } function transferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) { require(_from != address(0)); require(_to != address(0)); clearApproval(_from, _tokenId); removeTokenFrom(_from, _tokenId); addTokenTo(_to, _tokenId); emit Transfer(_from, _to, _tokenId); } function safeTransferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) { safeTransferFrom(_from, _to, _tokenId, ""); } function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public canTransfer(_tokenId) { transferFrom(_from, _to, _tokenId); require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data)); } function isApprovedOrOwner(address _spender, uint256 _tokenId) internal view returns (bool) { address owner = ownerOf(_tokenId); return ( _spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender) ); } function _mint(address _to, uint256 _tokenId) internal { require(_to != address(0)); addTokenTo(_to, _tokenId); emit Transfer(address(0), _to, _tokenId); } function _burn(address _owner, uint256 _tokenId) internal { clearApproval(_owner, _tokenId); removeTokenFrom(_owner, _tokenId); emit Transfer(_owner, address(0), _tokenId); } function clearApproval(address _owner, uint256 _tokenId) internal { require(ownerOf(_tokenId) == _owner); if (tokenApprovals[_tokenId] != address(0)) { tokenApprovals[_tokenId] = address(0); } } function addTokenTo(address _to, uint256 _tokenId) internal { require(tokenOwner[_tokenId] == address(0)); tokenOwner[_tokenId] = _to; ownedTokensCount[_to] = ownedTokensCount[_to].add(1); } function removeTokenFrom(address _from, uint256 _tokenId) internal { require(ownerOf(_tokenId) == _from); ownedTokensCount[_from] = ownedTokensCount[_from].sub(1); tokenOwner[_tokenId] = address(0); } function checkAndCallSafeTransfer(address _from, address _to, uint256 _tokenId, bytes _data) internal returns (bool) { if (!_to.isContract()) {return true; } bytes4 retval = ERC721Receiver(_to).onERC721Received( msg.sender, _from, _tokenId, _data); return (retval == ERC721_RECEIVED); } } contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 { bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63; bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f; string internal name_; string internal symbol_; mapping(address => uint256[]) internal ownedTokens; mapping(uint256 => uint256) internal ownedTokensIndex; uint256[] internal allTokens; mapping(uint256 => uint256) internal allTokensIndex; mapping(uint256 => string) internal tokenURIs; constructor(string _name, string _symbol) public { name_ = _name; symbol_ = _symbol; _registerInterface(InterfaceId_ERC721Enumerable); _registerInterface(InterfaceId_ERC721Metadata); } function name() external view returns (string) {return name_;} function symbol() external view returns (string) {return symbol_;} function tokenURI(uint256 _tokenId) public view returns (string) { require(exists(_tokenId)); return tokenURIs[_tokenId]; } function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) { require(_index < balanceOf(_owner)); return ownedTokens[_owner][_index]; } function totalSupply() public view returns (uint256) { return allTokens.length; } function tokenByIndex(uint256 _index) public view returns (uint256) { require(_index < totalSupply()); return allTokens[_index]; } function _setTokenURI(uint256 _tokenId, string _uri) internal { require(exists(_tokenId)); tokenURIs[_tokenId] = _uri; } function addTokenTo(address _to, uint256 _tokenId) internal { super.addTokenTo(_to, _tokenId); uint256 length = ownedTokens[_to].length; ownedTokens[_to].push(_tokenId); ownedTokensIndex[_tokenId] = length; } function removeTokenFrom(address _from, uint256 _tokenId) internal { super.removeTokenFrom(_from, _tokenId); uint256 tokenIndex = ownedTokensIndex[_tokenId]; uint256 lastTokenIndex = ownedTokens[_from].length.sub(1); uint256 lastToken = ownedTokens[_from][lastTokenIndex]; ownedTokens[_from][tokenIndex] = lastToken; ownedTokens[_from][lastTokenIndex] = 0; ownedTokens[_from].length--; ownedTokensIndex[_tokenId] = 0; ownedTokensIndex[lastToken] = tokenIndex; } function _mint(address _to, uint256 _tokenId) internal { super._mint(_to, _tokenId); allTokensIndex[_tokenId] = allTokens.length; allTokens.push(_tokenId); } function _burn(address _owner, uint256 _tokenId) internal { super._burn(_owner, _tokenId); if (bytes(tokenURIs[_tokenId]).length != 0) { delete tokenURIs[_tokenId]; } uint256 tokenIndex = allTokensIndex[_tokenId]; uint256 lastTokenIndex = allTokens.length.sub(1); uint256 lastToken = allTokens[lastTokenIndex]; allTokens[tokenIndex] = lastToken; allTokens[lastTokenIndex] = 0; allTokens.length--; allTokensIndex[_tokenId] = 0; allTokensIndex[lastToken] = tokenIndex; } } contract MutantMonsters is ERC721Token, Ownable { constructor() ERC721Token("MutantMonsters", "MUMO") public {} // CONSTANTS address client; uint256 currentPrice = 0; // if buying directly from the contract uint256 max_supply = 1000000; // all types x tokens uint256 max_types = 10000; // all types bool rarity_on = true; // true if random level of rarity for types uint256 rarity_percent = 50; // 0 to 100% if rarity_on == true uint256 rarity_capnum = 100; // 1 to 1000 (e.g.) if rarity_on == true mapping(uint256 => uint256) tokenTypes; mapping(uint256 => string) tokenMessage; mapping(uint256 => uint256) mintPrice; mapping(uint256 => uint256) mintTimeStamp; uint256 constant text_max = 10000; // max length of the description field string default_baseurl = "https://api.blocktime.solutions/monsters/"; // Proxies struct Proxy { uint pxID; string chain_name; address proxy_contract; // a proxy contract address } uint numProxies; mapping (uint => Proxy) proxies; function newProxy(string _chain_name, address _px_contract) public returns (uint pxID, bool ok) { require(authManager(msg.sender) == true); pxID = numProxies++; proxies[pxID] = Proxy(pxID, _chain_name, _px_contract); ok = true; } function updateProxy(uint _pxID, string _chain_name, address _px_contract) public { require(authManager(msg.sender) == true); Proxy storage p = proxies[_pxID]; string storage px_name = p.chain_name; {isEmpty(_chain_name) == true ? p.chain_name = px_name : p.chain_name = _chain_name;} p.proxy_contract = _px_contract; } function getProxy(uint _pxID) public view returns (uint pxID, string name, address proxy_address) { Proxy storage p = proxies[_pxID]; pxID = p.pxID; name = p.chain_name; proxy_address = p.proxy_contract; } function nProxies() public view returns (uint nofpxs) { nofpxs = numProxies; } // Bridges struct Bridge { uint bridgedTokenID; // ID of the token in this contrtact string bridgedTo; // the chain where token was sent to string bridgedFrom; // the chain where token came from uint bridgedFromTokenID; // ID of token from originating contract bool locked; // 'true' if there is a bridged token in bridgedTo chain; returns 'false' if a token returns home } mapping (uint => Bridge) bridges; uint numBridges; function newBridge(uint tokenID, string bridgeTo, string bridgeFrom, uint bridgeFromTokenID, bool locked) public returns (uint nofBridges) { require(authManager(msg.sender) == true); require(exists(tokenID) == true); bridges[tokenID] = Bridge(tokenID, bridgeTo, bridgeFrom, bridgeFromTokenID, locked); numBridges++; nofBridges = numBridges; } function getBridge(uint tokenID) public view returns (uint bridgedTokenID, string bridgedTo, string bridgedFrom, uint bridgedFromTokenID, bool locked) { Bridge storage bg = bridges[tokenID]; bridgedTokenID = bg.bridgedTokenID; bridgedTo = bg.bridgedTo; bridgedFrom = bg.bridgedFrom; bridgedFromTokenID = bg.bridgedFromTokenID; locked = bg.locked; } function updateBridge(uint tokenID, string bridgeTo, string bridgeFrom, uint bridgeFromTokenID, bool locked) public { require(authManager(msg.sender) == true); require(exists(tokenID) == true); Bridge storage bg = bridges[tokenID]; bg.bridgedTokenID = tokenID; bg.bridgedTo = bridgeTo; bg.bridgedFrom = bridgeFrom; bg.bridgedFromTokenID = bridgeFromTokenID; bg.locked = locked; } function numberOfBridges() public view returns (uint nofBridges) { nofBridges = numBridges; } // Managers struct Manager { uint manID; address manAddr; } uint numManagers; mapping (uint => Manager) managers; function addManager(address managerAddress) public onlyOwner { uint managerID = numManagers++; managers[managerID] = Manager(managerID, managerAddress); } function getManagers(uint manID) external view returns (uint nofmanagers, uint managerID, address managerAddress) { Manager storage m = managers[manID]; nofmanagers = numManagers; managerID = m.manID; managerAddress = m.manAddr; } function editManagers(uint managerID, address newAddress) external onlyOwner returns (uint nof, uint mID, address mAddress) { managers[managerID] = Manager(managerID, newAddress); Manager storage m = managers[managerID]; nof = numManagers; mID = m.manID; mAddress = m.manAddr; } // to remove a manager, replace the address with '0x0' ("retire") function authManager(address queryAddress) internal view returns (bool auth) { auth = false; if (msg.sender == owner) {auth = true;} // owner is always authorized for (uint i = 0; i < numManagers; i++) { // is the message sender in manager list? Manager storage m = managers[i]; if (m.manAddr == queryAddress) {auth = true;} } } function authEdit(address queryAddress, uint tokenId) internal view returns (bool auth) { auth = false; if (msg.sender == ownerOf(tokenId)) {auth = true;} // token owner is authorized if (msg.sender == owner) {auth = true;} // contract owner is always authorized for (uint i = 0; i < numManagers; i++) { // is the message sender a manager? Manager storage m = managers[i]; if (m.manAddr == queryAddress) {auth = true;} } } // Bots struct Bot { uint btype; string name; bool israre; uint price; uint softcap; uint hardcap; uint nofminted; string metad; bool restrict; string baseurl; } uint numBots; mapping (uint => Bot) bots; function rareSupply(uint botID, string _name) internal view returns (uint maxsupply) { maxsupply = 0; string memory b_name = _name; string memory txthash; txthash = string(abi.encodePacked(b_name, "#", uintTostr(botID))); bytes32 randHash = get0x(txthash, botID); // 32 long hex number uint randInt1 = getRand(randHash); // 16-long int uint ratio = randInt1 / 100000000000000; // 2-digit number; assigns rarity if < rarity_percentyh if (ratio <= rarity_percent) { // gets random rare supply if that is needed string memory txthash2 = string(abi.encodePacked(b_name, "#morerandom", uintTostr(botID+1+ratio))); bytes32 randHash2 = get0x(txthash2, botID + ratio); // 32 long hex number uint randInt2 = getRand(randHash2) / (10000000000000000/rarity_capnum); // x-digit number maxsupply = randInt2; } } function manageRarity(bool new_setting, uint new_percent, uint new_capnum) public onlyOwner { rarity_on = new_setting; rarity_percent = new_percent; rarity_capnum = new_capnum; } function viewRarity() public view returns (bool rarity_is_on, uint percent, uint capnum) { rarity_is_on = rarity_on; percent = rarity_percent; capnum = rarity_capnum; } function newBot(string name) public onlyOwner returns (uint botID) { botID = numBots++; require(botID <= max_types); bool make_rare = false; uint supply = 0; if (rarity_on == true) {supply = rareSupply(botID, name);} if (supply > 0) {make_rare = true;} bots[botID] = Bot(botID, name, make_rare, currentPrice, 0, supply, 0, "{}", false, default_baseurl); } function manageBaseURL(string new_baseurl) public onlyOwner { default_baseurl = new_baseurl; } function viewBaseURL() public view returns (string base_url) { base_url = default_baseurl; } function isEmpty(string str) internal pure returns (bool isempty) { isempty = false; bytes memory tmpStr = bytes(str); if (tmpStr.length == 0) {isempty = true;} else {isempty = false;}} function updateBot(uint botID, string _name, uint _softcap, string _metad, string _baseurl) public onlyOwner { Bot storage b = bots[botID]; string storage name = b.name; uint softcap = b.softcap; string storage metad = b.metad; string storage baseurl = b.baseurl; {isEmpty(_name) == true ? b.name = name : b.name = _name;} {_softcap == 0 ? b.softcap = softcap : b.softcap = _softcap;} {isEmpty(_metad) == true ? b.metad = metad : b.metad = _metad;} {isEmpty(_baseurl) == true ? b.baseurl = baseurl : b.baseurl = _baseurl;} } function updateBotPrice(uint botID, uint _price) public onlyOwner { Bot storage b = bots[botID]; uint newprice; {if (_price == 0) {newprice = currentPrice;} else {newprice = _price;}} b.price = newprice; } function setBotHardCap(uint botID, uint _hardcap) public onlyOwner { Bot storage b = bots[botID]; require(b.hardcap == 0); b.hardcap = _hardcap; } function updateMinted(uint botID) internal { Bot storage b = bots[botID]; uint stock = b.nofminted; b.nofminted = stock +1; } function updateBotRestrict(uint botID, bool _restrict) public onlyOwner { Bot storage b = bots[botID]; b.restrict = _restrict; } function updateBotRare(uint botID, bool _rare) public onlyOwner { require(_rare == true); // can't set rarity false if it was true previously Bot storage b = bots[botID]; b.israre = _rare; } function viewBot(uint botID) public view returns (uint btype, string name, bool rare, uint price, uint softcap, uint hardcap, string metad, bool restrict, uint nofminted, string baseurl) { Bot storage b = bots[botID]; btype = b.btype; name = b.name; rare = b.israre; price = b.price; softcap = b.softcap; hardcap = b.hardcap; metad = b.metad; restrict = b.restrict; nofminted = b.nofminted; baseurl = b.baseurl; } function nBots() public view returns (uint nofbots) { nofbots = numBots-1; } function get0x(string str, uint _int) internal pure returns (bytes32 hash256) { hash256 = keccak256(abi.encodePacked(str, _int)); } function getRand(bytes32 _hash) internal pure returns (uint randint) { uint bModulus = 10 ** 16; randint = uint(_hash) % bModulus; } event BoughtToken(address indexed buyer, uint256 tokenId); function uintTostr(uint i) internal pure returns (string){ if (i == 0) return "0"; uint j = i; uint length; while (j != 0){length++;j /= 10;} bytes memory bstr = new bytes(length); uint k = length - 1; while (i != 0){bstr[k--] = byte(48 + i % 10);i /= 10;} return string(bstr); } function moreSupply(uint tokenType) internal view returns (bool moreOK) { moreOK = true; Bot storage b = bots[tokenType]; uint newsupply = b.nofminted + 1; if (tokenType > max_types) {moreOK = false;} if (b.softcap != 0 && newsupply > b.softcap) {moreOK = false;} if (b.hardcap != 0 && newsupply > b.hardcap) {moreOK = false;} if (b.restrict == true) {moreOK = false;} if (allTokens.length + 1 > max_supply) {moreOK = false;} return moreOK; } function buyToken (uint256 _type, string _description) external payable { Bot storage b = bots[_type]; uint price = b.price; require(msg.value >= price, "Payment too small"); require(_type <= nBots(), "That type can't be bought yet!"); uint256 index = allTokens.length + 1; require(moreSupply(_type) == true, "All allowed tokens have been created already!"); bytes memory _descriptionBytes = bytes(_description); require(_descriptionBytes.length <= text_max, "Description is too long"); _mint(msg.sender, index); updateMinted(_type); tokenTypes[index] = _type; tokenMessage[index] = _description; mintPrice[index] = msg.value; mintTimeStamp[index] = block.timestamp; emit BoughtToken(msg.sender, index); setURI(index); } function mintToken (uint256 _type, string _description, uint256 _price) onlyOwner external { uint256 index = allTokens.length + 1; require(_type <= nBots(), "That type can't be bought yet!"); require(moreSupply(_type) == true, "All allowed tokens have been created already!"); bytes memory _descriptionBytes = bytes(_description); require(_descriptionBytes.length <= text_max, "Description is too long"); _mint(msg.sender, index); updateMinted(_type); tokenTypes[index] = _type; tokenMessage[index] = _description; mintPrice[index] = _price; mintTimeStamp[index] = block.timestamp; emit BoughtToken(msg.sender, index); setURI(index); } function mintTokensForOwner (uint256[] _types, string _description, uint256 _price) onlyOwner external { uint256 index = allTokens.length + 1; uint256 t_index = _types.length; uint256 new_index = index + t_index; bytes memory _descriptionBytes = bytes(_description); require(_descriptionBytes.length <= text_max, "Description is too long"); for (uint it = 0; it < t_index; it++) { uint ttype = _types[it]; require(ttype <= nBots(), "That type can't be bought yet!"); require(moreSupply(ttype) == true, "All allowed tokens have been created already!"); } for (uint i = index; i < new_index; i++) { _mint(msg.sender, i); uint newtokens_n = i-index; updateMinted(_types[newtokens_n]); tokenTypes[i] = _types[newtokens_n]; tokenMessage[i] = _description; mintPrice[i] = _price; mintTimeStamp[i] = block.timestamp; emit BoughtToken(msg.sender, i); setURI(i); } } function mintTokenForClient (uint256 _type, string _description, address _client, uint256 _price) onlyOwner external { uint256 index = allTokens.length + 1; require(_type <= nBots(), "That type can't be bought yet!"); require(moreSupply(_type) == true, "All allowed tokens have been minted already!"); bytes memory _descriptionBytes = bytes(_description); require(_descriptionBytes.length <= text_max, "Description is too long"); _mint(_client, index); updateMinted(_type); tokenTypes[index] = _type; tokenMessage[index] = _description; mintPrice[index] = _price; mintTimeStamp[index] = block.timestamp; emit BoughtToken(_client, index); setURI(index); } function mintTokensForClient (uint256[] _types, string _description, address _client, uint256 _price) onlyOwner external { uint256 index = allTokens.length + 1; uint256 t_index = _types.length; uint256 new_index = index + t_index; bytes memory _descriptionBytes = bytes(_description); require(_descriptionBytes.length <= text_max, "Description is too long"); for (uint it = 0; it < t_index; it++) { uint ttype = _types[it]; require(ttype <= nBots(), "That type can't be bought yet!"); require(moreSupply(ttype) == true, "All allowed tokens have been minted already!"); } for (uint i = index; i < new_index; i++) { _mint(_client, i); uint newtokens_n = i-index; updateMinted(_types[newtokens_n]); tokenTypes[i] = _types[newtokens_n]; tokenMessage[i] = _description; mintPrice[i] = _price; mintTimeStamp[i] = block.timestamp; emit BoughtToken(_client, i); setURI(i); } } function transferOwnTokens (uint256[] _ids, address _to) external { uint256 n_tokens = _ids.length; address _from = msg.sender; require(_to != address(0)); for (uint it = 0; it < n_tokens; it++) { require(isApprovedOrOwner(msg.sender, _ids[it]));} for (uint i = 0; i < n_tokens; i++) { clearApproval(_from, _ids[i]); removeTokenFrom(_from, _ids[i]); addTokenTo(_to, _ids[i]); emit Transfer(_from, _to, _ids[i]);} } function myTokens() external view returns (uint256[]) { return ownedTokens[msg.sender]; } function viewToken(uint256 _tokenId) external view returns (uint256 tokenType, string name, string tokenText, uint256 tokenPrice, uint256 tokenTimeStamp, uint256 tokenID, string tokenURI, bytes32 tokenHash, uint tokenRand, address tokenOwner) { tokenType = tokenTypes[_tokenId]; Bot storage b = bots[tokenType]; name = b.name; tokenType = tokenTypes[_tokenId]; tokenText = tokenMessage[_tokenId]; tokenPrice = mintPrice[_tokenId]; tokenTimeStamp = mintTimeStamp[_tokenId]; tokenID = _tokenId; tokenURI = tokenURIs[tokenID]; tokenHash = get0x(tokenText, _tokenId); // 32 long hex number tokenRand = getRand(tokenHash); // 16-long int tokenOwner = ownerOf(_tokenId); } function getTokenType(uint256 _tokenId) internal view returns (uint256 tokenType) { tokenType = tokenTypes[_tokenId]; } function getURI(uint _tokenId) public view returns (string tokenURI) { uint tokenType = getTokenType(_tokenId); Bot storage b = bots[tokenType]; string storage baseu = b.baseurl; tokenURI = string(abi.encodePacked(baseu, uintTostr(_tokenId))); } function setURI(uint _tokenId) internal { _setTokenURI(_tokenId, getURI(_tokenId)); } function manualURI(uint _tokenId, string uri) public { require(authManager(msg.sender) == true); string memory seturi; bytes memory tempEmptyStringTest = bytes(uri); if (tempEmptyStringTest.length == 0) {seturi = getURI(_tokenId);} else {seturi = string(uri);} _setTokenURI(_tokenId, seturi); } function setCurrentPrice(uint256 newPrice) public onlyOwner { currentPrice = newPrice; } function getCurrentPrice() external view returns (uint256 price) { price = currentPrice; } function updateMintPrice(uint _tokenId, uint _pricePaid) public { require(authEdit(msg.sender, _tokenId) == true); mintPrice[_tokenId] = _pricePaid; } function checkBalance() external onlyOwner view returns (uint256 contractBalance) { contractBalance = address(this).balance; } function withdrawBalance() external onlyOwner { owner.transfer(address(this).balance); } function kill(uint _PIN) public { require(_PIN == 428874); if(msg.sender == owner) selfdestruct(owner); } }
0.4.24