Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Ownable
•    - function transferOwnership(address ne ...
•  contract Pausable is Ownable
•    - function pause()
•    - function unpause()
•  contract ERC721
•    - function totalSupply()
•    - function balanceOf(address _owner)
•    - function ownerOf(uint256 _tokenId)
•    - function approve(address _to, uint256 ...
•    - function transfer(address _to, uint25 ...
•    - function transferFrom(address _from, ...
•  contract ClockAuctionBase
•    - function _owns(address _claimant, uin ...
•    - function _escrow(address _owner, uint ...
•    - function _transfer(address _receiver, ...
•    - function _addAuction(uint256 _tokenId ...
•    - function _cancelAuction(uint256 _toke ...
•    - function _bid(uint256 _tokenId, uint2 ...
•    - function _removeAuction(uint256 _toke ...
•    - function _isOnAuction(Auction storage ...
•    - function _currentPrice(Auction storag ...
•    - function _computeCurrentPrice(
•    - function _computeCut(uint256 _price)
•  contract ClockAuction is Pausable, ...
•    - function setAuctionParameters(address ...
•    - function withdrawBalance()
•    - function createAuction(
•    - function bid(uint256 _tokenId)
•    - function cancelAuction(uint256 _token ...
•    - function cancelAuctionWhenPaused(uint ...
•    - function getAuction(uint256 _tokenId)
•    - function getCurrentPrice(uint256 _tok ...
•    - function setBumpFee(uint val)
•    - function bumpAuction(uint tokenId)
•  contract SaleClockAuction is Clock ... *
•    - function createAuction(
•    - function bid(uint256 _tokenId)
•  contract SiringClockAuction is Clo ...
•    - function createAuction(
•    - function bid(uint256 _tokenId)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-05-20
*/

pragma solidity ^0.4.11;


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


  /**
   * @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 transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}




/**
 * @title Pausable
 * @dev Base contract which allows children to implement an emergency stop mechanism.
 */
contract Pausable is Ownable {
  event Pause();
  event Unpause();

  bool public paused = false;


  /**
   * @dev modifier to allow actions only when the contract IS paused
   */
  modifier whenNotPaused() {
    require(!paused);
    _;
  }

  /**
   * @dev modifier to allow actions only when the contract IS NOT paused
   */
  modifier whenPaused {
    require(paused);
    _;
  }

  /**
   * @dev called by the owner to pause, triggers stopped state
   */
  function pause() onlyOwner whenNotPaused public returns (bool) {
    paused = true;
    emit Pause();
    return true;
  }

  /**
   * @dev called by the owner to unpause, returns to normal state
   */
  function unpause() onlyOwner whenPaused public returns (bool) {
    paused = false;
    emit Unpause();
    return true;
  }
}


/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function ownerOf(uint256 _tokenId) external view returns (address owner);
    function approve(address _to, uint256 _tokenId) external;
    function transfer(address _to, uint256 _tokenId) external;
    function transferFrom(address _from, address _to, uint256 _tokenId) external;

    // Events
    event Transfer(address from, address to, uint256 tokenId);
    event Approval(address owner, address approved, uint256 tokenId);
}


/// @title Auction Core
/// @dev Contains models, variables, and internal methods for the auction.
/// @notice We omit a fallback function to prevent accidental sends to this contract.
contract ClockAuctionBase {

    // Represents an auction on an NFT
    struct Auction {
        // Current owner of NFT
        address seller;
        // Price (in wei) at beginning of auction
        uint128 startingPrice;
        // Price (in wei) at end of auction
        uint128 endingPrice;
        // Duration (in seconds) of auction
        uint64 duration;
        // Time when auction started
        // NOTE: 0 if this auction has been concluded
        uint64 startedAt;
    }

    // Reference to contract tracking NFT ownership
    ERC721 public nonFungibleContract;

    // Cut owner takes on each auction, measured in basis points (1/100 of a percent).
    // Values 0-10,000 map to 0%-100%
    uint256 public ownerCut;

    // Map from token ID to their corresponding auction.
    mapping (uint256 => Auction) tokenIdToAuction;

    event AuctionCreated(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration);
    event AuctionSuccessful(uint256 tokenId, uint256 totalPrice, address winner);
    event AuctionCancelled(uint256 tokenId);

    /// @dev Returns true if the claimant owns the token.
    /// @param _claimant - Address claiming to own the token.
    /// @param _tokenId - ID of token whose ownership to verify.
    function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
        return (nonFungibleContract.ownerOf(_tokenId) == _claimant);
    }

    /// @dev Escrows the NFT, assigning ownership to this contract.
    /// Throws if the escrow fails.
    /// @param _owner - Current owner address of token to escrow.
    /// @param _tokenId - ID of token whose approval to verify.
    function _escrow(address _owner, uint256 _tokenId) internal {
        // it will throw if transfer fails
        nonFungibleContract.transferFrom(_owner, this, _tokenId);
    }

    /// @dev Transfers an NFT owned by this contract to another address.
    /// Returns true if the transfer succeeds.
    /// @param _receiver - Address to transfer NFT to.
    /// @param _tokenId - ID of token to transfer.
    function _transfer(address _receiver, uint256 _tokenId) internal {
        // it will throw if transfer fails
        nonFungibleContract.transfer(_receiver, _tokenId);
    }

    /// @dev Adds an auction to the list of open auctions. Also fires the
    ///  AuctionCreated event.
    /// @param _tokenId The ID of the token to be put on auction.
    /// @param _auction Auction to add.
    function _addAuction(uint256 _tokenId, Auction _auction) internal {
        // Require that all auctions have a duration of
        // at least one minute. (Keeps our math from getting hairy!)
        require(_auction.duration >= 1 minutes);

        tokenIdToAuction[_tokenId] = _auction;

        emit AuctionCreated(
            uint256(_tokenId),
            uint256(_auction.startingPrice),
            uint256(_auction.endingPrice),
            uint256(_auction.duration)
        );
    }

    /// @dev Cancels an auction unconditionally.
    function _cancelAuction(uint256 _tokenId, address _seller) internal {
        _removeAuction(_tokenId);
        _transfer(_seller, _tokenId);
        emit AuctionCancelled(_tokenId);
    }

    /// @dev Computes the price and transfers winnings.
    /// Does NOT transfer ownership of token.
    function _bid(uint256 _tokenId, uint256 _bidAmount)
        internal
        returns (uint256)
    {
        // Get a reference to the auction struct
        Auction storage auction = tokenIdToAuction[_tokenId];

        // Explicitly check that this auction is currently live.
        // (Because of how Ethereum mappings work, we can't just count
        // on the lookup above failing. An invalid _tokenId will just
        // return an auction object that is all zeros.)
        require(_isOnAuction(auction));

        // Check that the bid is greater than or equal to the current price
        uint256 price = _currentPrice(auction);
        require(_bidAmount >= price);

        // Grab a reference to the seller before the auction struct
        // gets deleted.
        address seller = auction.seller;

        // The bid is good! Remove the auction before sending the fees
        // to the sender so we can't have a reentrancy attack.
        _removeAuction(_tokenId);

        // Transfer proceeds to seller (if there are any!)
        if (price > 0) {
            // Calculate the auctioneer's cut.
            // (NOTE: _computeCut() is guaranteed to return a
            // value <= price, so this subtraction can't go negative.)
            uint256 auctioneerCut = _computeCut(price);
            uint256 sellerProceeds = price - auctioneerCut;

            // NOTE: Doing a transfer() in the middle of a complex
            // method like this is generally discouraged because of
            // reentrancy attacks and DoS attacks if the seller is
            // a contract with an invalid fallback function. We explicitly
            // guard against reentrancy attacks by removing the auction
            // before calling transfer(), and the only thing the seller
            // can DoS is the sale of their own asset! (And if it's an
            // accident, they can call cancelAuction(). )
            seller.transfer(sellerProceeds);
        }

        // Calculate any excess funds included with the bid. If the excess
        // is anything worth worrying about, transfer it back to bidder.
        // NOTE: We checked above that the bid amount is greater than or
        // equal to the price so this cannot underflow.
        uint256 bidExcess = _bidAmount - price;

        // Return the funds. Similar to the previous transfer, this is
        // not susceptible to a re-entry attack because the auction is
        // removed before any transfers occur.
        msg.sender.transfer(bidExcess);

        // Tell the world!
        emit AuctionSuccessful(_tokenId, price, msg.sender);

        return price;
    }

    /// @dev Removes an auction from the list of open auctions.
    /// @param _tokenId - ID of NFT on auction.
    function _removeAuction(uint256 _tokenId) internal {
        delete tokenIdToAuction[_tokenId];
    }

    /// @dev Returns true if the NFT is on auction.
    /// @param _auction - Auction to check.
    function _isOnAuction(Auction storage _auction) internal view returns (bool) {
        return (_auction.startedAt > 0);
    }

    /// @dev Returns current price of an NFT on auction. Broken into two
    ///  functions (this one, that computes the duration from the auction
    ///  structure, and the other that does the price computation) so we
    ///  can easily test that the price computation works correctly.
    function _currentPrice(Auction storage _auction)
        internal
        view
        returns (uint256)
    {
        uint256 secondsPassed = 0;

        // A bit of insurance against negative values (or wraparound).
        // Probably not necessary (since Ethereum guarnatees that the
        // now variable doesn't ever go backwards).
        if (now > _auction.startedAt) {
            secondsPassed = now - _auction.startedAt;
        }

        return _computeCurrentPrice(
            _auction.startingPrice,
            _auction.endingPrice,
            _auction.duration,
            secondsPassed
        );
    }

    /// @dev Computes the current price of an auction. Factored out
    ///  from _currentPrice so we can run extensive unit tests.
    ///  When testing, make this function public and turn on
    ///  `Current price computation` test suite.
    function _computeCurrentPrice(
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration,
        uint256 _secondsPassed
    )
        internal
        pure
        returns (uint256)
    {
        // NOTE: We don't use SafeMath (or similar) in this function because
        //  all of our public functions carefully cap the maximum values for
        //  time (at 64-bits) and currency (at 128-bits). _duration is
        //  also known to be non-zero (see the require() statement in
        //  _addAuction())
        if (_secondsPassed >= _duration) {
            // We've reached the end of the dynamic pricing portion
            // of the auction, just return the end price.
            return _endingPrice;
        } else {
            // Starting price can be higher than ending price (and often is!), so
            // this delta can be negative.
            int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice);

            // This multiplication can't overflow, _secondsPassed will easily fit within
            // 64-bits, and totalPriceChange will easily fit within 128-bits, their product
            // will always fit within 256-bits.
            int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration);

            // currentPriceChange can be negative, but if so, will have a magnitude
            // less that _startingPrice. Thus, this result will always end up positive.
            int256 currentPrice = int256(_startingPrice) + currentPriceChange;

            return uint256(currentPrice);
        }
    }

    /// @dev Computes owner's cut of a sale.
    /// @param _price - Sale price of NFT.
    function _computeCut(uint256 _price) internal view returns (uint256) {
        // NOTE: We don't use SafeMath (or similar) in this function because
        //  all of our entry functions carefully cap the maximum values for
        //  currency (at 128-bits), and ownerCut <= 10000 (see the require()
        //  statement in the ClockAuction constructor). The result of this
        //  function is always guaranteed to be <= _price.
        return _price * ownerCut / 10000;
    }

}




/// @title Clock auction for non-fungible tokens.
/// @notice We omit a fallback function to prevent accidental sends to this contract.
contract ClockAuction is Pausable, ClockAuctionBase {

    
    /// @dev Constructor creates a reference to the NFT ownership contract
    ///  and verifies the owner cut is in the valid range.
    /// @param _nftAddress - address of a deployed contract implementing
    ///  the Nonfungible Interface.
    /// @param _cut - percent cut the owner takes on each auction, must be
    ///  between 0-10,000.
    constructor(address _nftAddress, uint256 _cut) public {
        require(_cut <= 10000);
        ownerCut = _cut;

        ERC721 candidateContract = ERC721(_nftAddress);
        nonFungibleContract = candidateContract;
    }
    
    function setAuctionParameters(address _nftAddress, uint256 _cut) external onlyOwner {
         require(_cut <= 10000);
        ownerCut = _cut;

        ERC721 candidateContract = ERC721(_nftAddress);
        nonFungibleContract = candidateContract;
    }

    /// @dev Remove all Ether from the contract, which is the owner's cuts
    ///  as well as any Ether sent directly to the contract address.
    ///  Always transfers to the NFT contract, but can be called either by
    ///  the owner or the NFT contract.
    function withdrawBalance() external {
        address nftAddress = address(nonFungibleContract);

        require(
            msg.sender == owner ||
            msg.sender == nftAddress
        );
        // We are using this boolean method to make sure that even if one fails it will still work
        nftAddress.transfer(address(this).balance);
    }

    /// @dev Creates and begins a new auction.
    /// @param _tokenId - ID of token to auction, sender must be owner.
    /// @param _startingPrice - Price of item (in wei) at beginning of auction.
    /// @param _endingPrice - Price of item (in wei) at end of auction.
    /// @param _duration - Length of time to move between starting
    ///  price and ending price (in seconds).
    /// @param _seller - Seller, if not the message sender
    function createAuction(
        uint256 _tokenId,
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration,
        address _seller
    )
        external
        whenNotPaused
    {
        // Sanity check that no inputs overflow how many bits we've allocated
        // to store them in the auction struct.
        require(_startingPrice == uint256(uint128(_startingPrice)));
        require(_endingPrice == uint256(uint128(_endingPrice)));
        require(_duration == uint256(uint64(_duration)));

        require(_owns(msg.sender, _tokenId));
        _escrow(msg.sender, _tokenId);
        Auction memory auction = Auction(
            _seller,
            uint128(_startingPrice),
            uint128(_endingPrice),
            uint64(_duration),
            uint64(now)
        );
        _addAuction(_tokenId, auction);
    }

    /// @dev Bids on an open auction, completing the auction and transferring
    ///  ownership of the NFT if enough Ether is supplied.
    /// @param _tokenId - ID of token to bid on.
    function bid(uint256 _tokenId)
        external
        payable
        whenNotPaused
    {
        // _bid will throw if the bid or funds transfer fails
        _bid(_tokenId, msg.value);
        _transfer(msg.sender, _tokenId);
    }

    /// @dev Cancels an auction that hasn't been won yet.
    ///  Returns the NFT to original owner.
    /// @notice This is a state-modifying function that can
    ///  be called while the contract is paused.
    /// @param _tokenId - ID of token on auction
    function cancelAuction(uint256 _tokenId)
        external
    {
        Auction storage auction = tokenIdToAuction[_tokenId];
        require(_isOnAuction(auction));
        address seller = auction.seller;
        require(msg.sender == seller);
        _cancelAuction(_tokenId, seller);
    }

    /// @dev Cancels an auction when the contract is paused.
    ///  Only the owner may do this, and NFTs are returned to
    ///  the seller. This should only be used in emergencies.
    /// @param _tokenId - ID of the NFT on auction to cancel.
    function cancelAuctionWhenPaused(uint256 _tokenId)
        whenPaused
        onlyOwner
        external
    {
        Auction storage auction = tokenIdToAuction[_tokenId];
        require(_isOnAuction(auction));
        _cancelAuction(_tokenId, auction.seller);
    }

    /// @dev Returns auction info for an NFT on auction.
    /// @param _tokenId - ID of NFT on auction.
    function getAuction(uint256 _tokenId)
        external
        view
        returns
    (
        address seller,
        uint256 startingPrice,
        uint256 endingPrice,
        uint256 duration,
        uint256 startedAt
    ) {
        Auction storage auction = tokenIdToAuction[_tokenId];
        require(_isOnAuction(auction));
        return (
            auction.seller,
            auction.startingPrice,
            auction.endingPrice,
            auction.duration,
            auction.startedAt
        );
    }

    /// @dev Returns the current price of an auction.
    /// @param _tokenId - ID of the token price we are checking.
    function getCurrentPrice(uint256 _tokenId)
        external
        view
        returns (uint256)
    {
        Auction storage auction = tokenIdToAuction[_tokenId];
        require(_isOnAuction(auction));
        return _currentPrice(auction);
    }
    
    uint public bumpFee = 1 finney;
    
    function setBumpFee(uint val) external onlyOwner {
        bumpFee = val;
    }
    
    event AuctionBumped(uint256 tokenId);
    
    function bumpAuction(uint tokenId) external payable {
        require(msg.value >= bumpFee);
        Auction storage auction = tokenIdToAuction[tokenId];
        require(_isOnAuction(auction));
        emit AuctionBumped(tokenId);
        msg.sender.transfer(msg.value - bumpFee);
    }

}




/// @title Clock auction modified for sale of monsters
/// @notice We omit a fallback function to prevent accidental sends to this contract.
contract SaleClockAuction is ClockAuction {

    // @dev Sanity check that allows us to ensure that we are pointing to the
    //  right auction in our setSaleAuctionAddress() call.
    bool public isSaleClockAuction = true;
    
    
    // Delegate constructor
    constructor(address _nftAddr, uint256 _cut) public
        ClockAuction(_nftAddr, _cut) {}

    /// @dev Creates and begins a new auction.
    /// @param _tokenId - ID of token to auction, sender must be owner.
    /// @param _startingPrice - Price of item (in wei) at beginning of auction.
    /// @param _endingPrice - Price of item (in wei) at end of auction.
    /// @param _duration - Length of auction (in seconds).
    /// @param _seller - Seller, if not the message sender
    function createAuction(
        uint256 _tokenId,
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration,
        address _seller
    )
        external
    {
        // Sanity check that no inputs overflow how many bits we've allocated
        // to store them in the auction struct.
        require(_startingPrice == uint256(uint128(_startingPrice)));
        require(_endingPrice == uint256(uint128(_endingPrice)));
        require(_duration == uint256(uint64(_duration)));

        require(msg.sender == address(nonFungibleContract));
        _escrow(_seller, _tokenId);
        Auction memory auction = Auction(
            _seller,
            uint128(_startingPrice),
            uint128(_endingPrice),
            uint64(_duration),
            uint64(now)
        );
        _addAuction(_tokenId, auction);
    }

    /// @dev Updates lastSalePrice if seller is the nft contract
    /// Otherwise, works the same as default bid method.
    function bid(uint256 _tokenId)
        external
        payable
    {
        // _bid verifies token ID size
        _bid(_tokenId, msg.value);
        _transfer(msg.sender, _tokenId);
    }

}


/// @title Reverse auction modified for siring
/// @notice We omit a fallback function to prevent accidental sends to this contract.
contract SiringClockAuction is ClockAuction {

    // @dev Sanity check that allows us to ensure that we are pointing to the
    //  right auction in our setSiringAuctionAddress() call.
    bool public isSiringClockAuction = true;

    // Delegate constructor
    constructor(address _nftAddr, uint256 _cut) public
        ClockAuction(_nftAddr, _cut) {}

    /// @dev Creates and begins a new auction. Since this function is wrapped,
    /// require sender to be MonsterBitCore contract.
    /// @param _tokenId - ID of token to auction, sender must be owner.
    /// @param _startingPrice - Price of item (in wei) at beginning of auction.
    /// @param _endingPrice - Price of item (in wei) at end of auction.
    /// @param _duration - Length of auction (in seconds).
    /// @param _seller - Seller, if not the message sender
    function createAuction(
        uint256 _tokenId,
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration,
        address _seller
    )
        external
    {
        // Sanity check that no inputs overflow how many bits we've allocated
        // to store them in the auction struct.
        require(_startingPrice == uint256(uint128(_startingPrice)));
        require(_endingPrice == uint256(uint128(_endingPrice)));
        require(_duration == uint256(uint64(_duration)));

        require(msg.sender == address(nonFungibleContract));
        _escrow(_seller, _tokenId);
        Auction memory auction = Auction(
            _seller,
            uint128(_startingPrice),
            uint128(_endingPrice),
            uint64(_duration),
            uint64(now)
        );
        _addAuction(_tokenId, auction);
    }

    /// @dev Places a bid for siring. Requires the sender
    /// is the MonsterCore contract because all bid methods
    /// should be wrapped. Also returns the monster to the
    /// seller rather than the winner.
    function bid(uint256 _tokenId)
        external
        payable
    {
        require(msg.sender == address(nonFungibleContract));
        address seller = tokenIdToAuction[_tokenId].seller;
        // _bid checks that token ID is valid and will throw if bid fails
        _bid(_tokenId, msg.value);
        // We transfer the monster back to the seller, the winner will get
        // the offspring
        _transfer(seller, _tokenId);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":false,"inputs":[{"name":"_nftAddress","type":"address"},{"name":"_cut","type":"uint256"}],"name":"setAuctionParameters","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_tokenId","type":"uint256"},{"name":"_startingPrice","type":"uint256"},{"name":"_endingPrice","type":"uint256"},{"name":"_duration","type":"uint256"},{"name":"_seller","type":"address"}],"name":"createAuction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unpause","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"bid","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"tokenId","type":"uint256"}],"name":"bumpAuction","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"bumpFee","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"val","type":"uint256"}],"name":"setBumpFee","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"withdrawBalance","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"getAuction","outputs":[{"name":"seller","type":"address"},{"name":"startingPrice","type":"uint256"},{"name":"endingPrice","type":"uint256"},{"name":"duration","type":"uint256"},{"name":"startedAt","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"ownerCut","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"pause","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isSaleClockAuction","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"cancelAuctionWhenPaused","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"cancelAuction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"getCurrentPrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"nonFungibleContract","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_nftAddr","type":"address"},{"name":"_cut","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"tokenId","type":"uint256"}],"name":"AuctionBumped","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"tokenId","type":"uint256"},{"indexed":false,"name":"startingPrice","type":"uint256"},{"indexed":false,"name":"endingPrice","type":"uint256"},{"indexed":false,"name":"duration","type":"uint256"}],"name":"AuctionCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"tokenId","type":"uint256"},{"indexed":false,"name":"totalPrice","type":"uint256"},{"indexed":false,"name":"winner","type":"address"}],"name":"AuctionSuccessful","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"tokenId","type":"uint256"}],"name":"AuctionCancelled","type":"event"},{"anonymous":false,"inputs":[],"name":"Pause","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpause","type":"event"}]

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

0000000000000000000000005f5ff74b198e5095069cf132d2523dbae516613f0000000000000000000000000000000000000000000000000000000000000181

-----Decoded View---------------
Arg [0] : _nftAddr (address): 0x5f5fF74B198E5095069cF132D2523DBaE516613f
Arg [1] : _cut (uint256): 385

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005f5ff74b198e5095069cf132d2523dbae516613f
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000181

19145:1982:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13658:261;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;13658:261:0;-1:-1:-1;;;;;13658:261:0;;;;;;;;;19914:879;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;19914:879:0;;;;;;;;;-1:-1:-1;;;;;19914:879:0;;;;;1743:128;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1743:128:0;;;;;;;;;;;;;;;;;;;;;;20925:197;;;;;;18695:292;;;;;;18510:30;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18510:30:0;;;;;;;;;;;;;;;;;;;;1115:26;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1115:26:0;;;;18553:81;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;18553:81:0;;;;;14190:363;;8:9:-1;5:2;;;30:1;27;20:12;5:2;14190:363:0;;;;17565:545;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;17565:545:0;;;;;;;;;-1:-1:-1;;;;;17565:545:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3591:23;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3591:23:0;;;;1530:126;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1530:126:0;;;;19335:37;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19335:37:0;;;;17174:276;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;17174:276:0;;;;;247:20;;8:9:-1;5:2;;;30:1;27;20:12;5:2;247:20:0;;;;;;;;-1:-1:-1;;;;;247:20:0;;;;;;;;;;;;;;16614:301;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;16614:301:0;;;;;18239:259;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;18239:259:0;;;;;3422:33;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3422:33:0;;;;774:135;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;774:135:0;-1:-1:-1;;;;;774:135:0;;;;;13658:261;13815:24;585:5;;-1:-1:-1;;;;;585:5:0;571:10;:19;563:28;;;;;;13770:5;13762:13;;;13754:22;;;;;;-1:-1:-1;13787:8:0;:15;13872:19;:39;;-1:-1:-1;;13872:39:0;-1:-1:-1;;;;;13872:39:0;;;;;;;;;;13658:261::o;19914:879::-;20547:22;;:::i;:::-;20277:32;;;20259:50;;20251:59;;;;;;20345:30;;;20329:46;;20321:55;;;;;;20408:26;;;20395:39;;20387:48;;;;;;20478:19;;-1:-1:-1;;;;;20478:19:0;20456:10;:42;20448:51;;;;;;20510:26;20518:7;20527:8;20510:7;:26::i;:::-;20572:172;;;;;;;;;20594:7;-1:-1:-1;;;;;20572:172:0;;;;;20624:14;20572:172;;;;;;20662:12;20572:172;;;;;;20697:9;20572:172;;;;;;20729:3;20572:172;;;;;20547:197;;20755:30;20767:8;20777:7;20755:11;:30::i;:::-;19914:879;;;;;;:::o;1743:128::-;1799:4;585:5;;-1:-1:-1;;;;;585:5:0;571:10;:19;563:28;;;;;;1425:6;;-1:-1:-1;;;1425:6:0;;;;1417:15;;;;;;;;1821:5;1812:14;;-1:-1:-1;;1812:14:0;;;1838:9;;;;1821:5;1838:9;-1:-1:-1;1861:4:0;1743:128;:::o;20925:197::-;21047:25;21052:8;21062:9;21047:4;:25::i;:::-;;21083:31;21093:10;21105:8;21083:9;:31::i;:::-;20925:197;:::o;18695:292::-;18779:7;;18798:23;;18766:9;:20;;18758:29;;;;;;-1:-1:-1;18824:25:0;;;;:16;:25;;;;;18868:21;18824:25;18868:12;:21::i;:::-;18860:30;;;;;;;;18906:22;;;;;;;;;;;;;;;;;18971:7;;18939:40;;:10;;18959:9;:19;18939:40;;;;;;;;;18959:19;18939:10;:40;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;18939:40:0;18695:292;;:::o;18510:30::-;;;;:::o;1115:26::-;;;-1:-1:-1;;;1115:26:0;;;;;:::o;18553:81::-;585:5;;-1:-1:-1;;;;;585:5:0;571:10;:19;563:28;;;;;;18613:7;:13;18553:81::o;14190:363::-;14266:19;;14237:18;14335:5;-1:-1:-1;;;;;14266:19:0;;;;14335:5;14321:10;:19;;:60;;-1:-1:-1;14357:10:0;-1:-1:-1;;;;;14357:24:0;;;14321:60;14299:93;;;;;;;;14503:42;;-1:-1:-1;;;;;14503:19:0;;;14531:4;14523:21;14503:42;;;;;;;;;14523:21;14503:19;:42;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14503:42:0;14190:363;:::o;17565:545::-;17668:14;17844:26;;;:16;:26;;;;;17668:14;;;;;;;;17889:21;17844:26;17889:12;:21::i;:::-;17881:30;;;;;;;;17944:14;;;17973:21;;;18043:16;;;;;-1:-1:-1;;;;;17944:14:0;;;;17973:21;;;;;-1:-1:-1;18009:19:0;;;;;;;;-1:-1:-1;18043:16:0;;;;;-1:-1:-1;18074:17:0;;;;;;-1:-1:-1;17565:545:0;-1:-1:-1;;17565:545:0:o;3591:23::-;;;;:::o;1530:126::-;1587:4;585:5;;-1:-1:-1;;;;;585:5:0;571:10;:19;563:28;;;;;;1275:6;;-1:-1:-1;;;1275:6:0;;;;1274:7;1266:16;;;;;;1600:6;:13;;-1:-1:-1;;1600:13:0;-1:-1:-1;;;1600:13:0;;;1625:7;;;;1600:6;1625:7;-1:-1:-1;1646:4:0;1530:126;:::o;19335:37::-;;;;;;:::o;17174:276::-;17298:23;1425:6;;-1:-1:-1;;;1425:6:0;;;;1417:15;;;;;;;;585:5;;-1:-1:-1;;;;;585:5:0;571:10;:19;563:28;;;;;;-1:-1:-1;17324:26:0;;;;:16;:26;;;;;17369:21;17324:26;17369:12;:21::i;:::-;17361:30;;;;;;;;17427:14;;17402:40;;17417:8;;-1:-1:-1;;;;;17427:14:0;17402;:40::i;247:20::-;;;-1:-1:-1;;;;;247:20:0;;:::o;16614:301::-;16689:23;16715:26;;;:16;:26;;;;;;16760:21;16715:26;16760:12;:21::i;:::-;16752:30;;;;;;;;-1:-1:-1;16810:14:0;;-1:-1:-1;;;;;16810:14:0;16843:10;:20;;16835:29;;;;;;16875:32;16890:8;16900:6;16875:14;:32::i;18239:259::-;18332:7;18383:26;;;:16;:26;;;;;18428:21;18383:26;18428:12;:21::i;:::-;18420:30;;;;;;;;18468:22;18482:7;18468:13;:22::i;:::-;18461:29;18239:259;-1:-1:-1;;;18239:259:0:o;3422:33::-;;;-1:-1:-1;;;;;3422:33:0;;:::o;774:135::-;585:5;;-1:-1:-1;;;;;585:5:0;571:10;:19;563:28;;;;;;-1:-1:-1;;;;;847:22:0;;;843:61;;880:5;:16;;-1:-1:-1;;;;;880:16:0;;-1:-1:-1;;880:16:0;;;;;;774:135;:::o;4565:179::-;4680:19;;:56;;;;;;-1:-1:-1;;;;;4680:56:0;;;;;;;4721:4;4680:56;;;;;;;;;;;;:19;;;;;:32;;:56;;;;;:19;;:56;;;;;;;:19;;:56;;;5:2:-1;;;;30:1;27;20:12;5:2;4680:56:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5382:507:0;5615:9;5594:8;:17;;;:30;;;;5586:39;;;;;;;;5638:26;;;;:16;:26;;;;;;;;;:37;;;;-1:-1:-1;;;;;5638:37:0;;;-1:-1:-1;;5638:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5638:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5638:37:0;;;;-1:-1:-1;;5638:37:0;;;;;;;;;;;;;5693:188;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5382:507;;:::o;6251:2701::-;6339:7;6440:26;;;:16;:26;;;;;6339:7;;;;;6753:21;6440:26;6753:12;:21::i;:::-;6745:30;;;;;;;;6881:22;6895:7;6881:13;:22::i;:::-;6865:38;-1:-1:-1;6922:19:0;;;;6914:28;;;;;;7067:14;;-1:-1:-1;;;;;7067:14:0;;-1:-1:-1;7230:24:0;7245:8;7230:14;:24::i;:::-;7339:1;7331:5;:9;7327:934;;;7564:18;7576:5;7564:11;:18::i;:::-;8218:31;;7540:42;;-1:-1:-1;7622:21:0;;;;-1:-1:-1;;;;;;8218:15:0;;;:31;;;;;7622:21;;8218:31;;;;7622:21;8218:15;:31;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;8218:31:0;7327:934;-1:-1:-1;8797:30:0;;8574:18;;;;8797:10;;:30;;;;;8574:18;;8797:30;;;;8574:18;8797:10;:30;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;8873:46:0;;;;;;;;;;;;8908:10;8873:46;;;;;;;;;;;;;;;-1:-1:-1;8939:5:0;;6251:2701;-1:-1:-1;;;;;;;6251:2701:0:o;4982:177::-;5102:19;;:49;;;;;;-1:-1:-1;;;;;5102:49:0;;;;;;;;;;;;;;;:19;;;;;:28;;:49;;;;;:19;;:49;;;;;;;:19;;:49;;;5:2:-1;;;;30:1;27;20:12;9283:127:0;9379:18;;;9354:4;9379:18;;;;;;:22;;9283:127::o;5947:192::-;6026:24;6041:8;6026:14;:24::i;:::-;6061:28;6071:7;6080:8;6061:9;:28::i;:::-;6105:26;;;;;;;;;;;;;;;;;5947:192;;:::o;9711:645::-;10079:18;;;;9810:7;;;;10079:18;;;;;10073:3;:24;10069:97;;;-1:-1:-1;10136:18:0;;;;;;;;;10130:3;:24;10069:97;10220:22;;;;10292:17;;;;10185:163;;10220:22;;;;;10257:20;;;;;;10292:17;;10324:13;10185:20;:163::i;9074:103::-;9143:26;;;;:16;:26;;;;;9136:33;;-1:-1:-1;;9136:33:0;;;;;;;;;;;;;;-1:-1:-1;;9136:33:0;;;9074:103::o;12356:489::-;12821:8;;12832:5;12812:17;;:25;;12356:489::o;10610:1648::-;10822:7;;;;11178:27;;;11174:1077;;11357:12;11350:19;;;;11174:1077;11585:14;11562:12;11555:45;11529:71;;11928:9;11903:14;11877:16;:41;:61;;;;;;;;11849:89;;12176:18;12158:14;12151:43;12129:65;;12226:12;12211:28;;11174:1077;10610:1648;;;;;;;;;:::o;19145:1982::-;;;;;;;;;-1:-1:-1;19145:1982:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o

bzzr://4598a2b07752b633d610580c1646234c59bd1b89ed31395bef70aca245600e3b