Contract Source Code:
File 1 of 1 : Market
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/*
'########::'########:'########::'##::::'##:
##.... ##: ##.....:: ##.... ##: ##:::: ##:
##:::: ##: ##::::::: ##:::: ##: ##:::: ##:
########:: ######::: ########:: ##:::: ##:
##.... ##: ##...:::: ##.. ##::: ##:::: ##:
##:::: ##: ##::::::: ##::. ##:: ##:::: ##:
########:: ########: ##:::. ##:. #######::
........:::........::..:::::..:::.......:::
*/
interface IModule {
function getModule(uint module_) external view returns (address);
}
/**
* @notice Connection's interface with Roles SC
*/
interface IRoles {
function isVerifiedUser(address user_) external returns (bool);
function isModerator(address user_) external returns (bool);
function isUser(address user_) external returns (bool);
}
/**
* @notice Connection's interface with ERC20 SC
*/
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address from, address to,uint256 amount) external returns (bool);
}
/**
* @notice Connection's interface with ERC721 SC
*/
interface IERC721 {
function ownerOf(uint256 tokenId) external view returns (address owner);
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function getRoyalties() external view returns (uint);
function deployer() external view returns (address);
}
/**
* @notice The interface to implement in the market contract
*/
interface IMarket {
event OfferCreated(uint256 id, string hiddenId);
event OfferCompleted(uint id, string hiddenId, address buyer);
event OfferApproved(uint256 offerId);
event OfferCancelled(uint256 offerId);
}
/**
* @notice Paper interface
*/
interface IPaperKeyManager {
function register(address _paperKey) external returns (bool);
function verify( bytes32 _hash, bytes32 _nonce, bytes calldata _signature) external returns (bool);
}
/**
* @notice Market logic
*/
contract Market is IMarket {
/**
* @notice The roles interface
*/
IRoles rolesContract;
/**
* @notice Only-paper interface
*/
IPaperKeyManager paperKeyManager;
/**
* @notice Amount of offers (counter)
*/
uint256 public offersCount;
/**
* @notice List of offers
*/
mapping(uint256 => Offer) public offersList;
/**
* @notice List of actions winners
*/
mapping(uint256 => address) public auctionWinners;
/**
* @notice List of approved offers
*/
mapping(uint256 => bool) public approvedOffers;
/**
* @notice If of valid ERC20 tokens
*/
mapping(address => bool) public validERC20;
/**
* @notice List of ERC721 approved
*/
mapping(address => bool) public approvedERC721;
/**
* @notice Module Manager instance
*/
IModule moduleManager;
/**
* @notice wallet to which royalties will be sent
*/
address public beruWallet;
/**
* @notice percentaje of beru's royalties
*/
uint public beruRoyalies;
/**
* @notice Struct created when at leas an ERC721 is put up for { sell / auction }
* @param info encoded params {}
* @param collection encoded collection's Ids
* @param tokenId encoded token's Ids
* @param collectionAddress array of collectionAddreses
* @param paymentToken Token to accept for the listing
* @param seller The address that sells the NFT (owner or approved)
*/
struct Offer {
uint256 info;
uint256 tokenIds;
address[] collectionAddresses;
address paymentToken;
address seller;
}
//! --------------------------------------------------------------------------- EVENTS ---------------------------------------------------------------------------
/**
* @notice Event triggered when someone bid in an auction
*/
event BiddedForAuction(address who, uint256 offerId, uint256 amount, string id);
/**
* @notice Fired when an auction winner is changed because the wallet has no funds (or not sufficient)
*/
event ChangedWinner(uint offerId, address newWinner);
/**
* @notice Event triggered when an offer changes status { approved / deprecated }
*/
event ChangeStatusERC721(address ERC721, address who, bool newStatus);
/**
* @notice Event triggered when an offer is activated
*/
event ApprovedOffer(uint offerId, address who);
/**
* @notice Event triggered when an ERC20 address is validated (or not)
*/
event ERC20Validated(address token, bool valid);
/**
* @notice Event triggered when the funds were sent
*/
event FundsSended(uint256 beruRoyalties , uint256 creatorsRoyalties , uint256 sellerFunds);
/**
*@notice Event triggered when the royalties wer sent
*/
event RoyaltiesSended(address to, uint256 amount);
/**
* @notice Event triggered when beruWallet was set
*/
event BeruWalletSet(address newBeruWallet);
/**
* @notice Event triggered when beruRoyalties was set
*/
event BeruRoyaliesSet(uint256 newRoyalties);
/**
*@notice Event triggered when a minBid was set in an auction
*/
event MinBidSet(uint256 offerId, uint256 value);
/**
* @notice Event triggered when an offer ends with paper
*/
event PaperOfferCompleted(uint id, string hiddenId, address buyer);
//! --------------------------------------------------------------------------- MODIFIERS ---------------------------------------------------------------------------
/**
* @notice Only offers that are approved or created by a moderator
* @param offerId_ Offer id to check if approved
*/
modifier onlyApprovedOffers(uint256 offerId_) {
require(
(approvedOffers[offerId_] == true) ||
(rolesContract.isVerifiedUser(offersList[offerId_].seller)),
'M101'
);
_;
}
/**
*@notice the offer must be active
*@param offerId_ the offer to check if is active
*/
modifier onlyActiveOffers(uint256 offerId_) {
require(isActive(offerId_), 'M113');
_;
}
/**
* @notice Only a moderator can call
*/
modifier onlyModerator {
require(rolesContract.isModerator(msg.sender), 'M120');
_;
}
/**
* @notice only offer must be an auction
* @param offerId_ the offer to check if is an auction
*/
modifier onlyAuctions(uint256 offerId_) {
require(isAuction(offerId_), 'M110');
_;
}
/**
*@notice only Votation Module can call
*/
modifier onlyVotationModule {
require(msg.sender == moduleManager.getModule(3), 'M133');
_;
}
/**
* @notice only paper modifier
*/
modifier onlyPaper(bytes32 _hash, bytes32 _nonce, bytes calldata _signature) {
bool success = paperKeyManager.verify(_hash, _nonce, _signature);
require(success, 'Failed to verify signature');
_;
}
/**
* @notice Builder
* @param module_ Module manager
*/
constructor(address module_) {
moduleManager = IModule(module_);
address roles = moduleManager.getModule(0);
rolesContract = IRoles(roles);
}
/**
* @notice Function to refresh the addresses used in this contract
*/
function refresh() public onlyVotationModule {
address roles = moduleManager.getModule(0);
rolesContract = IRoles(roles);
}
//! --------------------------------------------------------------------------- PAPER -----------------------------------------------------------------------------
/**
* @notice only paper register function
* @param _paperKey token obtained after register the SC paper in the paper developer dashboard
*/
function registerPaperKey(address _paperKey) external onlyVotationModule() {
require(paperKeyManager.register(_paperKey), 'Error registering key');
}
/**
* @notice function to set paperKeyManager
* @param _paperKeyManagerAddress address from which to instantiate paper key manager
*/
function setPaperKeyManager(address _paperKeyManagerAddress) public onlyVotationModule() {
paperKeyManager = IPaperKeyManager(_paperKeyManagerAddress);
}
/**
* @notice Eligibility method
* @param offerId_ The offer id to check
*/
function eligibilityMethod(uint offerId_) onlyActiveOffers(offerId_) public view returns (string memory) {
Offer memory offer = offersList[offerId_];
uint[] memory tokenIds = getDecodedTokenIds(offerId_);
for (uint256 i; i < offer.collectionAddresses.length; i++) {
require(IERC721(offer.collectionAddresses[i]).ownerOf(tokenIds[i]) == offer.seller, 'E413');
require(IERC721(offer.collectionAddresses[i]).isApprovedForAll(offer.seller, address(this)), 'M118');
}
return '';
}
/**
* @notice function to validate params from a purchase
* @param offerId_ The offer id to check
* @param directBuy_ Indicate if is a direct purchase {just for auctions}
* @param buyer_ the user who used onlyPaper to buy
*/
function _paperValidateBuyParams(uint256 offerId_, bool directBuy_, address buyer_) internal view {
Offer memory offer = offersList[offerId_];
if (isAuction(offerId_) && !directBuy_) {
require(!validateAuctionTime(offerId_), 'M111');
require(buyer_ == auctionWinners[offerId_], 'M112');
}
if (offer.paymentToken == address(0)) {
require(msg.value >= getValue(offerId_), 'M114');
} else {
require(IERC20(offer.paymentToken).allowance(msg.sender, address(this) ) >= getValue(offerId_),'M115');
}
}
/**
* @notice Function to transanc all tokens bought to buyer
* @param offerId_ the user who used onlyPaper to buy
* @param buyer_ user who bought the
*/
function _paperTransactAllTokens(uint256 offerId_, address buyer_) internal {
Offer memory offer = offersList[offerId_];
uint256[] memory auxTokenIds = getDecodedTokenIds(offerId_);
for (uint256 i = 0; i < offer.collectionAddresses.length; i++) {
require(IERC721(offer.collectionAddresses[i]).ownerOf(auxTokenIds[i]) == offer.seller , 'E413');
require(IERC721(offer.collectionAddresses[i]).isApprovedForAll(offer.seller, address(this)), 'M118');
IERC721(offer.collectionAddresses[i]).safeTransferFrom(offer.seller, buyer_, auxTokenIds[i], 'M135');
}
}
/**
* @notice Buy offer method modified to use only paper
* @param offerId_ the offer to buy
* @param buyer_ the user who used onlyPaper to buy
* @param directBuy_ this is just for auctions. Indicate if the if is a direct purchase
* @param hiddenId_ the Offer's fireBase Id.
* @param nonce_ variable used for onlyPaper methods
* @param signature_ valiable used for onlyPaper methods
*/
function buyWithPaper(
uint256 offerId_,
address buyer_,
bool directBuy_,
string memory hiddenId_,
bytes32 nonce_,
bytes calldata signature_
) public payable onlyActiveOffers(offerId_)
onlyPaper(keccak256(abi.encode(offerId_, buyer_, directBuy_, hiddenId_)), nonce_, signature_)
{
_paperValidateBuyParams(offerId_, directBuy_, buyer_);
setInactive(offerId_);
_splitFunds(offerId_, getValue(offerId_));
_paperTransactAllTokens(offerId_, buyer_);
emit PaperOfferCompleted(offerId_, hiddenId_, buyer_);
}
//! --------------------------------------------------------------------------- CREATE OFFER ---------------------------------------------------------------------------
/**
* @notice function to validate the params { all params } sent for create an offer
* @param isAuction_ indicate if the offer is going to be an auction or not
* @param endTime_ indicate the time when the offer will be end (just if is acution)
* @param minBid_ Min bid allowed
* @param tokenIds_ array of token's ids to sell
* @param value_ Value of the offer
* @param collectionAddresses_ array of collections's addresses
* @param paymentToken_ You can ask for USDT, DAI or Matic/Ether
*/
function _validateCreateParams(
bool isAuction_,
uint48 endTime_,
uint96 minBid_,
uint96 value_,
uint256[] memory tokenIds_,
address[] memory collectionAddresses_,
address paymentToken_
) internal view {
require (tokenIds_.length == collectionAddresses_.length , 'E806');
require(tokenIds_.length < 6,'M127');
require(value_ > 0, 'M102');
require(isValidERC20(paymentToken_), 'M106');
if (isAuction_){
require(endTime_ > block.timestamp + 3600,'M134');
require(value_ > minBid_, 'M103');
}
}
/**
* @notice function to validate the ownership of the tokens of an offer
* @param tokenIds_ array of token's ids
* @param collectionAddresses_ array of collecti's addresesss
* @return flag true if the offer have unapproved collection addresses
*/
function _validateOwnership(uint256[] memory tokenIds_, address[] memory collectionAddresses_) internal view returns (bool flag) {
for (uint256 i; i < collectionAddresses_.length; i++) {
require(IERC721(collectionAddresses_[i]).ownerOf(tokenIds_[i]) == msg.sender, 'E413');
require(IERC721(collectionAddresses_[i]).isApprovedForAll(msg.sender, address(this)), 'M118');
if (!approvedERC721[collectionAddresses_[i]] && !flag) flag = true;
}
}
/**
* @notice Function to create offers
* @param isAuction_ If it is auction
* @param endTime_ time when offers ends (just for auction)
* @param minBid_ Min bid allowed
* @param tokenIds_ array of token's ids to sell
* @param value_ Value of the offer
* @param collectionAddresses_ array of collections's addresses
* @param paymentToken_ You can ask for USDT, DAI or Matic/Ether
* @param hiddenId_ Offre's id in fireBase
*/
function createOffer(
bool isAuction_,
uint48 endTime_,
uint96 minBid_,
uint96 value_,
uint256[] memory tokenIds_,
address[] memory collectionAddresses_,
address paymentToken_,
string memory hiddenId_
) public {
_validateCreateParams(isAuction_, endTime_, minBid_, value_, tokenIds_, collectionAddresses_, paymentToken_);
bool notApproved = _validateOwnership(tokenIds_, collectionAddresses_);
if (!notApproved) approvedOffers[offersCount] = true;
offersList[offersCount] = Offer(
encodeInfo(isAuction_ ? 1 : 0, endTime_, minBid_, value_),
encode(tokenIds_),
collectionAddresses_,
paymentToken_,
msg.sender
);
emit OfferCreated(offersCount, hiddenId_);
offersCount++;
}
//! --------------------------------------------------------------------------- BUY OFFER ---------------------------------------------------------------------------
/**
* @notice function to validate params from a purchase
* @param offerId_ The offer id to check
* @param directBuy_ Indicate if is a direct purchase {just for auctions}
*/
function _validateBuyParams(uint256 offerId_, bool directBuy_) internal view {
Offer memory offer = offersList[offerId_];
if (isAuction(offerId_) && !directBuy_) {
require(!validateAuctionTime(offerId_), 'M111');
require(msg.sender == auctionWinners[offerId_], 'M112');
}
if (offer.paymentToken == address(0)) {
require(msg.value >= getValue(offerId_), 'M114');
} else {
require(IERC20(offer.paymentToken).allowance(msg.sender, address(this) ) >= getValue(offerId_),'M115');
}
}
/**
* @notice Function to transanc all tokens bought
* @param offerId_ The offer bought
*/
function _transactAllTokens(uint256 offerId_) internal {
Offer memory offer = offersList[offerId_];
uint256[] memory auxTokenIds = getDecodedTokenIds(offerId_);
for (uint256 i = 0; i < offer.collectionAddresses.length; i++) {
require(IERC721(offer.collectionAddresses[i]).ownerOf(auxTokenIds[i]) == offer.seller , 'E413');
require(IERC721(offer.collectionAddresses[i]).isApprovedForAll(offer.seller, address(this)), 'M118');
IERC721(offer.collectionAddresses[i]).safeTransferFrom(offer.seller, msg.sender, auxTokenIds[i], '');
}
}
/**
* @notice For buying a fixed offer & closing an auction
* @param offerId_ The offer to buy
* @param directBuy_ This is just for auctions. Indicate if the if is a direct purchase
* @param hiddenId_ The Offer's fireBase Id.
*/
function buyOffer(uint256 offerId_, bool directBuy_, string memory hiddenId_) public payable onlyActiveOffers(offerId_) onlyApprovedOffers(offerId_) {
_validateBuyParams(offerId_, directBuy_);
setInactive(offerId_);
_splitFunds(offerId_,getValue(offerId_)); //* ADDED
_transactAllTokens(offerId_);
emit OfferCompleted( offerId_, hiddenId_, msg.sender);
}
//! --------------------------------------------------------------------------- BID IN AUCTION ---------------------------------------------------------------------------
/**
* @notice Function to validate bid parameters to bid in an auction
* @param offerId_ The auction to check
* @param value_ The value to chek
*/
function _validateBidParams(uint256 offerId_, uint256 value_) internal view {
require((value_ > 0) && (getMinBid(offerId_) < value_), 'M121');
require(validateAuctionTime(offerId_),'M107');
}
/**
* @notice Function to validate if the msg.sender have enough balance to bid in an auction
* @param offerId_ The auction to check
* @param value_ The value to check
*/
function _validateUserBalance(uint256 offerId_, uint256 value_) internal view {
uint balance = getActualBalance(msg.sender, offersList[offerId_].paymentToken);
require(value_ < balance, 'M123');
}
/**
* @notice function that allows to bid in an auction
* @param offerId_ The auction id
* @param value_ The value to bid
*/
function bidForAuction(uint256 offerId_, uint256 value_, string memory id) public onlyActiveOffers(offerId_) onlyApprovedOffers(offerId_) onlyAuctions(offerId_) {
_validateBidParams(offerId_, value_);
_validateUserBalance(offerId_, value_);
setMinBid(offerId_, value_);
auctionWinners[offerId_] = msg.sender;
emit BiddedForAuction(msg.sender, offerId_, value_, id);
}
//! ------------------------------------------------------------------------- ROYALTIES --------------------------------------------------------------------------
/**
* @notice function to send ERC20 founds
* @param offerId_ offerId to check
* @param to_ who will receive the funds
* @param value_ the amount to send
*/
function _sendFunds(uint256 offerId_,address to_, uint256 value_) internal {
if (offersList[offerId_].paymentToken == address(0)) {
(bool success, ) = payable(to_).call{ value: value_ }("");
require(success, "M117");
} else {
require ( IERC20(offersList[offerId_].paymentToken).transferFrom(
msg.sender,
to_,
value_
), 'M120');
}
}
/**
* @notice Function to transfer royalies to Beru { wallet }
* @param value_ amount from which the commission percentage is calculated
* @return toBeru amount tranfered to beru
*/
function _sendRoyaltiesToBeru(uint256 offerId_, uint256 value_) internal returns (uint256 toBeru) {
toBeru = value_ * beruRoyalies / 1000 ; // %<0
_sendFunds(offerId_,beruWallet,toBeru);
emit RoyaltiesSended(beruWallet,toBeru);
}
/**
* @notice Function to send royalties to the NFT's creators
* @param offerId_ offer involved
* @param value_ price paid for the offer
* @return toCreators amount of roayalities transfered to creators
*/
function _sendRoyaltiesToCreators(uint256 offerId_, uint256 value_) internal returns (uint256 toCreators) {
address[] memory collectionAddrees_ = offersList[offerId_].collectionAddresses;
uint256 aux = value_ / collectionAddrees_.length;
for(uint i = 0; i < collectionAddrees_.length; i++) {
IERC721 proxy = IERC721(collectionAddrees_[i]);
if (proxy.getRoyalties() > 0) {
uint256 toTransfer = aux * proxy.getRoyalties() /1000;
_sendFunds(offerId_,proxy.deployer(), toTransfer);
toCreators += toTransfer;
emit RoyaltiesSended(proxy.deployer(), toTransfer);
}
}
}
/**
* @notice function to send founsd and royalties to collectio's creators, beru and the seller
* @param offerId_ the offer finished and bought
* @param value_ price paid for the offer
*/
function _splitFunds(uint256 offerId_, uint256 value_) internal {
uint256 royaltiesToBeru = _sendRoyaltiesToBeru(offerId_,value_);
uint256 royaltiesToCreators = _sendRoyaltiesToCreators(offerId_,value_);
uint256 fundsToSeller = value_ - royaltiesToBeru - royaltiesToCreators;
_sendFunds(offerId_, offersList[offerId_].seller , fundsToSeller);
emit FundsSended(royaltiesToBeru , royaltiesToCreators , fundsToSeller);
}
//! --------------------------------------------------------------------------- Encode & Decode ---------------------------------------------------------------------------
/**
* @notice Function to encode {auction, endtime, min, value} in info's encoded parameter
* @param isAuction_ True or false 0 / 1 if is auction
* @param endTime_ time when auctions ends (just for auctions)
* @param min_ min bid (just for auctions)
* @param value_ the offer's value for purchase
* @return finalValue_ the params encoded in a uint
*/
function encodeInfo(
uint isAuction_,
uint48 endTime_,
uint96 min_,
uint96 value_
) internal pure returns (uint finalValue_) {
finalValue_ = (1 * (10 ** 75)) + (1 * (10 ** 74)) + (isAuction_ * (10 ** 73)) + (uint(endTime_) * (10 ** 58)) + (uint(min_) * (10 ** 29)) + (value_);
}
/**
* @notice This is made to encode an array of uints and return just a uint
* @param array_ is an array that has the ids to encode
* @return aux have the ids encoded
*/
function encode(uint[] memory array_) public pure returns (uint256 aux) {
for (uint i; i < array_.length; ++i) {
aux += array_[i] * (10 ** (i * 15));
}
aux += array_.length * 1e75;
}
/**
* @notice This is made to decode a uint an retunrn an array of ids
* @param encoded_ This uint has encoded up to 5 ids that correspond to an array
* @return tokenIds This array have the ids decoded
*/
function decode(uint encoded_) public pure returns (uint[] memory tokenIds){
uint amount = (encoded_ / 1e75) % 1e15;
tokenIds = new uint[](amount);
for (uint i; i < amount; ++i){
tokenIds[i] = (encoded_ / (10 ** (i * 15)) % 1e15);
}
}
//! --------------------------------------------------------------------------- SETTERS ---------------------------------------------------------------------------
/**
* @notice validate an ERC721 collection
* @param erc721_ collection address
* @param validated_ new status of this ERC721 collection
*/
function validateERC721(address erc721_, bool validated_) public onlyModerator {
approvedERC721[erc721_] = validated_;
emit ChangeStatusERC721(erc721_, msg.sender, validated_);
}
/**
* @notice This is made to approve a valid offer
* @param offerId_ The offer id to validate
*/
function approveOffer(uint offerId_) public onlyModerator onlyActiveOffers(offerId_) {
approvedOffers[offerId_] = true;
emit OfferApproved(offerId_);
}
/**
* @notice function to set status active in an offer
* @param offerId_ offerId to set active
*/
function setInactive(uint offerId_) internal {
require(isActive(offerId_),'M108');
offersList[offerId_].info = offersList[offerId_].info - (1 * 1e74);
}
/**
* @notice function to set the minBid in an auction
* @param offerId_ the offer id to set the minBid
* @param min_ the value to set
*/
function setMinBid(uint offerId_, uint min_) internal {
offersList[offerId_].info = ((offersList[offerId_].info / 1e58) * 1e58 ) + (min_ * 1e29) + (offersList[offerId_].info % 1e29);
emit MinBidSet(offerId_, min_);
}
/**
* @notice Function to deprecate any active offer
* @param offerId_ The offer id to deprecate
*/
function deprecateOffer(uint256 offerId_) public onlyModerator onlyActiveOffers(offerId_) {
setInactive(offerId_);
emit OfferCancelled(offerId_);
}
/**
* @notice Validate an ERC20 token as payment method
* @param token_ The token address
* @param validated_ If is validated or not
*/
function validateERC20(address token_, bool validated_) public onlyVotationModule {
validERC20[token_] = validated_;
emit ERC20Validated(token_, validated_);
}
/**
* @notice Function to set {bidder_} as winner of the auction {offerId_}
* @param offerId_ Offer index
* @param newWinner_ The consecuent highest bidder of the auction
*/
function setWinner(uint256 offerId_, address newWinner_) public onlyModerator {
(uint256 oldWinnerBalance, uint256 newWinnerBalance) =
(
getActualBalance(auctionWinners[offerId_], offersList[offerId_].paymentToken),
getActualBalance(newWinner_, offersList[offerId_].paymentToken)
);
require(getMinBid(offerId_) > oldWinnerBalance,'M129');
require(getMinBid(offerId_) <= newWinnerBalance,'M130');
auctionWinners[offerId_] = newWinner_;
emit ChangedWinner(offerId_, newWinner_);
}
/**
* @notice function to set Beru Wallet address
* @param address_ the new address
*/
function setBeruWallet(address address_) public onlyVotationModule() {
beruWallet = address_;
emit BeruWalletSet(address_);
}
/**
* @notice function to set Beru Royalties
* @param value_ value of the new royalties
*/
function setBeruRoyalties(uint256 value_) public onlyVotationModule() {
require(value_<=1000,'M109');
beruRoyalies = value_;
emit BeruRoyaliesSet(value_);
}
//! --------------------------------------------------------------------------- GETTERS ---------------------------------------------------------------------------
/**
* @notice function to return the {isActive} encoded in info
* @param offerId_ the offerId where we get the data
*/
function isActive(uint offerId_) public view returns (bool) {
return ((offersList[offerId_].info / 1e74) % 10) == 1 ? true : false;
}
/**
* @notice function to return the {isAuction} encoded in info
* @param offerId_ the offerId where we get the data
*/
function isAuction(uint offerId_) public view returns (bool) {
return ((offersList[offerId_].info / 1e73) % 10) == 1 ? true : false;
}
/**
* @notice function to return the {endTime} encoded in info
* @param offerId_ the offerId where we get the data
*/
function getEndTime(uint offerId_) public view returns (uint) {
return (offersList[offerId_].info / 1e58) % 1e15;
}
/**
* @notice function to return the {minBid} encoded in info
* @param offerId_ the offerId where we get the data
*/
function getMinBid(uint offerId_) public view returns (uint) {
return (offersList[offerId_].info / 1e29) % 1e29;
}
/**
* @notice function to return the {value} encoded in info
* @param offerId_ the offerId where we get the data
*/
function getValue(uint offerId_) public view returns (uint) {
return offersList[offerId_].info % 1e29;
}
/**
* @notice function to return an array of token Ids previusly encoded
* @param offerId_ the offerId where we get the data
*/
function getDecodedTokenIds(uint offerId_) public view returns (uint[] memory) {
return decode(offersList[offerId_].tokenIds);
}
/**
* @notice Validates if an auction is still valid or not
* @param offerId_ The auction
* @return valid if it is valid or not
*/
function validateAuctionTime(uint256 offerId_) public view onlyAuctions(offerId_) returns (bool) {
return getEndTime(offerId_) > block.timestamp;
}
/**
* @notice Function to check if {token_} is a validERC20 for payment method
* @param token_ The token address
* @return bool if {token_} is valid
*/
function isValidERC20(address token_) public view returns (bool) {
return validERC20[token_];
}
/**
* @notice Helper function that returns the balance of {who} in {paymentToken} token
* @param who_ Address to check balance
* @param paymentToken_ Address of the token to check
*/
function getActualBalance(address who_, address paymentToken_) public view returns (uint balance) {
if (paymentToken_ == address(0))
balance = address(who_).balance;
else balance = IERC20(paymentToken_).balanceOf(who_);
}
/**
* @notice function to get the encoded collection address uint
* @param offerId_ offer Id to check
*/
function getCollectionAddresses(uint256 offerId_) public view returns (address[] memory){
return offersList[offerId_].collectionAddresses;
}
}