Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

 contract Genetic    - function breed(uint256[2] mother, uin ...    - function shiftR(value, offset)    - function processSide(fatherSrc, mothe ...    - function randomDNA(uint256 seed)  contract Ownable    - function renounceOwnership()    - function transferOwnership(address _n ...    - function _transferOwnership(address _ ...  contract Usernames    - function claimUsername(bytes32 _usern ...  contract Beneficiary is Ownable    - function setBeneficiary(address _bene ...  contract Affiliate is Ownable    - function setAffiliateSetter(address _ ...    - function setAffiliate(address _user, ...  contract ERC721    - function implementsERC721()    - function totalSupply()    - function balanceOf(address _owner)    - function ownerOf(uint256 _tokenId)    - function approve(address _to, uint256 ...    - function transferFrom(address _from, ...    - function transfer(address _to, uint25 ...  contract PepeInterface is ERC721    - function cozyTime(uint256 _mother, ui ...    - function getCozyAgain(uint256 _pepeId ...  contract AuctionBase is Beneficiar ...    - function savePepe(uint256 _pepeId)    - function changeFee(uint256 _fee)    - function startAuction(uint256 _pepeId ...    - function startAuctionDirect(uint256 _ ...    - function calculateBid(uint256 _pepeId ...    - function getFees()  contract CozyTimeAuction is Auctio ...    - function startAuction(uint256 _pepeId ...    - function startAuctionDirect(uint256 _ ...    - function buyCozy(uint256 _pepeId, uin ...    - function buyCozyAffiliated(uint256 _p ...  contract Haltable is Ownable    - function halt(uint256 _duration)    - function unhalt() library SafeMath    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function add(uint256 a, uint256 b) interface ERC721TokenReceiver    - function onERC721Received(address _fr ...  contract PepeBase is Genetic, Owna ... *    - function _newPepe(uint256[2] _genoTyp ...    - function setMiner(address _miner)    - function minePepe(uint256 _seed, addr ...    - function pepePremine(uint256 _amount)    - function cozyTime(uint256 _mother, ui ...    - function _handleCoolDown(uint256 _pep ...    - function setPepeName(uint256 _pepeId, ...    - function transferAndAuction(uint256 _ ...    - function approveAndBuy(uint256 _pepeI ...    - function approveAndBuyAffiliated(uint ...    - function getPepe(uint256 _pepeId)    - function getCozyAgain(uint256 _pepeId ...    - function totalSupply()    - function balanceOf(address _owner)    - function ownerOf(uint256 _tokenId)    - function tokenOfOwnerByIndex(address ...    - function addToWallet(address _owner, ...    - function removeFromWallet(address _ow ...    - function _transfer(address _from, add ...    - function transfer(address _to, uint25 ...    - function approve(address _to, uint256 ...    - function setApprovalForAll(address _o ...    - function getApproved(uint256 _tokenId ...    - function isApprovedForAll(address _ow ...    - function supportsInterface(bytes4 int ...    - function safeTransferFrom(address _fr ...    - function safeTransferFrom(address _fr ...    - function _safeTransferFromInternal(ad ...    - function transferFrom(address _from, ...    - function isContract(address _address)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *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;
    }

}

• 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"}]

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

bzzr://824faa9a1a1c971be5f5b529149a59e462185c5aef8cde729b59ca67cbf5ff42