// File: contracts/ERC721/ERC721Basic.sol pragma solidity ^0.4.18; /** * @title ERC721 Non-Fungible Token Standard basic interface * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md */ contract ERC721Basic { event Transfer(address indexed _from, address indexed _to, uint256 _tokenId); event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId); event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved); function balanceOf(address _owner) public view returns (uint256 _balance); function ownerOf(uint256 _tokenId) public view returns (address _owner); function exists(uint256 _tokenId) public view returns (bool _exists); function approve(address _to, uint256 _tokenId) public; function getApproved(uint256 _tokenId) public view returns (address _operator); function setApprovalForAll(address _operator, bool _approved) public; function isApprovedForAll(address _owner, address _operator) public view returns (bool); function transferFrom(address _from, address _to, uint256 _tokenId) public; function safeTransferFrom(address _from, address _to, uint256 _tokenId) public; function safeTransferFrom( address _from, address _to, uint256 _tokenId, bytes _data ) public; } // File: contracts/ERC721/ERC721.sol pragma solidity ^0.4.18; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md */ contract ERC721Enumerable is ERC721Basic { function totalSupply() public view returns (uint256); function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256 _tokenId); function tokenByIndex(uint256 _index) public view returns (uint256); } /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md */ contract ERC721Metadata is ERC721Basic { function name() public view returns (string _name); function symbol() public view returns (string _symbol); function tokenURI(uint256 _tokenId) public view returns (string); } /** * @title ERC-721 Non-Fungible Token Standard, full implementation interface * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md */ contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata { } // File: contracts/ERC721/DeprecatedERC721.sol pragma solidity ^0.4.18; /** * @title ERC-721 methods shipped in OpenZeppelin v1.7.0, removed in the latest version of the standard * @dev Only use this interface for compatibility with previously deployed contracts * @dev Use ERC721 for interacting with new contracts which are standard-compliant */ contract DeprecatedERC721 is ERC721 { function takeOwnership(uint256 _tokenId) public; function transfer(address _to, uint256 _tokenId) public; function tokensOf(address _owner) public view returns (uint256[]); } // File: contracts/ERC721/ERC721Receiver.sol pragma solidity ^0.4.18; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ contract ERC721Receiver { /** * @dev Magic value to be returned upon successful reception of an NFT * Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`, * which can be also obtained as `ERC721Receiver(0).onERC721Received.selector` */ bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba; /** * @notice Handle the receipt of an NFT * @dev The ERC721 smart contract calls this function on the recipient * after a `safetransfer`. 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)"))` */ function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4); } // File: contracts/utils/math/SafeMath.sol pragma solidity ^0.4.18; /** * @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) { if (a == 0) { return 0; } uint256 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) { uint256 c = a + b; assert(c >= a); return c; } } // File: contracts/utils/AddressUtils.sol pragma solidity ^0.4.18; /** * Utility library of inline functions on addresses */ library AddressUtils { /** * Returns whether the target address is a contract * @dev This function will return false if invoked during the constructor of a contract, * as the code is not actually created until after the constructor finishes. * @param addr address to check * @return whether the target address is a contract */ function isContract(address addr) internal view returns (bool) { uint256 size; // XXX Currently there is no better way to check if there is a contract in an address // than to check the size of the code at that address. // See https://ethereum.stackexchange.com/a/14016/36603 // for more details about how this works. // TODO Check this again before the Serenity release, because all addresses will be // contracts then. assembly { size := extcodesize(addr) } // solium-disable-line security/no-inline-assembly return size > 0; } } // File: contracts/ERC721/ERC721BasicToken.sol pragma solidity ^0.4.18; /** * @title ERC721 Non-Fungible Token Standard basic implementation * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md */ contract ERC721BasicToken is ERC721Basic { using SafeMath for uint256; using AddressUtils for address; // Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))` // which can be also obtained as `ERC721Receiver(0).onERC721Received.selector` bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba; // Mapping from token ID to owner mapping (uint256 => address) internal tokenOwner; // Mapping from token ID to approved address mapping (uint256 => address) internal tokenApprovals; // Mapping from owner to number of owned token mapping (address => uint256) internal ownedTokensCount; // Mapping from owner to operator approvals mapping (address => mapping (address => bool)) internal operatorApprovals; /** * @dev Guarantees msg.sender is owner of the given token * @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender */ modifier onlyOwnerOf(uint256 _tokenId) { require(ownerOf(_tokenId) == msg.sender); _; } /** * @dev Checks msg.sender can transfer a token, by being owner, approved, or operator * @param _tokenId uint256 ID of the token to validate */ modifier canTransfer(uint256 _tokenId) { require(isApprovedOrOwner(msg.sender, _tokenId)); _; } /** * @dev Gets the balance of the specified address * @param _owner address to query the balance of * @return uint256 representing the amount owned by the passed address */ function balanceOf(address _owner) public view returns (uint256) { require(_owner != address(0)); return ownedTokensCount[_owner]; } /** * @dev Gets the owner of the specified token ID * @param _tokenId uint256 ID of the token to query the owner of * @return owner address currently marked as the owner of the given token ID */ function ownerOf(uint256 _tokenId) public view returns (address) { address owner = tokenOwner[_tokenId]; require(owner != address(0)); return owner; } /** * @dev Returns whether the specified token exists * @param _tokenId uint256 ID of the token to query the existance of * @return whether the token exists */ function exists(uint256 _tokenId) public view returns (bool) { address owner = tokenOwner[_tokenId]; return owner != address(0); } /** * @dev Approves another address to transfer the given token ID * @dev The zero address indicates there is no approved address. * @dev There can only be one approved address per token at a given time. * @dev Can only be called by the token owner or an approved operator. * @param _to address to be approved for the given token ID * @param _tokenId uint256 ID of the token to be approved */ function approve(address _to, uint256 _tokenId) public { address owner = ownerOf(_tokenId); require(_to != owner); require(msg.sender == owner || isApprovedForAll(owner, msg.sender)); if (getApproved(_tokenId) != address(0) || _to != address(0)) { tokenApprovals[_tokenId] = _to; Approval(owner, _to, _tokenId); } } /** * @dev Gets the approved address for a token ID, or zero if no address set * @param _tokenId uint256 ID of the token to query the approval of * @return address currently approved for a the given token ID */ function getApproved(uint256 _tokenId) public view returns (address) { return tokenApprovals[_tokenId]; } /** * @dev Sets or unsets the approval of a given operator * @dev An operator is allowed to transfer all tokens of the sender on their behalf * @param _to operator address to set the approval * @param _approved representing the status of the approval to be set */ function setApprovalForAll(address _to, bool _approved) public { require(_to != msg.sender); operatorApprovals[msg.sender][_to] = _approved; ApprovalForAll(msg.sender, _to, _approved); } /** * @dev Tells whether an operator is approved by a given owner * @param _owner owner address which you want to query the approval of * @param _operator operator address which you want to query the approval of * @return bool whether the given operator is approved by the given owner */ function isApprovedForAll(address _owner, address _operator) public view returns (bool) { return operatorApprovals[_owner][_operator]; } /** * @dev Transfers the ownership of a given token ID to another address * @dev Usage of this method is discouraged, use `safeTransferFrom` whenever possible * @dev Requires the msg sender to be the owner, approved, or operator * @param _from current owner of the token * @param _to address to receive the ownership of the given token ID * @param _tokenId uint256 ID of the token to be transferred */ function transferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) { require(_from != address(0)); require(_to != address(0)); clearApproval(_from, _tokenId); removeTokenFrom(_from, _tokenId); addTokenTo(_to, _tokenId); Transfer(_from, _to, _tokenId); } /** * @dev Safely transfers the ownership of a given token ID to another address * @dev If the target address is a contract, it must implement `onERC721Received`, * which is called upon a safe transfer, and return the magic value * `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise, * the transfer is reverted. * @dev Requires the msg sender to be the owner, approved, or operator * @param _from current owner of the token * @param _to address to receive the ownership of the given token ID * @param _tokenId uint256 ID of the token to be transferred */ function safeTransferFrom( address _from, address _to, uint256 _tokenId ) public canTransfer(_tokenId) { safeTransferFrom(_from, _to, _tokenId, ""); } /** * @dev Safely transfers the ownership of a given token ID to another address * @dev If the target address is a contract, it must implement `onERC721Received`, * which is called upon a safe transfer, and return the magic value * `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise, * the transfer is reverted. * @dev Requires the msg sender to be the owner, approved, or operator * @param _from current owner of the token * @param _to address to receive the ownership of the given token ID * @param _tokenId uint256 ID of the token to be transferred * @param _data bytes data to send along with a safe transfer check */ function safeTransferFrom( address _from, address _to, uint256 _tokenId, bytes _data ) public canTransfer(_tokenId) { transferFrom(_from, _to, _tokenId); require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data)); } /** * @dev Returns whether the given spender can transfer a given token ID * @param _spender address of the spender to query * @param _tokenId uint256 ID of the token to be transferred * @return bool whether the msg.sender is approved for the given token ID, * is an operator of the owner, or is the owner of the token */ function isApprovedOrOwner(address _spender, uint256 _tokenId) internal view returns (bool) { address owner = ownerOf(_tokenId); return _spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender); } /** * @dev Internal function to mint a new token * @dev Reverts if the given token ID already exists * @param _to The address that will own the minted token * @param _tokenId uint256 ID of the token to be minted by the msg.sender */ function _mint(address _to, uint256 _tokenId) internal { require(_to != address(0)); addTokenTo(_to, _tokenId); Transfer(address(0), _to, _tokenId); } /** * @dev Internal function to burn a specific token * @dev Reverts if the token does not exist * @param _tokenId uint256 ID of the token being burned by the msg.sender */ function _burn(address _owner, uint256 _tokenId) internal { clearApproval(_owner, _tokenId); removeTokenFrom(_owner, _tokenId); Transfer(_owner, address(0), _tokenId); } /** * @dev Internal function to clear current approval of a given token ID * @dev Reverts if the given address is not indeed the owner of the token * @param _owner owner of the token * @param _tokenId uint256 ID of the token to be transferred */ function clearApproval(address _owner, uint256 _tokenId) internal { require(ownerOf(_tokenId) == _owner); if (tokenApprovals[_tokenId] != address(0)) { tokenApprovals[_tokenId] = address(0); Approval(_owner, address(0), _tokenId); } } /** * @dev Internal function to add a token ID to the list of a given address * @param _to address representing the new owner of the given token ID * @param _tokenId uint256 ID of the token to be added to the tokens list of the given address */ function addTokenTo(address _to, uint256 _tokenId) internal { require(tokenOwner[_tokenId] == address(0)); tokenOwner[_tokenId] = _to; ownedTokensCount[_to] = ownedTokensCount[_to].add(1); } /** * @dev Internal function to remove a token ID from the list of a given address * @param _from address representing the previous owner of the given token ID * @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function removeTokenFrom(address _from, uint256 _tokenId) internal { require(ownerOf(_tokenId) == _from); ownedTokensCount[_from] = ownedTokensCount[_from].sub(1); tokenOwner[_tokenId] = address(0); } /** * @dev Internal function to invoke `onERC721Received` on a target address * @dev The call is not executed if the target address is not a contract * @param _from address representing the previous owner of the given token ID * @param _to target address that will receive the tokens * @param _tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return whether the call correctly returned the expected magic value */ function checkAndCallSafeTransfer( address _from, address _to, uint256 _tokenId, bytes _data ) internal returns (bool) { if (!_to.isContract()) { return true; } bytes4 retval = ERC721Receiver(_to).onERC721Received(_from, _tokenId, _data); return (retval == ERC721_RECEIVED); } } // File: contracts/ERC721/ERC721Token.sol pragma solidity ^0.4.18; /** * @title Full ERC721 Token * This implementation includes all the required and some optional functionality of the ERC721 standard * Moreover, it includes approve all functionality using operator terminology * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md */ contract ERC721Token is ERC721, ERC721BasicToken { // Token name string internal name_; // Token symbol string internal symbol_; // Mapping from owner to list of owned token IDs mapping (address => uint256[]) internal ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) internal ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] internal allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) internal allTokensIndex; // Optional mapping for token URIs mapping(uint256 => string) internal tokenURIs; /** * @dev Constructor function */ function ERC721Token(string _name, string _symbol) public { name_ = _name; symbol_ = _symbol; } /** * @dev Gets the token name * @return string representing the token name */ function name() public view returns (string) { return name_; } /** * @dev Gets the token symbol * @return string representing the token symbol */ function symbol() public view returns (string) { return symbol_; } /** * @dev Returns an URI for a given token ID * @dev Throws if the token ID does not exist. May return an empty string. * @param _tokenId uint256 ID of the token to query */ function tokenURI(uint256 _tokenId) public view returns (string) { require(exists(_tokenId)); return tokenURIs[_tokenId]; } /** * @dev Gets the token ID at a given index of the tokens list of the requested owner * @param _owner address owning the tokens list to be accessed * @param _index uint256 representing the index to be accessed of the requested tokens list * @return uint256 token ID at the given index of the tokens list owned by the requested address */ function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) { require(_index < balanceOf(_owner)); return ownedTokens[_owner][_index]; } /** * @dev Gets the total amount of tokens stored by the contract * @return uint256 representing the total amount of tokens */ function totalSupply() public view returns (uint256) { return allTokens.length; } /** * @dev Gets the token ID at a given index of all the tokens in this contract * @dev Reverts if the index is greater or equal to the total number of tokens * @param _index uint256 representing the index to be accessed of the tokens list * @return uint256 token ID at the given index of the tokens list */ function tokenByIndex(uint256 _index) public view returns (uint256) { require(_index < totalSupply()); return allTokens[_index]; } /** * @dev Internal function to set the token URI for a given token * @dev Reverts if the token ID does not exist * @param _tokenId uint256 ID of the token to set its URI * @param _uri string URI to assign */ function _setTokenURI(uint256 _tokenId, string _uri) internal { require(exists(_tokenId)); tokenURIs[_tokenId] = _uri; } /** * @dev Internal function to add a token ID to the list of a given address * @param _to address representing the new owner of the given token ID * @param _tokenId uint256 ID of the token to be added to the tokens list of the given address */ function addTokenTo(address _to, uint256 _tokenId) internal { super.addTokenTo(_to, _tokenId); uint256 length = ownedTokens[_to].length; ownedTokens[_to].push(_tokenId); ownedTokensIndex[_tokenId] = length; } /** * @dev Internal function to remove a token ID from the list of a given address * @param _from address representing the previous owner of the given token ID * @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function removeTokenFrom(address _from, uint256 _tokenId) internal { super.removeTokenFrom(_from, _tokenId); uint256 tokenIndex = ownedTokensIndex[_tokenId]; uint256 lastTokenIndex = ownedTokens[_from].length.sub(1); uint256 lastToken = ownedTokens[_from][lastTokenIndex]; ownedTokens[_from][tokenIndex] = lastToken; ownedTokens[_from][lastTokenIndex] = 0; // Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to // be zero. Then we can make sure that we will remove _tokenId from the ownedTokens list since we are first swapping // the lastToken to the first position, and then dropping the element placed in the last position of the list ownedTokens[_from].length--; ownedTokensIndex[_tokenId] = 0; ownedTokensIndex[lastToken] = tokenIndex; } /** * @dev Internal function to mint a new token * @dev Reverts if the given token ID already exists * @param _to address the beneficiary that will own the minted token * @param _tokenId uint256 ID of the token to be minted by the msg.sender */ function _mint(address _to, uint256 _tokenId) internal { super._mint(_to, _tokenId); allTokensIndex[_tokenId] = allTokens.length; allTokens.push(_tokenId); } /** * @dev Internal function to burn a specific token * @dev Reverts if the token does not exist * @param _owner owner of the token to burn * @param _tokenId uint256 ID of the token being burned by the msg.sender */ function _burn(address _owner, uint256 _tokenId) internal { super._burn(_owner, _tokenId); // Clear metadata (if any) if (bytes(tokenURIs[_tokenId]).length != 0) { delete tokenURIs[_tokenId]; } // Reorg all tokens array uint256 tokenIndex = allTokensIndex[_tokenId]; uint256 lastTokenIndex = allTokens.length.sub(1); uint256 lastToken = allTokens[lastTokenIndex]; allTokens[tokenIndex] = lastToken; allTokens[lastTokenIndex] = 0; allTokens.length--; allTokensIndex[_tokenId] = 0; allTokensIndex[lastToken] = tokenIndex; } } // File: contracts/DeedRepository.sol pragma solidity ^0.4.17; /** * @title Repository of ERC721 Deeds * This contract contains the list of deeds registered by users. * This is a demo to show how tokens (deeds) can be minted and added * to the repository. */ contract DeedRepository is ERC721Token { /** * @dev Created a DeedRepository with a name and symbol * @param _name string represents the name of the repository * @param _symbol string represents the symbol of the repository */ function DeedRepository(string _name, string _symbol) public ERC721Token(_name, _symbol) {} /** * @dev Public function to register a new deed * @dev Call the ERC721Token minter * @param _tokenId uint256 represents a specific deed * @param _uri string containing metadata/uri */ function registerDeed(uint256 _tokenId, string _uri) public { _mint(msg.sender, _tokenId); addDeedMetadata(_tokenId, _uri); emit DeedRegistered(msg.sender, _tokenId); } /** * @dev Public function to add metadata to a deed * @param _tokenId represents a specific deed * @param _uri text which describes the characteristics of a given deed * @return whether the deed metadata was added to the repository */ function addDeedMetadata(uint256 _tokenId, string _uri) public returns(bool){ _setTokenURI(_tokenId, _uri); return true; } /** * @dev Event is triggered if deed/token is registered * @param _by address of the registrar * @param _tokenId uint256 represents a specific deed */ event DeedRegistered(address _by, uint256 _tokenId); } // File: contracts/AuctionRepository.sol pragma solidity ^0.4.17; /** * @title Auction Repository * This contracts allows auctions to be created for non-fungible tokens * Moreover, it includes the basic functionalities of an auction house */ contract AuctionRepository { // Array with all auctions Auction[] public auctions; // Mapping from auction index to user bids mapping(uint256 => Bid[]) public auctionBids; // Mapping from owner to a list of owned auctions mapping(address => uint[]) public auctionOwner; // Bid struct to hold bidder and amount struct Bid { address from; uint256 amount; } // Auction struct which holds all the required info struct Auction { string name; uint256 blockDeadline; uint256 startPrice; string metadata; uint256 deedId; address deedRepositoryAddress; address owner; bool active; bool finalized; } /** * @dev Guarantees msg.sender is owner of the given auction * @param _auctionId uint ID of the auction to validate its ownership belongs to msg.sender */ modifier isOwner(uint _auctionId) { require(auctions[_auctionId].owner == msg.sender); _; } /** * @dev Guarantees this contract is owner of the given deed/token * @param _deedRepositoryAddress address of the deed repository to validate from * @param _deedId uint256 ID of the deed which has been registered in the deed repository */ modifier contractIsDeedOwner(address _deedRepositoryAddress, uint256 _deedId) { address deedOwner = DeedRepository(_deedRepositoryAddress).ownerOf(_deedId); require(deedOwner == address(this)); _; } /** * @dev Disallow payments to this contract directly */ function() public{ revert(); } /** * @dev Gets the length of auctions * @return uint representing the auction count */ function getCount() public constant returns(uint) { return auctions.length; } /** * @dev Gets the bid counts of a given auction * @param _auctionId uint ID of the auction */ function getBidsCount(uint _auctionId) public constant returns(uint) { return auctionBids[_auctionId].length; } /** * @dev Gets an array of owned auctions * @param _owner address of the auction owner */ function getAuctionsOf(address _owner) public constant returns(uint[]) { uint[] memory ownedAuctions = auctionOwner[_owner]; return ownedAuctions; } /** * @dev Gets an array of owned auctions * @param _auctionId uint of the auction owner * @return amount uint256, address of last bidder */ function getCurrentBid(uint _auctionId) public constant returns(uint256, address) { uint bidsLength = auctionBids[_auctionId].length; // if there are bids refund the last bid if( bidsLength > 0 ) { Bid memory lastBid = auctionBids[_auctionId][bidsLength - 1]; return (lastBid.amount, lastBid.from); } return (0, 0); } /** * @dev Gets the total number of auctions owned by an address * @param _owner address of the owner * @return uint total number of auctions */ function getAuctionsCountOfOwner(address _owner) public constant returns(uint) { return auctionOwner[_owner].length; } /** * @dev Gets the info of a given auction which are stored within a struct * @param _auctionId uint ID of the auction * @return string name of the auction * @return uint256 timestamp of the auction in which it expires * @return uint256 starting price of the auction * @return string representing the metadata of the auction * @return uint256 ID of the deed registered in DeedRepository * @return address Address of the DeedRepository * @return address owner of the auction * @return bool whether the auction is active * @return bool whether the auction is finalized */ function getAuctionById(uint _auctionId) public constant returns( string name, uint256 blockDeadline, uint256 startPrice, string metadata, uint256 deedId, address deedRepositoryAddress, address owner, bool active, bool finalized) { Auction memory auc = auctions[_auctionId]; return ( auc.name, auc.blockDeadline, auc.startPrice, auc.metadata, auc.deedId, auc.deedRepositoryAddress, auc.owner, auc.active, auc.finalized); } /** * @dev Creates an auction with the given informatin * @param _deedRepositoryAddress address of the DeedRepository contract * @param _deedId uint256 of the deed registered in DeedRepository * @param _auctionTitle string containing auction title * @param _metadata string containing auction metadata * @param _startPrice uint256 starting price of the auction * @param _blockDeadline uint is the timestamp in which the auction expires * @return bool whether the auction is created */ function createAuction(address _deedRepositoryAddress, uint256 _deedId, string _auctionTitle, string _metadata, uint256 _startPrice, uint _blockDeadline) public contractIsDeedOwner(_deedRepositoryAddress, _deedId) returns(bool) { uint auctionId = auctions.length; Auction memory newAuction; newAuction.name = _auctionTitle; newAuction.blockDeadline = _blockDeadline; newAuction.startPrice = _startPrice; newAuction.metadata = _metadata; newAuction.deedId = _deedId; newAuction.deedRepositoryAddress = _deedRepositoryAddress; newAuction.owner = msg.sender; newAuction.active = true; newAuction.finalized = false; auctions.push(newAuction); auctionOwner[msg.sender].push(auctionId); emit AuctionCreated(msg.sender, auctionId); return true; } function approveAndTransfer(address _from, address _to, address _deedRepositoryAddress, uint256 _deedId) internal returns(bool) { DeedRepository remoteContract = DeedRepository(_deedRepositoryAddress); remoteContract.approve(_to, _deedId); remoteContract.transferFrom(_from, _to, _deedId); return true; } /** * @dev Cancels an ongoing auction by the owner * @dev Deed is transfered back to the auction owner * @dev Bidder is refunded with the initial amount * @param _auctionId uint ID of the created auction */ function cancelAuction(uint _auctionId) public isOwner(_auctionId) { Auction memory myAuction = auctions[_auctionId]; uint bidsLength = auctionBids[_auctionId].length; // if there are bids refund the last bid if( bidsLength > 0 ) { Bid memory lastBid = auctionBids[_auctionId][bidsLength - 1]; if(!lastBid.from.send(lastBid.amount)) { revert(); } } // approve and transfer from this contract to auction owner if(approveAndTransfer(address(this), myAuction.owner, myAuction.deedRepositoryAddress, myAuction.deedId)){ auctions[_auctionId].active = false; emit AuctionCanceled(msg.sender, _auctionId); } } /** * @dev Finalized an ended auction * @dev The auction should be ended, and there should be at least one bid * @dev On success Deed is transfered to bidder and auction owner gets the amount * @param _auctionId uint ID of the created auction */ function finalizeAuction(uint _auctionId) public { Auction memory myAuction = auctions[_auctionId]; uint bidsLength = auctionBids[_auctionId].length; // 1. if auction not ended just revert if( block.timestamp < myAuction.blockDeadline ) revert(); // if there are no bids cancel if(bidsLength == 0) { cancelAuction(_auctionId); }else{ // 2. the money goes to the auction owner Bid memory lastBid = auctionBids[_auctionId][bidsLength - 1]; if(!myAuction.owner.send(lastBid.amount)) { revert(); } // approve and transfer from this contract to the bid winner if(approveAndTransfer(address(this), lastBid.from, myAuction.deedRepositoryAddress, myAuction.deedId)){ auctions[_auctionId].active = false; auctions[_auctionId].finalized = true; emit AuctionFinalized(msg.sender, _auctionId); } } } /** * @dev Bidder sends bid on an auction * @dev Auction should be active and not ended * @dev Refund previous bidder if a new bid is valid and placed. * @param _auctionId uint ID of the created auction */ function bidOnAuction(uint _auctionId) public payable { uint256 ethAmountSent = msg.value; // owner can't bid on their auctions Auction memory myAuction = auctions[_auctionId]; if(myAuction.owner == msg.sender) revert(); // if auction is expired if( block.timestamp > myAuction.blockDeadline ) revert(); uint bidsLength = auctionBids[_auctionId].length; uint256 tempAmount = myAuction.startPrice; Bid memory lastBid; // there are previous bids if( bidsLength > 0 ) { lastBid = auctionBids[_auctionId][bidsLength - 1]; tempAmount = lastBid.amount; } // check if amound is greater than previous amount if( ethAmountSent < tempAmount ) revert(); // refund the last bidder if( bidsLength > 0 ) { if(!lastBid.from.send(lastBid.amount)) { revert(); } } // insert bid Bid memory newBid; newBid.from = msg.sender; newBid.amount = ethAmountSent; auctionBids[_auctionId].push(newBid); emit BidSuccess(msg.sender, _auctionId); } event BidSuccess(address _from, uint _auctionId); // AuctionCreated is fired when an auction is created event AuctionCreated(address _owner, uint _auctionId); // AuctionCanceled is fired when an auction is canceled event AuctionCanceled(address _owner, uint _auctionId); // AuctionFinalized is fired when an auction is finalized event AuctionFinalized(address _owner, uint _auctionId); }
0.4.24