NFT
Collectibles
Overview
TokenID
4011
Total Transfers
-
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
PepeBase
Compiler Version
v0.4.25+commit.59dbf8f1
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2018-10-09 */ pragma solidity ^0.4.24; // File: contracts/Genetic.sol // solhint-disable-next-line pragma solidity ^0.4.23; contract Genetic { // TODO mutations // maximum number of random mutations per chromatid uint8 public constant R = 5; // solhint-disable-next-line function-max-lines function breed(uint256[2] mother, uint256[2] father, uint256 seed) internal view returns (uint256[2] memOffset) { // Meiosis I: recombining alleles (Chromosomal crossovers) // Note about optimization I: no cell duplication, // producing 2 seeds/eggs per cell is enough, instead of 4 (like humans do) // Note about optimization II: crossovers happen, // but only 1 side of the result is computed, // as the other side will not affect anything. // solhint-disable-next-line no-inline-assembly assembly { // allocate output // 1) get the pointer to our memory memOffset := mload(0x40) // 2) Change the free-memory pointer to keep our memory // (we will only use 64 bytes: 2 values of 256 bits) mstore(0x40, add(memOffset, 64)) // Put seed in scratchpad 0 mstore(0x0, seed) // Also use the timestamp, best we could do to increase randomness // without increasing costs dramatically. (Trade-off) mstore(0x20, timestamp) // Hash it for a universally random bitstring. let hash := keccak256(0, 64) // Byzantium VM does not support shift opcodes, will be introduced in Constantinople. // Soldity itself, in non-assembly, also just uses other opcodes to simulate it. // Optmizer should take care of inlining, just declare shiftR ourselves here. // Where possible, better optimization is applied to make it cheaper. function shiftR(value, offset) -> result { result := div(value, exp(2, offset)) } // solhint-disable max-line-length // m_context << Instruction::SWAP1 << u256(2) << Instruction::EXP << Instruction::SWAP1 << (c_leftSigned ? Instruction::SDIV : Instruction::DIV); // optimization: although one side consists of multiple chromatids, // we handle them just as one long chromatid: // only difference is that a crossover in chromatid i affects chromatid i+1. // No big deal, order and location is random anyway function processSide(fatherSrc, motherSrc, rngSrc) -> result { { // initial rngSrc bit length: 254 bits // Run the crossovers // ===================================================== // Pick some crossovers // Each crossover is spaced ~64 bits on average. // To achieve this, we get a random 7 bit number, [0, 128), for each crossover. // 256 / 64 = 4, we need 4 crossovers, // and will have 256 / 127 = 2 at least (rounded down). // Get one bit determining if we should pick DNA from the father, // or from the mother. // This changes every crossover. (by swapping father and mother) { if eq(and(rngSrc, 0x1), 0) { // Swap mother and father, // create a temporary variable (code golf XOR swap costs more in gas) let temp := fatherSrc fatherSrc := motherSrc motherSrc := temp } // remove the bit from rng source, 253 rng bits left rngSrc := shiftR(rngSrc, 1) } // Don't push/pop this all the time, we have just enough space on stack. let mask := 0 // Cap at 4 crossovers, no more than that. let cap := 0 let crossoverLen := and(rngSrc, 0x7f) // bin: 1111111 (7 bits ON) // remove bits from hash, e.g. 254 - 7 = 247 left. rngSrc := shiftR(rngSrc, 7) let crossoverPos := crossoverLen // optimization: instead of shifting with an opcode we don't have until Constantinople, // keep track of the a shifted number, updated using multiplications. let crossoverPosLeading1 := 1 // solhint-disable-next-line no-empty-blocks for { } and(lt(crossoverPos, 256), lt(cap, 4)) { crossoverLen := and(rngSrc, 0x7f) // bin: 1111111 (7 bits ON) // remove bits from hash, e.g. 254 - 7 = 247 left. rngSrc := shiftR(rngSrc, 7) crossoverPos := add(crossoverPos, crossoverLen) cap := add(cap, 1) } { // Note: we go from right to left in the bit-string. // Create a mask for this crossover. // Example: // 00000000000001111111111111111110000000000000000000000000000000000000000000000000000000000..... // |Prev. data ||Crossover here ||remaining data ....... // // The crossover part is copied from the mother/father to the child. // Create the bit-mask // Create a bitstring that ignores the previous data: // 00000000000001111111111111111111111111111111111111111111111111111111111111111111111111111..... // First create a leading 1, just before the crossover, like: // 00000000000010000000000000000000000000000000000000000000000000000000000..... // Then substract 1, to get a long string of 1s // 00000000000001111111111111111111111111111111111111111111111111111111111111111111111111111..... // Now do the same for the remain part, and xor it. // leading 1 // 00000000000000000000000000000010000000000000000000000000000000000000000000000000000000000..... // sub 1 // 00000000000000000000000000000001111111111111111111111111111111111111111111111111111111111..... // xor with other // 00000000000001111111111111111111111111111111111111111111111111111111111111111111111111111..... // 00000000000000000000000000000001111111111111111111111111111111111111111111111111111111111..... // 00000000000001111111111111111110000000000000000000000000000000000000000000000000000000000..... // Use the final shifted 1 of the previous crossover as the start marker mask := sub(crossoverPosLeading1, 1) // update for this crossover, (and will be used as start for next crossover) crossoverPosLeading1 := mul(1, exp(2, crossoverPos)) mask := xor(mask, sub(crossoverPosLeading1, 1) ) // Now add the parent data to the child genotype // E.g. // Mask: 00000000000001111111111111111110000000000000000000000000000000000000000000000000000000000.... // Parent: 10010111001000110101011111001010001011100000000000010011000001000100000001011101111000111.... // Child (pre): 00000000000000000000000000000001111110100101111111000011001010000000101010100000110110110.... // Child (post): 00000000000000110101011111001011111110100101111111000011001010000000101010100000110110110.... // To do this, we run: child_post = child_pre | (mask & father) result := or(result, and(mask, fatherSrc)) // Swap father and mother, next crossover will take a string from the other. let temp := fatherSrc fatherSrc := motherSrc motherSrc := temp } // We still have a left-over part that was not copied yet // E.g., we have something like: // Father: | xxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxx .... // Mother: |############ xxxxxxxxxx xxxxxxxxxxxx.... // Child: | xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.... // The ############ still needs to be applied to the child, also, // this can be done cheaper than in the loop above, // as we don't have to swap anything for the next crossover or something. // At this point we have to assume 4 crossovers ran, // and that we only have 127 - 1 - (4 * 7) = 98 bits of randomness left. // We stopped at the bit after the crossoverPos index, see "x": // 000000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx..... // now create a leading 1 at crossoverPos like: // 000000001000000000000000000000000000000000000000000000000000000000000000000..... // Sub 1, get the mask for what we had. // 000000000111111111111111111111111111111111111111111111111111111111111111111..... // Invert, and we have the final mask: // 111111111000000000000000000000000000000000000000000000000000000000000000000..... mask := not(sub(crossoverPosLeading1, 1)) // Apply it to the result result := or(result, and(mask, fatherSrc)) // Random mutations // ===================================================== // random mutations // Put rng source in scratchpad 0 mstore(0x0, rngSrc) // And some arbitrary padding in scratchpad 1, // used to create different hashes based on input size changes mstore(0x20, 0x434f4c4c454354205045504553204f4e2043525950544f50455045532e494f21) // Hash it for a universally random bitstring. // Then reduce the number of 1s by AND-ing it with other *different* hashes. // Each bit in mutations has a probability of 0.5^5 = 0.03125 = 3.125% to be a 1 let mutations := and( and( and(keccak256(0, 32), keccak256(1, 33)), and(keccak256(2, 34), keccak256(3, 35)) ), keccak256(0, 36) ) result := xor(result, mutations) } } { // Get 1 bit of pseudo randomness that will // determine if side #1 will come from the left, or right side. // Either 0 or 1, shift it by 5 bits to get either 0x0 or 0x20, cheaper later on. let relativeFatherSideLoc := mul(and(hash, 0x1), 0x20) // shift by 5 bits = mul by 2^5=32 (0x20) // Either 0 or 1, shift it by 5 bits to get either 0x0 or 0x20, cheaper later on. let relativeMotherSideLoc := mul(and(hash, 0x2), 0x10) // already shifted by 1, mul by 2^4=16 (0x10) // Now remove the used 2 bits from the hash, 254 bits remaining now. hash := div(hash, 4) // Process the side, load the relevant parent data that will be used. mstore(memOffset, processSide( mload(add(father, relativeFatherSideLoc)), mload(add(mother, relativeMotherSideLoc)), hash )) // The other side will be the opposite index: 1 -> 0, 0 -> 1 // Apply it to the location, // which is either 0x20 (For index 1) or 0x0 for index 0. relativeFatherSideLoc := xor(relativeFatherSideLoc, 0x20) relativeMotherSideLoc := xor(relativeMotherSideLoc, 0x20) mstore(0x0, seed) // Second argument will be inverse, // resulting in a different second hash. mstore(0x20, not(timestamp)) // Now create another hash, for the other side hash := keccak256(0, 64) // Process the other side mstore(add(memOffset, 0x20), processSide( mload(add(father, relativeFatherSideLoc)), mload(add(mother, relativeMotherSideLoc)), hash )) } } // Sample input: // ["0xAAABBBBBBBBCCCCCCCCAAAAAAAAABBBBBBBBBBCCCCCCCCCAABBBBBBBCCCCCCCC","0x4444444455555555555555556666666666666644444444455555555555666666"] // // ["0x1111111111112222222223333311111111122222223333333331111112222222","0x7777788888888888999999999999977777777777788888888888999999997777"] // Expected results (or similar, depends on the seed): // 0xAAABBBBBBBBCCCCCCCCAAAAAAAAABBBBBBBBBBCCCCCCCCCAABBBBBBBCCCCCCCC < Father side A // 0x4444444455555555555555556666666666666644444444455555555555666666 < Father side B // 0x1111111111112222222223333311111111122222223333333331111112222222 < Mother side A // 0x7777788888888888999999999999977777777777788888888888999999997777 < Mother side B // xxxxxxxxxxxxxxxxx xxxxxxxxx xx // 0xAAABBBBBBBBCCCCCD99999999998BBBBBBBBF77778888888888899999999774C < Child side A // xxx xxxxxxxxxxx // 0x4441111111112222222223333366666666666222223333333331111112222222 < Child side B // And then random mutations, for gene pool expansion. // Each bit is flipped with a 3.125% chance // Example: //a2c37edc61dca0ca0b199e098c80fd5a221c2ad03605b4b54332361358745042 < random hash 1 //c217d04b19a83fe497c1cf6e1e10030e455a0812a6949282feec27d67fe2baa7 < random hash 2 //2636a55f38bed26d804c63a13628e21b2d701c902ca37b2b0ca94fada3821364 < random hash 3 //86bb023a85e2da50ac233b946346a53aa070943b0a8e91c56e42ba181729a5f9 < random hash 4 //5d71456a1288ab30ddd4c955384d42e66a09d424bd7743791e3eab8e09aa13f1 < random hash 5 //0000000800800000000000000000000200000000000000000000020000000000 < resulting mutation //aaabbbbbbbbcccccd99999999998bbbbbbbbf77778888888888899999999774c < original //aaabbbb3bb3cccccd99999999998bbb9bbbbf7777888888888889b999999774c < mutated (= original XOR mutation) } // Generates (psuedo) random Pepe DNA function randomDNA(uint256 seed) internal pure returns (uint256[2] memOffset) { // solhint-disable-next-line no-inline-assembly assembly { // allocate output // 1) get the pointer to our memory memOffset := mload(0x40) // 2) Change the free-memory pointer to keep our memory // (we will only use 64 bytes: 2 values of 256 bits) mstore(0x40, add(memOffset, 64)) // Load the seed into 1st scratchpad memory slot. // adjacent to the additional value (used to create two distinct hashes) mstore(0x0, seed) // In second scratchpad slot: // The additional value can be any word, as long as the caller uses // it (second hash needs to be different) mstore(0x20, 0x434f4c4c454354205045504553204f4e2043525950544f50455045532e494f21) // // Create first element pointer of array // mstore(memOffset, add(memOffset, 64)) // pointer 1 // mstore(add(memOffset, 32), add(memOffset, 96)) // pointer 2 // control block to auto-pop the hash. { // L * N * 2 * 4 = 4 * 2 * 2 * 4 = 64 bytes, 2x 256 bit hash // Sha3 is cheaper than sha256, make use of it let hash := keccak256(0, 64) // Store first array value mstore(memOffset, hash) // Now hash again, but only 32 bytes of input, // to ignore make the input different than the previous call, hash := keccak256(0, 32) mstore(add(memOffset, 32), hash) } } } } // File: openzeppelin-solidity/contracts/ownership/Ownable.sol /** * @title Ownable * @dev The Ownable contract has an owner address, and provides basic authorization control * functions, this simplifies the implementation of "user permissions". */ contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); /** * @dev The Ownable constructor sets the original `owner` of the contract to the sender * account. */ constructor() public { owner = msg.sender; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(msg.sender == owner); _; } /** * @dev Allows the current owner to relinquish control of the contract. * @notice Renouncing to ownership will leave the contract without an owner. * It will not be possible to call the functions with the `onlyOwner` * modifier anymore. */ function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } /** * @dev Allows the current owner to transfer control of the contract to a newOwner. * @param _newOwner The address to transfer ownership to. */ function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } /** * @dev Transfers control of the contract to a newOwner. * @param _newOwner The address to transfer ownership to. */ function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } // File: contracts/Usernames.sol // solhint-disable-next-line pragma solidity ^0.4.19; contract Usernames { mapping(address => bytes32) public addressToUser; mapping(bytes32 => address) public userToAddress; event UserNamed(address indexed user, bytes32 indexed username); /** * Claim a username. Frees up a previously used one * @param _username to claim */ function claimUsername(bytes32 _username) external { require(userToAddress[_username] == address(0));// Username must be free if (addressToUser[msg.sender] != bytes32(0)) { // If user already has username free it up userToAddress[addressToUser[msg.sender]] = address(0); } //all is well assign username addressToUser[msg.sender] = _username; userToAddress[_username] = msg.sender; emit UserNamed(msg.sender, _username); } } // File: contracts/Beneficiary.sol // solhint-disable-next-line pragma solidity ^0.4.24; /** @title Beneficiary */ contract Beneficiary is Ownable { address public beneficiary; constructor() public { beneficiary = msg.sender; } /** * @dev Change the beneficiary address * @param _beneficiary Address of the new beneficiary */ function setBeneficiary(address _beneficiary) public onlyOwner { beneficiary = _beneficiary; } } // File: contracts/Affiliate.sol // solhint-disable-next-line pragma solidity ^0.4.25; /** @title Affiliate */ contract Affiliate is Ownable { mapping(address => bool) public canSetAffiliate; mapping(address => address) public userToAffiliate; /** @dev Allows an address to set the affiliate address for a user * @param _setter The address that should be allowed */ function setAffiliateSetter(address _setter) public onlyOwner { canSetAffiliate[_setter] = true; } /** * @dev Set the affiliate of a user * @param _user user to set affiliate for * @param _affiliate address to set */ function setAffiliate(address _user, address _affiliate) public { require(canSetAffiliate[msg.sender]); if (userToAffiliate[_user] == address(0)) { userToAffiliate[_user] = _affiliate; } } } // File: contracts/interfaces/ERC721.sol contract ERC721 { function implementsERC721() public pure returns (bool); function totalSupply() public view returns (uint256 total); function balanceOf(address _owner) public view returns (uint256 balance); function ownerOf(uint256 _tokenId) public view returns (address owner); function approve(address _to, uint256 _tokenId) public; function transferFrom(address _from, address _to, uint256 _tokenId) public returns (bool) ; function transfer(address _to, uint256 _tokenId) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); // Optional // function name() public view returns (string name); // function symbol() public view returns (string symbol); // function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256 tokenId); // function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl); } // File: contracts/interfaces/PepeInterface.sol contract PepeInterface is ERC721{ function cozyTime(uint256 _mother, uint256 _father, address _pepeReceiver) public returns (bool); function getCozyAgain(uint256 _pepeId) public view returns(uint64); } // File: contracts/AuctionBase.sol // solhint-disable-next-line pragma solidity ^0.4.24; /** @title AuctionBase */ contract AuctionBase is Beneficiary { mapping(uint256 => PepeAuction) public auctions;//maps pepes to auctions PepeInterface public pepeContract; Affiliate public affiliateContract; uint256 public fee = 37500; //in 1 10000th of a percent so 3.75% at the start uint256 public constant FEE_DIVIDER = 1000000; //Perhaps needs better name? struct PepeAuction { address seller; uint256 pepeId; uint64 auctionBegin; uint64 auctionEnd; uint256 beginPrice; uint256 endPrice; } event AuctionWon(uint256 indexed pepe, address indexed winner, address indexed seller); event AuctionStarted(uint256 indexed pepe, address indexed seller); event AuctionFinalized(uint256 indexed pepe, address indexed seller); constructor(address _pepeContract, address _affiliateContract) public { pepeContract = PepeInterface(_pepeContract); affiliateContract = Affiliate(_affiliateContract); } /** * @dev Return a pepe from a auction that has passed * @param _pepeId the id of the pepe to save */ function savePepe(uint256 _pepeId) external { // solhint-disable-next-line not-rely-on-time require(auctions[_pepeId].auctionEnd < now);//auction must have ended require(pepeContract.transfer(auctions[_pepeId].seller, _pepeId));//transfer pepe back to seller emit AuctionFinalized(_pepeId, auctions[_pepeId].seller); delete auctions[_pepeId];//delete auction } /** * @dev change the fee on pepe sales. Can only be lowerred * @param _fee The new fee to set. Must be lower than current fee */ function changeFee(uint256 _fee) external onlyOwner { require(_fee < fee);//fee can not be raised fee = _fee; } /** * @dev Start a auction * @param _pepeId Pepe to sell * @param _beginPrice Price at which the auction starts * @param _endPrice Ending price of the auction * @param _duration How long the auction should take */ function startAuction(uint256 _pepeId, uint256 _beginPrice, uint256 _endPrice, uint64 _duration) public { require(pepeContract.transferFrom(msg.sender, address(this), _pepeId)); // solhint-disable-next-line not-rely-on-time require(now > auctions[_pepeId].auctionEnd);//can only start new auction if no other is active PepeAuction memory auction; auction.seller = msg.sender; auction.pepeId = _pepeId; // solhint-disable-next-line not-rely-on-time auction.auctionBegin = uint64(now); // solhint-disable-next-line not-rely-on-time auction.auctionEnd = uint64(now) + _duration; require(auction.auctionEnd > auction.auctionBegin); auction.beginPrice = _beginPrice; auction.endPrice = _endPrice; auctions[_pepeId] = auction; emit AuctionStarted(_pepeId, msg.sender); } /** * @dev directly start a auction from the PepeBase contract * @param _pepeId Pepe to put on auction * @param _beginPrice Price at which the auction starts * @param _endPrice Ending price of the auction * @param _duration How long the auction should take * @param _seller The address selling the pepe */ // solhint-disable-next-line max-line-length function startAuctionDirect(uint256 _pepeId, uint256 _beginPrice, uint256 _endPrice, uint64 _duration, address _seller) public { require(msg.sender == address(pepeContract)); //can only be called by pepeContract //solhint-disable-next-line not-rely-on-time require(now > auctions[_pepeId].auctionEnd);//can only start new auction if no other is active PepeAuction memory auction; auction.seller = _seller; auction.pepeId = _pepeId; // solhint-disable-next-line not-rely-on-time auction.auctionBegin = uint64(now); // solhint-disable-next-line not-rely-on-time auction.auctionEnd = uint64(now) + _duration; require(auction.auctionEnd > auction.auctionBegin); auction.beginPrice = _beginPrice; auction.endPrice = _endPrice; auctions[_pepeId] = auction; emit AuctionStarted(_pepeId, _seller); } /** * @dev Calculate the current price of a auction * @param _pepeId the pepeID to calculate the current price for * @return currentBid the current price for the auction */ function calculateBid(uint256 _pepeId) public view returns(uint256 currentBid) { PepeAuction storage auction = auctions[_pepeId]; // solhint-disable-next-line not-rely-on-time uint256 timePassed = now - auctions[_pepeId].auctionBegin; // If auction ended return auction end price. // solhint-disable-next-line not-rely-on-time if (now >= auction.auctionEnd) { return auction.endPrice; } else { // Can be negative int256 priceDifference = int256(auction.endPrice) - int256(auction.beginPrice); // Always positive int256 duration = int256(auction.auctionEnd) - int256(auction.auctionBegin); // As already proven in practice by CryptoKitties: // timePassed -> 64 bits at most // priceDifference -> 128 bits at most // timePassed * priceDifference -> 64 + 128 bits at most int256 priceChange = priceDifference * int256(timePassed) / duration; // Will be positive, both operands are less than 256 bits int256 price = int256(auction.beginPrice) + priceChange; return uint256(price); } } /** * @dev collect the fees from the auction */ function getFees() public { beneficiary.transfer(address(this).balance); } } // File: contracts/CozyTimeAuction.sol // solhint-disable-next-line pragma solidity ^0.4.24; /** @title CozyTimeAuction */ contract CozyTimeAuction is AuctionBase { // solhint-disable-next-line constructor (address _pepeContract, address _affiliateContract) AuctionBase(_pepeContract, _affiliateContract) public { } /** * @dev Start an auction * @param _pepeId The id of the pepe to start the auction for * @param _beginPrice Start price of the auction * @param _endPrice End price of the auction * @param _duration How long the auction should take */ function startAuction(uint256 _pepeId, uint256 _beginPrice, uint256 _endPrice, uint64 _duration) public { // solhint-disable-next-line not-rely-on-time require(pepeContract.getCozyAgain(_pepeId) <= now);//need to have this extra check super.startAuction(_pepeId, _beginPrice, _endPrice, _duration); } /** * @dev Start a auction direclty from the PepeBase smartcontract * @param _pepeId The id of the pepe to start the auction for * @param _beginPrice Start price of the auction * @param _endPrice End price of the auction * @param _duration How long the auction should take * @param _seller The address of the seller */ // solhint-disable-next-line max-line-length function startAuctionDirect(uint256 _pepeId, uint256 _beginPrice, uint256 _endPrice, uint64 _duration, address _seller) public { // solhint-disable-next-line not-rely-on-time require(pepeContract.getCozyAgain(_pepeId) <= now);//need to have this extra check super.startAuctionDirect(_pepeId, _beginPrice, _endPrice, _duration, _seller); } /** * @dev Buy cozy right from the auction * @param _pepeId Pepe to cozy with * @param _cozyCandidate the pepe to cozy with * @param _candidateAsFather Is the _cozyCandidate father? * @param _pepeReceiver address receiving the pepe after cozy time */ // solhint-disable-next-line max-line-length function buyCozy(uint256 _pepeId, uint256 _cozyCandidate, bool _candidateAsFather, address _pepeReceiver) public payable { require(address(pepeContract) == msg.sender); //caller needs to be the PepeBase contract PepeAuction storage auction = auctions[_pepeId]; // solhint-disable-next-line not-rely-on-time require(now < auction.auctionEnd);// auction must be still going uint256 price = calculateBid(_pepeId); require(msg.value >= price);//must send enough ether uint256 totalFee = price * fee / FEE_DIVIDER; //safe math needed? //Send ETH to seller auction.seller.transfer(price - totalFee); //send ETH to beneficiary address affiliate = affiliateContract.userToAffiliate(_pepeReceiver); //solhint-disable-next-line if (affiliate != address(0) && affiliate.send(totalFee / 2)) { //if user has affiliate //nothing just to suppress warning } //actual cozytiming if (_candidateAsFather) { if (!pepeContract.cozyTime(auction.pepeId, _cozyCandidate, _pepeReceiver)) { revert(); } } else { // Swap around the two pepes, they have no set gender, the user decides what they are. if (!pepeContract.cozyTime(_cozyCandidate, auction.pepeId, _pepeReceiver)) { revert(); } } //Send pepe to seller of auction if (!pepeContract.transfer(auction.seller, _pepeId)) { revert(); //can't complete transfer if this fails } if (msg.value > price) { //return ether send to much _pepeReceiver.transfer(msg.value - price); } emit AuctionWon(_pepeId, _pepeReceiver, auction.seller);//emit event delete auctions[_pepeId];//deletes auction } /** * @dev Buy cozytime and pass along affiliate * @param _pepeId Pepe to cozy with * @param _cozyCandidate the pepe to cozy with * @param _candidateAsFather Is the _cozyCandidate father? * @param _pepeReceiver address receiving the pepe after cozy time * @param _affiliate Affiliate address to set */ //solhint-disable-next-line max-line-length function buyCozyAffiliated(uint256 _pepeId, uint256 _cozyCandidate, bool _candidateAsFather, address _pepeReceiver, address _affiliate) public payable { affiliateContract.setAffiliate(_pepeReceiver, _affiliate); buyCozy(_pepeId, _cozyCandidate, _candidateAsFather, _pepeReceiver); } } // File: contracts/Haltable.sol // solhint-disable-next-line pragma solidity ^0.4.24; contract Haltable is Ownable { uint256 public haltTime; //when the contract was halted bool public halted;//is the contract halted? uint256 public haltDuration; uint256 public maxHaltDuration = 8 weeks;//how long the contract can be halted modifier stopWhenHalted { require(!halted); _; } modifier onlyWhenHalted { require(halted); _; } /** * @dev Halt the contract for a set time smaller than maxHaltDuration * @param _duration Duration how long the contract should be halted. Must be smaller than maxHaltDuration */ function halt(uint256 _duration) public onlyOwner { require(haltTime == 0); //cannot halt if it was halted before require(_duration <= maxHaltDuration);//cannot halt for longer than maxHaltDuration haltDuration = _duration; halted = true; // solhint-disable-next-line not-rely-on-time haltTime = now; } /** * @dev Unhalt the contract. Can only be called by the owner or when the haltTime has passed */ function unhalt() public { // solhint-disable-next-line require(now > haltTime + haltDuration || msg.sender == owner);//unhalting is only possible when haltTime has passed or the owner unhalts halted = false; } } // File: openzeppelin-solidity/contracts/math/SafeMath.sol /** * @title SafeMath * @dev Math operations with safety checks that throw on error */ library SafeMath { /** * @dev Multiplies two numbers, throws on overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { // Gas optimization: this is cheaper than asserting 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } /** * @dev Integer division of two numbers, truncating the quotient. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 // uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return a / b; } /** * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } /** * @dev Adds two numbers, throws on overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } // File: contracts/interfaces/ERC721TokenReceiver.sol /// @dev Note: the ERC-165 identifier for this interface is 0xf0b9e5ba interface ERC721TokenReceiver { /// @notice Handle the receipt of an NFT /// @dev The ERC721 smart contract calls this function on the recipient /// after a `transfer`. This function MAY throw to revert and reject the /// transfer. This function MUST use 50,000 gas or less. Return of other /// than the magic value MUST result in the transaction being reverted. /// Note: the contract address is always the message sender. /// @param _from The sending address /// @param _tokenId The NFT identifier which is being transfered /// @param data Additional data with no specified format /// @return `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))` /// unless throwing function onERC721Received(address _from, uint256 _tokenId, bytes data) external returns(bytes4); } // File: contracts/PepeBase.sol // solhint-disable-next-line pragma solidity ^0.4.24; // solhint-disable func-order contract PepeBase is Genetic, Ownable, Usernames, Haltable { uint32[15] public cozyCoolDowns = [ //determined by generation / 2 uint32(1 minutes), uint32(2 minutes), uint32(5 minutes), uint32(15 minutes), uint32(30 minutes), uint32(45 minutes), uint32(1 hours), uint32(2 hours), uint32(4 hours), uint32(8 hours), uint32(16 hours), uint32(1 days), uint32(2 days), uint32(4 days), uint32(7 days) ]; struct Pepe { address master; //The master of the pepe uint256[2] genotype; //all genes stored here uint64 canCozyAgain; //time when pepe can have nice time again uint64 generation; //what generation? uint64 father; //father of this pepe uint64 mother; //mommy of this pepe uint8 coolDownIndex; } mapping(uint256 => bytes32) public pepeNames; //stores all pepes Pepe[] public pepes; bool public implementsERC721 = true; //signal erc721 support // solhint-disable-next-line const-name-snakecase string public constant name = "Crypto Pepe"; // solhint-disable-next-line const-name-snakecase string public constant symbol = "CPEP"; mapping(address => uint256[]) private wallets; mapping(address => uint256) public balances; //amounts of pepes per address mapping(uint256 => address) public approved; //pepe index to address approved to transfer mapping(address => mapping(address => bool)) public approvedForAll; uint256 public zeroGenPepes; //how many zero gen pepes are mined uint256 public constant MAX_PREMINE = 100;//how many pepes can be premined uint256 public constant MAX_ZERO_GEN_PEPES = 1100; //max number of zero gen pepes address public miner; //address of the miner contract modifier onlyPepeMaster(uint256 _pepeId) { require(pepes[_pepeId].master == msg.sender); _; } modifier onlyAllowed(uint256 _tokenId) { // solhint-disable-next-line max-line-length require(msg.sender == pepes[_tokenId].master || msg.sender == approved[_tokenId] || approvedForAll[pepes[_tokenId].master][msg.sender]); //check if msg.sender is allowed _; } event PepeBorn(uint256 indexed mother, uint256 indexed father, uint256 indexed pepeId); event PepeNamed(uint256 indexed pepeId); constructor() public { Pepe memory pepe0 = Pepe({ master: 0x0, genotype: [uint256(0), uint256(0)], canCozyAgain: 0, father: 0, mother: 0, generation: 0, coolDownIndex: 0 }); pepes.push(pepe0); } /** * @dev Internal function that creates a new pepe * @param _genoType DNA of the new pepe * @param _mother The ID of the mother * @param _father The ID of the father * @param _generation The generation of the new Pepe * @param _master The owner of this new Pepe * @return The ID of the newly generated Pepe */ // solhint-disable-next-line max-line-length function _newPepe(uint256[2] _genoType, uint64 _mother, uint64 _father, uint64 _generation, address _master) internal returns (uint256 pepeId) { uint8 tempCoolDownIndex; tempCoolDownIndex = uint8(_generation / 2); if (_generation > 28) { tempCoolDownIndex = 14; } Pepe memory _pepe = Pepe({ master: _master, //The master of the pepe genotype: _genoType, //all genes stored here canCozyAgain: 0, //time when pepe can have nice time again father: _father, //father of this pepe mother: _mother, //mommy of this pepe generation: _generation, //what generation? coolDownIndex: tempCoolDownIndex }); if (_generation == 0) { zeroGenPepes += 1; //count zero gen pepes } //push returns the new length, use it to get a new unique id pepeId = pepes.push(_pepe) - 1; //add it to the wallet of the master of the new pepe addToWallet(_master, pepeId); emit PepeBorn(_mother, _father, pepeId); emit Transfer(address(0), _master, pepeId); return pepeId; } /** * @dev Set the miner contract. Can only be called once * @param _miner Address of the miner contract */ function setMiner(address _miner) public onlyOwner { require(miner == address(0));//can only be set once miner = _miner; } /** * @dev Mine a new Pepe. Can only be called by the miner contract. * @param _seed Seed to be used for the generation of the DNA * @param _receiver Address receiving the newly mined Pepe * @return The ID of the newly mined Pepe */ function minePepe(uint256 _seed, address _receiver) public stopWhenHalted returns(uint256) { require(msg.sender == miner);//only miner contract can call require(zeroGenPepes < MAX_ZERO_GEN_PEPES); return _newPepe(randomDNA(_seed), 0, 0, 0, _receiver); } /** * @dev Premine pepes. Can only be called by the owner and is limited to MAX_PREMINE * @param _amount Amount of Pepes to premine */ function pepePremine(uint256 _amount) public onlyOwner stopWhenHalted { for (uint i = 0; i < _amount; i++) { require(zeroGenPepes <= MAX_PREMINE);//can only generate set amount during premine //create a new pepe // 1) who's genes are based on hash of the timestamp and the number of pepes // 2) who has no mother or father // 3) who is generation zero // 4) who's master is the manager // solhint-disable-next-line _newPepe(randomDNA(uint256(keccak256(abi.encodePacked(block.timestamp, pepes.length)))), 0, 0, 0, owner); } } /** * @dev CozyTime two Pepes together * @param _mother The mother of the new Pepe * @param _father The father of the new Pepe * @param _pepeReceiver Address receiving the new Pepe * @return If it was a success */ function cozyTime(uint256 _mother, uint256 _father, address _pepeReceiver) external stopWhenHalted returns (bool) { //cannot cozyTime with itself require(_mother != _father); //caller has to either be master or approved for mother // solhint-disable-next-line max-line-length require(pepes[_mother].master == msg.sender || approved[_mother] == msg.sender || approvedForAll[pepes[_mother].master][msg.sender]); //caller has to either be master or approved for father // solhint-disable-next-line max-line-length require(pepes[_father].master == msg.sender || approved[_father] == msg.sender || approvedForAll[pepes[_father].master][msg.sender]); //require both parents to be ready for cozytime // solhint-disable-next-line not-rely-on-time require(now > pepes[_mother].canCozyAgain && now > pepes[_father].canCozyAgain); //require both mother parents not to be father require(pepes[_mother].mother != _father && pepes[_mother].father != _father); //require both father parents not to be mother require(pepes[_father].mother != _mother && pepes[_father].father != _mother); Pepe storage father = pepes[_father]; Pepe storage mother = pepes[_mother]; approved[_father] = address(0); approved[_mother] = address(0); uint256[2] memory newGenotype = breed(father.genotype, mother.genotype, pepes.length); uint64 newGeneration; newGeneration = mother.generation + 1; if (newGeneration < father.generation + 1) { //if father generation is bigger newGeneration = father.generation + 1; } _handleCoolDown(_mother); _handleCoolDown(_father); //sets pepe birth when mother is done // solhint-disable-next-line max-line-length pepes[_newPepe(newGenotype, uint64(_mother), uint64(_father), newGeneration, _pepeReceiver)].canCozyAgain = mother.canCozyAgain; //_pepeReceiver becomes the master of the pepe return true; } /** * @dev Internal function to increase the coolDownIndex * @param _pepeId The id of the Pepe to update the coolDown of */ function _handleCoolDown(uint256 _pepeId) internal { Pepe storage tempPep = pepes[_pepeId]; // solhint-disable-next-line not-rely-on-time tempPep.canCozyAgain = uint64(now + cozyCoolDowns[tempPep.coolDownIndex]); if (tempPep.coolDownIndex < 14) {// after every cozy time pepe gets slower tempPep.coolDownIndex++; } } /** * @dev Set the name of a Pepe. Can only be set once * @param _pepeId ID of the pepe to name * @param _name The name to assign */ function setPepeName(uint256 _pepeId, bytes32 _name) public stopWhenHalted onlyPepeMaster(_pepeId) returns(bool) { require(pepeNames[_pepeId] == 0x0000000000000000000000000000000000000000000000000000000000000000); pepeNames[_pepeId] = _name; emit PepeNamed(_pepeId); return true; } /** * @dev Transfer a Pepe to the auction contract and auction it * @param _pepeId ID of the Pepe to auction * @param _auction Auction contract address * @param _beginPrice Price the auction starts at * @param _endPrice Price the auction ends at * @param _duration How long the auction should run */ // solhint-disable-next-line max-line-length function transferAndAuction(uint256 _pepeId, address _auction, uint256 _beginPrice, uint256 _endPrice, uint64 _duration) public stopWhenHalted onlyPepeMaster(_pepeId) { _transfer(msg.sender, _auction, _pepeId);//transfer pepe to auction AuctionBase auction = AuctionBase(_auction); auction.startAuctionDirect(_pepeId, _beginPrice, _endPrice, _duration, msg.sender); } /** * @dev Approve and buy. Used to buy cozyTime in one call * @param _pepeId Pepe to cozy with * @param _auction Address of the auction contract * @param _cozyCandidate Pepe to approve and cozy with * @param _candidateAsFather Use the candidate as father or not */ // solhint-disable-next-line max-line-length function approveAndBuy(uint256 _pepeId, address _auction, uint256 _cozyCandidate, bool _candidateAsFather) public stopWhenHalted payable onlyPepeMaster(_cozyCandidate) { approved[_cozyCandidate] = _auction; // solhint-disable-next-line max-line-length CozyTimeAuction(_auction).buyCozy.value(msg.value)(_pepeId, _cozyCandidate, _candidateAsFather, msg.sender); //breeding resets approval } /** * @dev The same as above only pass an extra parameter * @param _pepeId Pepe to cozy with * @param _auction Address of the auction contract * @param _cozyCandidate Pepe to approve and cozy with * @param _candidateAsFather Use the candidate as father or not * @param _affiliate Address to set as affiliate */ // solhint-disable-next-line max-line-length function approveAndBuyAffiliated(uint256 _pepeId, address _auction, uint256 _cozyCandidate, bool _candidateAsFather, address _affiliate) public stopWhenHalted payable onlyPepeMaster(_cozyCandidate) { approved[_cozyCandidate] = _auction; // solhint-disable-next-line max-line-length CozyTimeAuction(_auction).buyCozyAffiliated.value(msg.value)(_pepeId, _cozyCandidate, _candidateAsFather, msg.sender, _affiliate); //breeding resets approval } /** * @dev get Pepe information * @param _pepeId ID of the Pepe to get information of * @return master * @return genotype * @return canCozyAgain * @return generation * @return father * @return mother * @return pepeName * @return coolDownIndex */ // solhint-disable-next-line max-line-length function getPepe(uint256 _pepeId) public view returns(address master, uint256[2] genotype, uint64 canCozyAgain, uint64 generation, uint256 father, uint256 mother, bytes32 pepeName, uint8 coolDownIndex) { Pepe storage tempPep = pepes[_pepeId]; master = tempPep.master; genotype = tempPep.genotype; canCozyAgain = tempPep.canCozyAgain; generation = tempPep.generation; father = tempPep.father; mother = tempPep.mother; pepeName = pepeNames[_pepeId]; coolDownIndex = tempPep.coolDownIndex; } /** * @dev Get the time when a pepe can cozy again * @param _pepeId ID of the pepe * @return Time when the pepe can cozy again */ function getCozyAgain(uint256 _pepeId) public view returns(uint64) { return pepes[_pepeId].canCozyAgain; } /** * ERC721 Compatibility * */ event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId); event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved); /** * @dev Get the total number of Pepes * @return total Returns the total number of pepes */ function totalSupply() public view returns(uint256 total) { total = pepes.length - balances[address(0)]; return total; } /** * @dev Get the number of pepes owned by an address * @param _owner Address to get the balance from * @return balance The number of pepes */ function balanceOf(address _owner) external view returns (uint256 balance) { balance = balances[_owner]; } /** * @dev Get the owner of a Pepe * @param _tokenId the token to get the owner of * @return _owner the owner of the pepe */ function ownerOf(uint256 _tokenId) external view returns (address _owner) { _owner = pepes[_tokenId].master; } /** * @dev Get the id of an token by its index * @param _owner The address to look up the tokens of * @param _index Index to look at * @return tokenId the ID of the token of the owner at the specified index */ function tokenOfOwnerByIndex(address _owner, uint256 _index) public constant returns (uint256 tokenId) { //The index must be smaller than the balance, // to guarantee that there is no leftover token returned. require(_index < balances[_owner]); return wallets[_owner][_index]; } /** * @dev Private method that ads a token to the wallet * @param _owner Address of the owner * @param _tokenId Pepe ID to add */ function addToWallet(address _owner, uint256 _tokenId) private { uint256[] storage wallet = wallets[_owner]; uint256 balance = balances[_owner]; if (balance < wallet.length) { wallet[balance] = _tokenId; } else { wallet.push(_tokenId); } //increase owner balance //overflow is not likely to happen(need very large amount of pepes) balances[_owner] += 1; } /** * @dev Remove a token from a address's wallet * @param _owner Address of the owner * @param _tokenId Token to remove from the wallet */ function removeFromWallet(address _owner, uint256 _tokenId) private { uint256[] storage wallet = wallets[_owner]; uint256 i = 0; // solhint-disable-next-line no-empty-blocks for (; wallet[i] != _tokenId; i++) { // not the pepe we are looking for } if (wallet[i] == _tokenId) { //found it! uint256 last = balances[_owner] - 1; if (last > 0) { //move the last item to this spot, the last will become inaccessible wallet[i] = wallet[last]; } //else: no last item to move, the balance is 0, making everything inaccessible. //only decrease balance if _tokenId was in the wallet balances[_owner] -= 1; } } /** * @dev Internal transfer function * @param _from Address sending the token * @param _to Address to token is send to * @param _tokenId ID of the token to send */ function _transfer(address _from, address _to, uint256 _tokenId) internal { pepes[_tokenId].master = _to; approved[_tokenId] = address(0);//reset approved of pepe on every transfer //remove the token from the _from wallet removeFromWallet(_from, _tokenId); //add the token to the _to wallet addToWallet(_to, _tokenId); emit Transfer(_from, _to, _tokenId); } /** * @dev transfer a token. Can only be called by the owner of the token * @param _to Addres to send the token to * @param _tokenId ID of the token to send */ // solhint-disable-next-line no-simple-event-func-name function transfer(address _to, uint256 _tokenId) public stopWhenHalted onlyPepeMaster(_tokenId) //check if msg.sender is the master of this pepe returns(bool) { _transfer(msg.sender, _to, _tokenId);//after master modifier invoke internal transfer return true; } /** * @dev Approve a address to send a token * @param _to Address to approve * @param _tokenId Token to set approval for */ function approve(address _to, uint256 _tokenId) external stopWhenHalted onlyPepeMaster(_tokenId) { approved[_tokenId] = _to; emit Approval(msg.sender, _to, _tokenId); } /** * @dev Approve or revoke approval an address for al tokens of a user * @param _operator Address to (un)approve * @param _approved Approving or revoking indicator */ function setApprovalForAll(address _operator, bool _approved) external stopWhenHalted { if (_approved) { approvedForAll[msg.sender][_operator] = true; } else { approvedForAll[msg.sender][_operator] = false; } emit ApprovalForAll(msg.sender, _operator, _approved); } /** * @dev Get approved address for a token * @param _tokenId Token ID to get the approved address for * @return The address that is approved for this token */ function getApproved(uint256 _tokenId) external view returns (address) { return approved[_tokenId]; } /** * @dev Get if an operator is approved for all tokens of that owner * @param _owner Owner to check the approval for * @param _operator Operator to check approval for * @return Boolean indicating if the operator is approved for that owner */ function isApprovedForAll(address _owner, address _operator) external view returns (bool) { return approvedForAll[_owner][_operator]; } /** * @dev Function to signal support for an interface * @param interfaceID the ID of the interface to check for * @return Boolean indicating support */ function supportsInterface(bytes4 interfaceID) external pure returns (bool) { if (interfaceID == 0x80ac58cd || interfaceID == 0x01ffc9a7) { //TODO: add more interfaces the contract supports return true; } return false; } /** * @dev Safe transferFrom function * @param _from Address currently owning the token * @param _to Address to send token to * @param _tokenId ID of the token to send */ function safeTransferFrom(address _from, address _to, uint256 _tokenId) external stopWhenHalted { _safeTransferFromInternal(_from, _to, _tokenId, ""); } /** * @dev Safe transferFrom function with aditional data attribute * @param _from Address currently owning the token * @param _to Address to send token to * @param _tokenId ID of the token to send * @param _data Data to pass along call */ // solhint-disable-next-line max-line-length function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) external stopWhenHalted { _safeTransferFromInternal(_from, _to, _tokenId, _data); } /** * @dev Internal Safe transferFrom function with aditional data attribute * @param _from Address currently owning the token * @param _to Address to send token to * @param _tokenId ID of the token to send * @param _data Data to pass along call */ // solhint-disable-next-line max-line-length function _safeTransferFromInternal(address _from, address _to, uint256 _tokenId, bytes _data) internal onlyAllowed(_tokenId) { require(pepes[_tokenId].master == _from);//check if from is current owner require(_to != address(0));//throw on zero address _transfer(_from, _to, _tokenId); //transfer token if (isContract(_to)) { //check if is contract // solhint-disable-next-line max-line-length require(ERC721TokenReceiver(_to).onERC721Received(_from, _tokenId, _data) == bytes4(keccak256("onERC721Received(address,uint256,bytes)"))); } } /** * @dev TransferFrom function * @param _from Address currently owning the token * @param _to Address to send token to * @param _tokenId ID of the token to send * @return If it was successful */ // solhint-disable-next-line max-line-length function transferFrom(address _from, address _to, uint256 _tokenId) public stopWhenHalted onlyAllowed(_tokenId) returns(bool) { require(pepes[_tokenId].master == _from);//check if _from is really the master. require(_to != address(0)); _transfer(_from, _to, _tokenId);//handles event, balances and approval reset; return true; } /** * @dev Utility method to check if an address is a contract * @param _address Address to check * @return Boolean indicating if the address is a contract */ function isContract(address _address) internal view returns (bool) { uint size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(_address) } return size > 0; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"constant":true,"inputs":[{"name":"interfaceID","type":"bytes4"}],"name":"supportsInterface","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"approve","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"approvedForAll","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"implementsERC721","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_seed","type":"uint256"},{"name":"_receiver","type":"address"}],"name":"minePepe","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"total","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_amount","type":"uint256"}],"name":"pepePremine","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"zeroGenPepes","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_pepeId","type":"uint256"},{"name":"_name","type":"bytes32"}],"name":"setPepeName","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balances","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"pepeNames","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_pepeId","type":"uint256"}],"name":"getPepe","outputs":[{"name":"master","type":"address"},{"name":"genotype","type":"uint256[2]"},{"name":"canCozyAgain","type":"uint64"},{"name":"generation","type":"uint64"},{"name":"father","type":"uint256"},{"name":"mother","type":"uint256"},{"name":"pepeName","type":"bytes32"},{"name":"coolDownIndex","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"name":"tokenId","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"miner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"R","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxHaltDuration","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_pepeId","type":"uint256"}],"name":"getCozyAgain","outputs":[{"name":"","type":"uint64"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"name":"_owner","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"bytes32"}],"name":"userToAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_username","type":"bytes32"}],"name":"claimUsername","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"MAX_ZERO_GEN_PEPES","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"approved","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_pepeId","type":"uint256"},{"name":"_auction","type":"address"},{"name":"_beginPrice","type":"uint256"},{"name":"_endPrice","type":"uint256"},{"name":"_duration","type":"uint64"}],"name":"transferAndAuction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_miner","type":"address"}],"name":"setMiner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_pepeId","type":"uint256"},{"name":"_auction","type":"address"},{"name":"_cozyCandidate","type":"uint256"},{"name":"_candidateAsFather","type":"bool"},{"name":"_affiliate","type":"address"}],"name":"approveAndBuyAffiliated","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"_operator","type":"address"},{"name":"_approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"haltDuration","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_tokenId","type":"uint256"},{"name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"halted","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_mother","type":"uint256"},{"name":"_father","type":"uint256"},{"name":"_pepeReceiver","type":"address"}],"name":"cozyTime","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unhalt","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"cozyCoolDowns","outputs":[{"name":"","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_pepeId","type":"uint256"},{"name":"_auction","type":"address"},{"name":"_cozyCandidate","type":"uint256"},{"name":"_candidateAsFather","type":"bool"}],"name":"approveAndBuy","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"addressToUser","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"haltTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"MAX_PREMINE","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"pepes","outputs":[{"name":"master","type":"address"},{"name":"canCozyAgain","type":"uint64"},{"name":"generation","type":"uint64"},{"name":"father","type":"uint64"},{"name":"mother","type":"uint64"},{"name":"coolDownIndex","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_duration","type":"uint256"}],"name":"halt","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"mother","type":"uint256"},{"indexed":true,"name":"father","type":"uint256"},{"indexed":true,"name":"pepeId","type":"uint256"}],"name":"PepeBorn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"pepeId","type":"uint256"}],"name":"PepeNamed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_owner","type":"address"},{"indexed":true,"name":"_approved","type":"address"},{"indexed":false,"name":"_tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_from","type":"address"},{"indexed":true,"name":"_to","type":"address"},{"indexed":true,"name":"_tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_owner","type":"address"},{"indexed":true,"name":"_operator","type":"address"},{"indexed":false,"name":"_approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"user","type":"address"},{"indexed":true,"name":"username","type":"bytes32"}],"name":"UserNamed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"}],"name":"OwnershipRenounced","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]
Contract Creation Code
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
Deployed Bytecode
0x6080604052600436106102505763ffffffff7c010000000000000000000000000000000000000000000000000000000060003504166301ffc9a7811461025557806306fdde031461028b578063081812fc14610315578063095ea7b3146103495780630b1714fd1461036f5780631051db341461039657806313aa48bf146103ab57806318160ddd146103e15780631977bd68146103f657806321a764301461040e578063228dff131461042357806323b872dd1461043e57806327e235e3146104685780632df1f1b6146104895780632e1a9ffe146104a15780632f745c591461053d578063349dc3291461056157806342842e0e146105765780634980e1be146105a0578063583c2e7b146105cb57806362bc63c4146105e05780636352211e146106155780636c88beeb1461062d57806370a0823114610645578063715018a61461066657806371e68cad1461067b57806373a01b75146106935780637d4061e6146106a857806382cf2116146106c05780638da5cb5b146106f757806395d89b411461070c5780639742ca46146107215780639d18e40514610742578063a22cb46514610769578063a9059cbb1461078f578063b3ecf7a6146107b3578063b88d4fde146107c8578063b9b8af0b14610801578063c29338cf14610816578063cb3e64fd1461083d578063d346658b14610852578063e23a778514610883578063e985e9c5146108a2578063edf53886146108c9578063ee66875a146108ea578063f2fde38b146108ff578063f73bda7214610920578063fb139a2114610935578063fb1fad501461099b575b600080fd5b34801561026157600080fd5b50610277600160e060020a0319600435166109b3565b604080519115158252519081900360200190f35b34801561029757600080fd5b506102a0610a2c565b6040805160208082528351818301528351919283929083019185019080838360005b838110156102da5781810151838201526020016102c2565b50505050905090810190601f1680156103075780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b34801561032157600080fd5b5061032d600435610a63565b60408051600160a060020a039092168252519081900360200190f35b34801561035557600080fd5b5061036d600160a060020a0360043516602435610a7e565b005b34801561037b57600080fd5b50610277600160a060020a0360043581169060243516610b2b565b3480156103a257600080fd5b50610277610b4b565b3480156103b757600080fd5b506103cf600435600160a060020a0360243516610b54565b60408051918252519081900360200190f35b3480156103ed57600080fd5b506103cf610bac565b34801561040257600080fd5b5061036d600435610bdf565b34801561041a57600080fd5b506103cf610cdb565b34801561042f57600080fd5b50610277600435602435610ce1565b34801561044a57600080fd5b50610277600160a060020a0360043581169060243516604435610d85565b34801561047457600080fd5b506103cf600160a060020a0360043516610eaa565b34801561049557600080fd5b506103cf600435610ebc565b3480156104ad57600080fd5b506104b9600435610ece565b60408051600160a060020a038a168152906020820190899080838360005b838110156104ef5781810151838201526020016104d7565b50505067ffffffffffffffff9a8b169390910192835250509590961660208601526040808601949094526060850192909252608084015260ff1660a0830152519081900360c0019350915050f35b34801561054957600080fd5b506103cf600160a060020a0360043516602435610fb1565b34801561056d57600080fd5b5061032d61100c565b34801561058257600080fd5b5061036d600160a060020a036004358116906024351660443561101b565b3480156105ac57600080fd5b506105b561104c565b6040805160ff9092168252519081900360200190f35b3480156105d757600080fd5b506103cf611051565b3480156105ec57600080fd5b506105f8600435611057565b6040805167ffffffffffffffff9092168252519081900360200190f35b34801561062157600080fd5b5061032d60043561108c565b34801561063957600080fd5b5061032d6004356110bd565b34801561065157600080fd5b506103cf600160a060020a03600435166110d8565b34801561067257600080fd5b5061036d6110f3565b34801561068757600080fd5b5061036d600435611152565b34801561069f57600080fd5b506103cf61120e565b3480156106b457600080fd5b5061032d600435611214565b3480156106cc57600080fd5b5061036d600435600160a060020a036024351660443560643567ffffffffffffffff6084351661122f565b34801561070357600080fd5b5061032d61132c565b34801561071857600080fd5b506102a061133b565b34801561072d57600080fd5b5061036d600160a060020a0360043516611372565b61036d600435600160a060020a0360243581169060443590606435151590608435166113c1565b34801561077557600080fd5b5061036d600160a060020a036004351660243515156114a5565b34801561079b57600080fd5b50610277600160a060020a0360043516602435611560565b3480156107bf57600080fd5b506103cf6115be565b3480156107d457600080fd5b5061036d600160a060020a03600480358216916024803590911691604435916064359081019101356115c4565b34801561080d57600080fd5b50610277611617565b34801561082257600080fd5b50610277600435602435600160a060020a0360443516611620565b34801561084957600080fd5b5061036d611af9565b34801561085e57600080fd5b5061086a600435611b2e565b6040805163ffffffff9092168252519081900360200190f35b61036d600435600160a060020a03602435166044356064351515611b5b565b3480156108ae57600080fd5b50610277600160a060020a0360043581169060243516611c55565b3480156108d557600080fd5b506103cf600160a060020a0360043516611c83565b3480156108f657600080fd5b506103cf611c95565b34801561090b57600080fd5b5061036d600160a060020a0360043516611c9b565b34801561092c57600080fd5b506103cf611cbe565b34801561094157600080fd5b5061094d600435611cc3565b60408051600160a060020a03909716875267ffffffffffffffff9586166020880152938516868501529184166060860152909216608084015260ff90911660a0830152519081900360c00190f35b3480156109a757600080fd5b5061036d600435611d40565b60007f80ac58cd00000000000000000000000000000000000000000000000000000000600160e060020a031983161480610a1657507f01ffc9a700000000000000000000000000000000000000000000000000000000600160e060020a03198316145b15610a2357506001610a27565b5060005b919050565b60408051808201909152600b81527f43727970746f2050657065000000000000000000000000000000000000000000602082015281565b6000908152600e6020526040902054600160a060020a031690565b60045460ff1615610a8e57600080fd5b600a80548291339183908110610aa057fe5b6000918252602090912060059091020154600160a060020a031614610ac457600080fd5b6000828152600e60209081526040918290208054600160a060020a031916600160a060020a03871690811790915582518581529251909233927f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92592918290030190a3505050565b600f60209081526000928352604080842090915290825290205460ff1681565b600b5460ff1681565b60045460009060ff1615610b6757600080fd5b601154600160a060020a03163314610b7e57600080fd5b60105461044c11610b8e57600080fd5b610ba5610b9a84611d89565b600080600086611dd6565b9392505050565b60008052600d6020527f81955a0a11e65eac625c29e8882660bae4e165a75d72780094acae8ece9a29ee54600a54035b90565b60008054600160a060020a03163314610bf757600080fd5b60045460ff1615610c0757600080fd5b5060005b81811015610cd75760105460641015610c2357600080fd5b610cce610cb842600a8054905060405160200180838152602001828152602001925050506040516020818303038152906040526040518082805190602001908083835b60208310610c855780518252601f199092019160209182019101610c66565b5181516020939093036101000a600019018019909116921691909117905260405192018290039091209250611d89915050565b6000805481908190600160a060020a0316611dd6565b50600101610c0b565b5050565b60105481565b60045460009060ff1615610cf457600080fd5b600a80548491339183908110610d0657fe5b6000918252602090912060059091020154600160a060020a031614610d2a57600080fd5b60008481526009602052604090205415610d4357600080fd5b6000848152600960205260408082208590555185917f5a8858069902ead8e61944d06d7de6818a0dd09b668447431ac1501baa5e8ef891a25060019392505050565b60045460009060ff1615610d9857600080fd5b81600a81815481101515610da857fe5b6000918252602090912060059091020154600160a060020a0316331480610de557506000818152600e6020526040902054600160a060020a031633145b80610e375750600f6000600a83815481101515610dfe57fe5b60009182526020808320600590920290910154600160a060020a03168352828101939093526040918201812033825290925290205460ff165b1515610e4257600080fd5b84600160a060020a0316600a84815481101515610e5b57fe5b6000918252602090912060059091020154600160a060020a031614610e7f57600080fd5b600160a060020a0384161515610e9457600080fd5b610e9f85858561206c565b506001949350505050565b600d6020526000908152604090205481565b60096020526000908152604090205481565b6000610ed86127d9565b6000806000806000806000600a8a815481101515610ef257fe5b6000918252602090912060059091020180546040805180820191829052600160a060020a039092169b5091925090600183019060029082845b815481526020019060010190808311610f2b57505050600384015460009d8e5260096020526040909d20546004909401549b9d929c67ffffffffffffffff8082169d68010000000000000000830482169d50700100000000000000000000000000000000830482169c5060c060020a9092041699509397505060ff909216945092505050565b600160a060020a0382166000908152600d60205260408120548210610fd557600080fd5b600160a060020a0383166000908152600c60205260409020805483908110610ff957fe5b9060005260206000200154905092915050565b601154600160a060020a031681565b60045460ff161561102b57600080fd5b6110478383836020604051908101604052806000815250612117565b505050565b600581565b60065481565b6000600a8281548110151561106857fe5b600091825260209091206005909102016003015467ffffffffffffffff1692915050565b6000600a8281548110151561109d57fe5b6000918252602090912060059091020154600160a060020a031692915050565b600260205260009081526040902054600160a060020a031681565b600160a060020a03166000908152600d602052604090205490565b600054600160a060020a0316331461110a57600080fd5b60008054604051600160a060020a03909116917ff8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c6482091a260008054600160a060020a0319169055565b600081815260026020526040902054600160a060020a03161561117457600080fd5b33600090815260016020526040902054156111b457336000908152600160209081526040808320548352600290915290208054600160a060020a03191690555b33600081815260016020908152604080832085905584835260029091528082208054600160a060020a03191684179055518392917f43c1ac38b68f3a24742fba8f0826c9fcf340d41f123872fa3175164d117e25af91a350565b61044c81565b600e60205260009081526040902054600160a060020a031681565b60045460009060ff161561124257600080fd5b600a8054879133918390811061125457fe5b6000918252602090912060059091020154600160a060020a03161461127857600080fd5b61128333878961206c565b604080517fd024cd0200000000000000000000000000000000000000000000000000000000815260048101899052602481018790526044810186905267ffffffffffffffff851660648201523360848201529051879350600160a060020a0384169163d024cd029160a480830192600092919082900301818387803b15801561130b57600080fd5b505af115801561131f573d6000803e3d6000fd5b5050505050505050505050565b600054600160a060020a031681565b60408051808201909152600481527f4350455000000000000000000000000000000000000000000000000000000000602082015281565b600054600160a060020a0316331461138957600080fd5b601154600160a060020a03161561139f57600080fd5b60118054600160a060020a031916600160a060020a0392909216919091179055565b60045460ff16156113d157600080fd5b600a805484913391839081106113e357fe5b6000918252602090912060059091020154600160a060020a03161461140757600080fd5b6000848152600e60205260408082208054600160a060020a031916600160a060020a0389811691821790925582517fa6da467c000000000000000000000000000000000000000000000000000000008152600481018b905260248101899052871515604482015233606482015291861660848301529151919263a6da467c92349260a480820193929182900301818588803b15801561130b57600080fd5b60045460ff16156114b557600080fd5b80156114ee57336000908152600f60209081526040808320600160a060020a03861684529091529020805460ff1916600117905561151a565b336000908152600f60209081526040808320600160a060020a03861684529091529020805460ff191690555b6040805182151581529051600160a060020a0384169133917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c319181900360200190a35050565b60045460009060ff161561157357600080fd5b600a8054839133918390811061158557fe5b6000918252602090912060059091020154600160a060020a0316146115a957600080fd5b6115b433858561206c565b5060019392505050565b60055481565b60045460ff16156115d457600080fd5b61161085858585858080601f01602080910402602001604051908101604052809392919081815260200183838082843750612117945050505050565b5050505050565b60045460ff1681565b600080600061162d6127d9565b60045460009060ff161561164057600080fd5b8787141561164d57600080fd5b600a80543391908a90811061165e57fe5b6000918252602090912060059091020154600160a060020a0316148061169a57506000888152600e6020526040902054600160a060020a031633145b806116ec5750600f6000600a8a8154811015156116b357fe5b60009182526020808320600590920290910154600160a060020a03168352828101939093526040918201812033825290925290205460ff165b15156116f757600080fd5b600a80543391908990811061170857fe5b6000918252602090912060059091020154600160a060020a0316148061174457506000878152600e6020526040902054600160a060020a031633145b806117965750600f6000600a8981548110151561175d57fe5b60009182526020808320600590920290910154600160a060020a03168352828101939093526040918201812033825290925290205460ff165b15156117a157600080fd5b600a8054899081106117af57fe5b600091825260209091206003600590920201015467ffffffffffffffff16421180156118055750600a8054889081106117e457fe5b600091825260209091206003600590920201015467ffffffffffffffff1642115b151561181057600080fd5b86600a8981548110151561182057fe5b600091825260209091206005909102016003015460c060020a900467ffffffffffffffff1614801590611893575086600a8981548110151561185e57fe5b6000918252602090912060059091020160030154700100000000000000000000000000000000900467ffffffffffffffff1614155b151561189e57600080fd5b87600a888154811015156118ae57fe5b600091825260209091206005909102016003015460c060020a900467ffffffffffffffff1614801590611921575087600a888154811015156118ec57fe5b6000918252602090912060059091020160030154700100000000000000000000000000000000900467ffffffffffffffff1614155b151561192c57600080fd5b600a80548890811061193a57fe5b90600052602060002090600502019350600a8881548110151561195957fe5b600091825260208083208a8452600e90915260408084208054600160a060020a03199081169091558c8552938190208054909416909355825180840193849052600592909202019450611a0291600187019060029082845b8154815260200190600101908083116119b1575050604080518082019182905293506001890192506002915082845b8154815260200190600101908083116119e0575050600a5492506123cd915050565b91508260030160089054906101000a900467ffffffffffffffff1660010190508360030160089054906101000a900467ffffffffffffffff1660010167ffffffffffffffff168167ffffffffffffffff161015611a795750600383015468010000000000000000900467ffffffffffffffff166001015b611a828861254e565b611a8b8761254e565b600383015467ffffffffffffffff16600a611aa9848b8b868c611dd6565b81548110611ab357fe5b906000526020600020906005020160030160006101000a81548167ffffffffffffffff021916908367ffffffffffffffff16021790555060019450505050509392505050565b60055460035401421180611b175750600054600160a060020a031633145b1515611b2257600080fd5b6004805460ff19169055565b600781600f8110611b3b57fe5b60089182820401919006600402915054906101000a900463ffffffff1681565b60045460ff1615611b6b57600080fd5b600a80548391339183908110611b7d57fe5b6000918252602090912060059091020154600160a060020a031614611ba157600080fd5b6000838152600e60205260408082208054600160a060020a031916600160a060020a03881690811790915581517fd3ce71df000000000000000000000000000000000000000000000000000000008152600481018990526024810187905285151560448201523360648201529151909263d3ce71df9234926084808301939282900301818588803b158015611c3557600080fd5b505af1158015611c49573d6000803e3d6000fd5b50505050505050505050565b600160a060020a039182166000908152600f6020908152604080832093909416825291909152205460ff1690565b60016020526000908152604090205481565b60035481565b600054600160a060020a03163314611cb257600080fd5b611cbb816125f5565b50565b606481565b600a805482908110611cd157fe5b6000918252602090912060059091020180546003820154600490920154600160a060020a03909116925067ffffffffffffffff80831692680100000000000000008104821692700100000000000000000000000000000000820483169260c060020a9092049091169060ff1686565b600054600160a060020a03163314611d5757600080fd5b60035415611d6457600080fd5b600654811115611d7357600080fd5b6005556004805460ff1916600117905542600355565b611d916127d9565b5060408051808201825260009283527f434f4c4c454354205045504553204f4e2043525950544f50455045532e494f2160209081529183208152918190209082015290565b600080611de16127f4565b600267ffffffffffffffff8616049150601c8567ffffffffffffffff161115611e0957600e91505b506040805160e081018252600160a060020a03851681526020810189905260009181019190915267ffffffffffffffff85811660608301819052878216608084015290881660a083015260ff831660c08301521515611e6c576010805460010190555b600a8054600180820180845560009390935283517fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a860059093029283018054600160a060020a031916600160a060020a0390921691909117815560208501519193928592611efe917fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a901906002612839565b5060408201516003820180546060850151608086015160a087015167ffffffffffffffff1990931667ffffffffffffffff958616176fffffffffffffffff0000000000000000191668010000000000000000928616929092029190911777ffffffffffffffff000000000000000000000000000000001916700100000000000000000000000000000000918516919091021777ffffffffffffffffffffffffffffffffffffffffffffffff1660c060020a939091169290920291909117905560c0909101516004909101805460ff191660ff909216919091179055039250611fe68484612665565b828667ffffffffffffffff168867ffffffffffffffff167f160403841b73fe58236181ab476e17f2836a5b4aa8a570d9f1baf4b6ed61a38a60405160405180910390a46040518390600160a060020a038616906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4505095945050505050565b81600a8281548110151561207c57fe5b6000918252602080832060059092029091018054600160a060020a0394909416600160a060020a0319948516179055838252600e905260409020805490911690556120c783826126eb565b6120d18282612665565b8082600160a060020a031684600160a060020a03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4505050565b81600a8181548110151561212757fe5b6000918252602090912060059091020154600160a060020a031633148061216457506000818152600e6020526040902054600160a060020a031633145b806121b65750600f6000600a8381548110151561217d57fe5b60009182526020808320600590920290910154600160a060020a03168352828101939093526040918201812033825290925290205460ff165b15156121c157600080fd5b84600160a060020a0316600a848154811015156121da57fe5b6000918252602090912060059091020154600160a060020a0316146121fe57600080fd5b600160a060020a038416151561221357600080fd5b61221e85858561206c565b612227846127d1565b156116105760405180807f6f6e455243373231526563656976656428616464726573732c75696e7432353681526020017f2c62797465732900000000000000000000000000000000000000000000000000815250602701905060405180910390207bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191684600160a060020a031663f0b9e5ba8786866040518463ffffffff167c01000000000000000000000000000000000000000000000000000000000281526004018084600160a060020a0316600160a060020a0316815260200183815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561233f578181015183820152602001612327565b50505050905090810190601f16801561236c5780820380516001836020036101000a031916815260200191505b50945050505050602060405180830381600087803b15801561238d57600080fd5b505af11580156123a1573d6000803e3d6000fd5b505050506040513d60208110156123b757600080fd5b5051600160e060020a0319161461161057600080fd5b6123d56127d9565b604051905060408101604052816000524260205260406000206123fe565b60029190910a900490565b6124eb565b6000600184161515612413579091905b61241e6001856123f3565b9350600080607f86166124326007886123f3565b96508060015b600484106101008310161561248657959695600019908101600283900a9182011880891696909617959450607f8916925061247460078a6123f3565b98508282019150600184019350612438565b6001810319945086851686179550886000527f434f4c4c454354205045504553204f4e2043525950544f50455045532e494f21602052602460002060236003206022600220166021600120602060002016161680871896505050505050509392505050565b6020600182160260106002831602600483049250612510838289015184890151612403565b84526020821891506020811890508460005242196020526040600020925061253f838289015184890151612403565b60208501525050509392505050565b6000600a8281548110151561255f57fe5b60009182526020909120600590910201600481015490915060079060ff16600f811061258757fe5b60088104919091015460038301805467ffffffffffffffff1916600790931660049081026101000a90920463ffffffff16420167ffffffffffffffff1692909217909155810154600e60ff9091161015610cd757600401805460ff8082166001011660ff1990911617905550565b600160a060020a038116151561260a57600080fd5b60008054604051600160a060020a03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a360008054600160a060020a031916600160a060020a0392909216919091179055565b600160a060020a0382166000908152600c60209081526040808320600d9092529091205481548110156126b2578282828154811015156126a157fe5b6000918252602090912001556126c8565b8154600181018355600083815260209020018390555b505050600160a060020a03166000908152600d6020526040902080546001019055565b600160a060020a0382166000908152600c6020526040812090805b83838381548110151561271557fe5b906000526020600020015414151561273257600190910190612706565b83838381548110151561274157fe5b906000526020600020015414156116105750600160a060020a0384166000908152600d602052604081205460001901908111156127ac57828181548110151561278657fe5b9060005260206000200154838381548110151561279f57fe5b6000918252602090912001555b50505050600160a060020a03166000908152600d602052604090208054600019019055565b6000903b1190565b60408051808201825290600290829080388339509192915050565b60408051610100810190915260008152602081016128106127d9565b815260006020820181905260408201819052606082018190526080820181905260a09091015290565b8260028101928215612867579160200282015b8281111561286757825182559160200191906001019061284c565b50612873929150612877565b5090565b610bdc91905b80821115612873576000815560010161287d5600a165627a7a72305820824faa9a1a1c971be5f5b529149a59e462185c5aef8cde729b59ca67cbf5ff420029
Swarm Source
bzzr://824faa9a1a1c971be5f5b529149a59e462185c5aef8cde729b59ca67cbf5ff42
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.