NFTMarket.sol

//*~~~> SPDX-License-Identifier: MIT make it better, stronger, faster

/*~~~>
    Thank you Phunks for your inspiration and phriendship.
      Never stop phighting, never surrender, always stand up for what is right and make the best of all situations towards all people.
      Phunks are phreedom phighters!
        "When the power of love overcomes the love of power the world will know peace." - Jimi Hendrix <3

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(((((((((((((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(((((((((((((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((((((((((((((((((((((@@@@@##############################%%%%%@@@@@((((((((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((((((((((((((((((((((@@@@@##############################%%%%%@@@@@((((((((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((@@@@@########################################%%%%%@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((@@@@@########################################%%%%%@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((((((((((((@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@###############@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((((((((((((@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@###############@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((@@@@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@@@@@##########@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((@@PhunkyJON was here programming trustless unstoppable contracts@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@/////////////////////////////////////////////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@/////////////////////////////////////////////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@#PHUNKYJON///////////////#PHUNKYJON//////////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@#PHUNKYJON///////////////#PHUNKYJON//////////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@/////@EYES////////////////////@EYES///////////////@@@@@((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@/////@EYES////////////////////@EYES///////////////EAR@@((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@//////////////////////////////////////////////////EAR@@((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@//////////////////////////////////////////////////EAR@@((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@/////////////////////////////////////////////@@@@@@@@@@((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@/////////////////////////////////////////////@@@@@@@@@@((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@//////////NOSE@NOSE@////////////////////#####@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((SMOKE((((((((((@@@@@//////////NOSE@NOSE@////////////////////#####@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((@@@@@#####//////////////////////////////##########@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((@@@@@#####//////////////////////////////##########@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((@SPLIFF@SPLIFF@SPLIFF@SPLIFF@@###################################@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((@SPLIFF@SPLIFF@SPLIFF@SPLIFF@@###################################@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((EMBER(((((,,,,,,,,,,,,,,,,,,,,,,,,,@@@@@MOUTH&&&&&####################@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((EMBER(((((,,,,,,,,,,,,,,,,,,,,,,,,,@@@@@MOUTH&&&&&####################@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((@SPLIFF@SPLIFF@SPLIFF@SPLIFF@@##############################/////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((@SPLIFF@SPLIFF@SPLIFF@SPLIFF@@##############################/////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((((((((((((((((((((((@@@@@##############################//////////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%(((((((((((((((((((((((((((((((((((@@@@@##############################//////////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((@@@@@@@@@@@@@@@@@@@@@@@@@///////////////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((@@@@@@@@@@@@@@@@@@@@@@@@@///////////////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((@@@@@///////////////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((@@@@@///////////////@@@@@(((((((((((((((((((((((((%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@@@@@///////////////@@@@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@@@@@///////////////@@@@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

 <~~~*/

pragma solidity  0.8.7;

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./interfaces/IEscrow.sol";
import "./interfaces/IRewardsController.sol";
import "./interfaces/IRoleProvider.sol";

interface IERC20 {
  function transfer(address to, uint value) external returns (bool);
}

contract NFTMarket is ReentrancyGuard {

  /*~~~> 
    Roles allow for designated accessibility
  <~~~*/
  bytes32 public constant PROXY_ROLE = keccak256("PROXY_ROLE"); 
  bytes32 public constant DEV = keccak256("DEV");

  address public roleAdd;

  modifier hasAdmin(){
    require(IRoleProvider(roleAdd).hasTheRole(PROXY_ROLE, msg.sender), "DOES NOT HAVE ADMIN ROLE");
    _;
  }
  modifier hasContractAdmin(){
    require(IRoleProvider(roleAdd).hasContractRole(msg.sender), "DOES NOT HAVE CONTRACT ROLE");
    _;
  }
  modifier hasDevAdmin(){
    require(IRoleProvider(roleAdd).hasTheRole(DEV, msg.sender), "DOES NOT HAVE DEV ROLE");
    _;
  }

  /*~~~> increments NFT items upon creation <~~~*/
  uint256 public itemIds;

  //*~~~> global address variable from Role Provider contract
  bytes32 public constant REWARDS = keccak256("REWARDS");
  
  bytes32 public constant BIDS = keccak256("BIDS");
  
  bytes32 public constant OFFERS = keccak256("OFFERS");
  
  bytes32 public constant TRADES = keccak256("TRADES");

  bytes32 public constant NFTADD = keccak256("NFT");

  /*~~~> Open storage indexes <~~~*/
  uint[] private openStorage;

  /*~~~> Minimum listing value <~~~*/
  uint public minVal;

  /*~~~> sets deployment address as default admin role <~~~*/
  constructor(address newrole) {
    roleAdd = newrole;
    minVal = 1e15;
  }

  /*~~~> Declaring object structures for listed items for sale <~~~*/
  struct MktItem {
    bool is1155;
    uint itemId;
    uint amount1155;
    uint price;
    uint tokenId;
    address nftContract;
    address payable seller;
  }

  /*~~~> Memory array of item id to market item <~~~*/
  mapping(uint256 => MktItem) private idToMktItem;
  // Maps the balance of items that the user has listed for sale
  mapping(address => uint) public addressToUserBal;

  /*~~~> Declaring event object structure for Nft Listed for sale <~~~*/
  event ItemListed (
    uint itemId,
    uint amount1155,
    uint price,
    uint indexed tokenId, 
    address indexed nftContract, 
    address indexed seller
    );

  /*~~~> Declaring event object structures for delistings <~~~*/
  event ItemDelisted(
    uint indexed itemId,
    uint indexed tokenId,
    address indexed nftContract
    );

  /*~~~> Declaring event object structures for NFTs bought <~~~*/
  event ItemBought(
    uint itemId,
    uint indexed tokenId, 
    address indexed nftContract, 
    address fromAddress, 
    address indexed toAddress
    );

  /*~~~> Declaring event object structure for Item price updated <~~~*/
  event ItemUpdated(
    uint itemId,
    uint indexed tokenId,
    uint price,
    address indexed nftContract,
    address indexed seller
  );

    //~~~> To set the minimum listing price
  function setMinimumValue(uint minWei) external hasDevAdmin returns(bool){
    minVal = minWei;
    return true;
  }

  /// @notice 
  /*~~~> Public function to list NFTs for sale <~~~*/
  ///@dev
  /*~~~>
    is1155: (true) if item is ERC1155;
    amount1155: amount of ERC1155 to trade;
    tokenId: token Id of the item to list;
    price: eth value wanted for purchase;
    nftContract: contract address of item to list on the market;
  <~~~*/
  ///@return Bool
  function listMarketItems(
    bool[] memory is1155,
    uint[] memory amount1155,
    uint[] memory tokenId,
    uint[] memory price,
    address[] memory nftContract
  ) external nonReentrant returns(bool){
    require(tokenId.length>0);
    require(tokenId.length == nftContract.length);
    uint user = addressToUserBal[msg.sender];
    if (user==0) {
        require(IRewardsController(IRoleProvider(roleAdd).fetchAddress(REWARDS)).createUser(msg.sender));
      }
    uint tokenLen = tokenId.length;
    for (uint i=0;i<tokenLen;i++){
        require(price[i] >= minVal);
        uint itemId;
        uint len = openStorage.length;
        if (len>=1){
          itemId=openStorage[len-1];
          _remove();
        } else {
          itemId = itemIds+=1;
        }
        if(!is1155[i]){
        require(transferFromERC721(nftContract[i], tokenId[i], address(this)));
        require(approveERC721(nftContract[i], address(this), tokenId[i]));
        idToMktItem[itemId] =  MktItem(false, itemId, amount1155[i], price[i], tokenId[i], nftContract[i], payable(msg.sender));
      } else {
        IERC1155(nftContract[i]).safeTransferFrom(msg.sender, address(this), tokenId[i], amount1155[i], "");
        IERC1155(nftContract[i]).setApprovalForAll(address(this), true);
        idToMktItem[itemId] =  MktItem(true, itemId, amount1155[i], price[i], tokenId[i], nftContract[i], payable(msg.sender));
      }
      emit ItemListed(itemId, amount1155[i], price[i], tokenId[i], nftContract[i], msg.sender);
    }
    //*~~~> Add new count to user balances
    addressToUserBal[msg.sender] += tokenLen;
    return true;
  }


  /// @notice 
  /*~~~> Public function to delist NFTs <~~~*/
  ///@dev
  /*~~~>
    itemId: itemId for internal storage location;
  <~~~*/
  ///@return Bool
  function delistMarketItems(
    uint256[] calldata itemId
  ) public nonReentrant returns(bool){

    address rewardsAdd = IRoleProvider(roleAdd).fetchAddress(REWARDS);
    address bidsAdd = IRoleProvider(roleAdd).fetchAddress(BIDS);
    address offersAdd = IRoleProvider(roleAdd).fetchAddress(OFFERS);
    address tradesAdd = IRoleProvider(roleAdd).fetchAddress(TRADES);

    for (uint i=0;i<itemId.length;i++){
      MktItem memory it = idToMktItem[itemId[i]];
      require(it.seller == msg.sender, "Not owner");

      uint bidId = IBids(bidsAdd).fetchBidId(itemId[i]);
      if (bidId>0) {
      /*~~~> Kill bid and refund bidValue <~~~*/
        //~~~> Call the contract to refund the ETH offered for a bid
        require(IBids(bidsAdd).refundBid(bidId));
      }
        /*~~~> Check for the case where there is a trade and refund it. <~~~*/
      uint offerId = IOffers(offersAdd).fetchOfferId(itemId[i]);
      if (offerId > 0) {
      /*~~~> Kill offer and refund amount <~~~*/
        //*~~~> Call the contract to refund the NFT offered for trade
        require(IOffers(offersAdd).refundOffer(itemId[i], offerId));
      }
      /*~~~> Check for the case where there is an offer and refund it. <~~~*/
      uint tradeId = ITrades(tradesAdd).fetchTradeId(itemId[i]);
      if (tradeId > 0) {
      /*~~~> Kill offer and refund amount <~~~*/
        //*~~~> Call the contract to refund the ERC20 offered for trade
        require(ITrades(tradesAdd).refundTrade(itemId[i], tradeId));
      }
      if(it.is1155){
        IERC1155(it.nftContract).safeTransferFrom(address(this), msg.sender, it.tokenId, it.amount1155, "");
      } else {
        require(transferERC721(it.nftContract, it.seller, it.tokenId));
      }
      openStorage.push(itemId[i]);
      idToMktItem[itemId[i]] =  MktItem(false, itemId[i], 0, 0, 0, address(0x0), payable(0x0));
      emit ItemDelisted(itemId[i], it.tokenId, it.nftContract);
      //*~~~> remove count from user balances
      addressToUserBal[msg.sender] -= 1;
      }
      //*~~~> Check to see if user has any remaining items listed after iteration
      if (addressToUserBal[msg.sender]==0){
        //*~~~> If not, remove them from claims allowance
          require(IRewardsController(rewardsAdd).setUser(false, msg.sender));
        } else { //*~~~> Allow claims
          require(IRewardsController(rewardsAdd).setUser(true, msg.sender));
        }
      return true;
  }

  /// @notice 
  /*~~~> Public function to buy(purchase) NFTs <~~~*/
  ///@dev
  /*~~~>
    itemId: itemId for internal storage location;
  <~~~*/
  ///@return Bool
  function buyMarketItems(
    uint256[] memory itemId
    ) public payable nonReentrant returns(bool) {
    
    address bidsAdd = IRoleProvider(roleAdd).fetchAddress(BIDS);
    address offersAdd = IRoleProvider(roleAdd).fetchAddress(OFFERS);
    address tradesAdd = IRoleProvider(roleAdd).fetchAddress(TRADES);
    address rewardsAdd = IRoleProvider(roleAdd).fetchAddress(REWARDS);

    uint balance = IERC721(IRoleProvider(roleAdd).fetchAddress(NFTADD)).balanceOf(msg.sender);
    uint prices=0;
    uint length = itemId.length;
    for (uint i=0; i < length; i++) {
      MktItem memory it = idToMktItem[itemId[i]];
      prices += it.price;
    }
    require(msg.value == prices);
    for (uint i=0; i<length; i++) {
      MktItem memory it = idToMktItem[itemId[i]];
      if(balance<1){
        /*~~~> Calculating the platform fee <~~~*/
        uint256 saleFee = calcFee(it.price);
        uint256 userAmnt = it.price - saleFee;
        // send saleFee to rewards controller
        require(sendEther(rewardsAdd, saleFee));
        // send (listed amount - saleFee) to seller
        require(sendEther(it.seller, useramnt));
      } else {
        require(sendEther(it.seller, it.price));
      }
      if (IBids(bidsAdd).fetchBidId(itemId[i])>0) {
      /*~~~> Kill bid and refund bidValue <~~~*/
        //~~~> Call the contract to refund the ETH offered for a bid
        require(IBids(bidsAdd).refundBid(IBids(bidsAdd).fetchBidId(itemId[i])));
      }
        /*~~~> Check for the case where there is a trade and refund it. <~~~*/
      if (IOffers(offersAdd).fetchOfferId(itemId[i]) > 0) {
      /*~~~> Kill offer and refund amount <~~~*/
        //*~~~> Call the contract to refund the NFT offered for trade
        require(IOffers(offersAdd).refundOffer(itemId[i], IOffers(offersAdd).fetchOfferId(itemId[i])));
      }
      /*~~~> Check for the case where there is an offer and refund it. <~~~*/
      if (ITrades(tradesAdd).fetchTradeId(itemId[i]) > 0) {
      /*~~~> Kill offer and refund amount <~~~*/
        //*~~~> Call the contract to refund the ERC20 offered for trade
        require(ITrades(tradesAdd).refundTrade(itemId[i], ITrades(tradesAdd).fetchTradeId(itemId[i])));
      }
      addressToUserBal[it.seller] -= 1;
      emit ItemBought(itemId[i], it.tokenId, it.nftContract, it.seller, msg.sender);
      if(it.is1155){
        IERC1155(it.nftContract).safeTransferFrom(address(this), msg.sender, it.tokenId, it.amount1155, "");
        idToMktItem[itemId[i]] = MktItem(true, itemId[i], 0, 0, 0, address(0x0), payable(0x0));
      } else {
        require(transferERC721(it.nftContract, msg.sender, it.tokenId));
        idToMktItem[itemId[i]] = MktItem(false, itemId[i], 0, 0, 0, address(0x0), payable(0x0));
      }
      openStorage.push(itemId[i]);
      //*~~~> Check to see if user has any remaining items listed after iteration
      if (addressToUserBal[it.seller]==0){
        //*~~~> If not, remove them from claims allowance
          require(IRewardsController(rewardsAdd).setUser(false, it.seller));
        } else { //*~~~> Allow claims
          require(IRewardsController(rewardsAdd).setUser(true, it.seller));
        }
    }
    return true;
  }

  /// @notice 
    /*~~~> 
      Internal function to transferFrom ERC721 NFTs, including crypto kitties/punks
    <~~~*/
  /// @dev
    /*~~~>
      assetAddr: address of the token to be transfered;
      tokenId: Id of the token to be transfered;
      to: address of recipient;
    <~~~*/
function transferFromERC721(address assetAddr, uint256 tokenId, address to) internal virtual returns(bool) {
    address kitties = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d;
    address punks = 0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB;
    bytes memory data;
    if (assetAddr == kitties) {
        // Cryptokitties.
        data = abi.encodeWithSignature("transferFrom(address,address,uint256)", msg.sender, to, tokenId);
    } else if (assetAddr == punks) {
        // CryptoPunks.
        bytes memory punkIndexToAddress = abi.encodeWithSignature("punkIndexToAddress(uint256)", tokenId);
        (bool checkSuccess, bytes memory result) = address(assetAddr).staticcall(punkIndexToAddress);
        (address nftOwner) = abi.decode(result, (address));
        require(checkSuccess && nftOwner == msg.sender, "Not the NFT owner");
        data = abi.encodeWithSignature("transferPunk(address,uint256)", msg.sender, tokenId);
    } else {
        // Default.
        // We push to avoid an unneeded transfer.
        data = abi.encodeWithSignature("safeTransferFrom(address,address,uint256)", msg.sender, to, tokenId);
    }
    (bool success, bytes memory resultData) = address(assetAddr).call(data);
    require(success, string(resultData));
    return true;
  }

  /// @notice 
    /*~~~> 
      Internal function to approve ERC721 NFTs for transfer, including crypto kitties/punks
    <~~~*/
  /// @dev
    /*~~~>
      assetAddr: address of the token to be transfered;
      to: address of recipient;
      tokenId: Id of the token to be transfered;
    <~~~*/
  function approveERC721(address assetAddr, address to, uint256 tokenId) internal virtual returns(bool) {
    address punks = 0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB;
    bytes memory data;
    if (assetAddr == punks) {
        // CryptoPunks.
        data = abi.encodeWithSignature("offerPunkForSaleToAddress(uint256,uint256,address)", tokenId, 0, to);
        (bool success, bytes memory resultData) = address(assetAddr).call(data);
        require(success, string(resultData));
    } else {
      data = abi.encodeWithSignature("approve(address,uint256)", to, tokenId);
    }
    return(true);
  }

  /// @notice 
    /*~~~> 
      Internal function to transfer ERC721 NFTs, including crypto kitties/punks
    <~~~*/
  /// @dev
    /*~~~>
      assetAddr: address of the token to be transfered;
      to: address of the recipient;
      tokenId: Id of the token to be transfered;
    <~~~*/
  function transferERC721(address assetAddr, address to, uint256 tokenId) internal virtual returns(bool) {
    address kitties = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d;
    address punks = 0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB;
    bytes memory data;
    if (assetAddr == kitties) {
        // Changed in v1.0.4.
        data = abi.encodeWithSignature("transfer(address,uint256)", to, tokenId);
    } else if (assetAddr == punks) {
        // CryptoPunks.
        data = abi.encodeWithSignature("transferPunk(address,uint256)", to, tokenId);
    } else {
        // Default.
        data = abi.encodeWithSignature("safeTransferFrom(address,address,uint256)", address(this), to, tokenId);
    }
    (bool success, bytes memory returnData) = address(assetAddr).call(data);
    require(success, string(returnData));
    return true;
  }

  /// @notice
  /*~~~> 
    Internal function for sending ether
  <~~~*/
  /// @return Bool
  function sendEther(address recipient, uint ethvalue) internal nonReentrant returns (bool){
    (bool success, bytes memory data) = address(recipient).call{value: ethvalue}("");
    return(success);
  }

  /// @notice 
  /*~~~> 
    Calculating the platform fee, 
      Base fee set at 2% (i.e. value * 200 / 10,000) 
      Future fees can be set by the controlling DAO 
    <~~~*/
  /// @return platform fee
  function calcFee(uint256 value) internal returns (uint256)  {
      address rewardsAdd = IRoleProvider(roleAdd).fetchAddress(REWARDS);
      uint fee = IRewardsController(rewardsAdd).getFee();
      uint256 percent = ((value * fee) / 10000);
      return percent;
    }
    
  ///@notice
  /*~~~> Function to update price, only seller can call <~~~*/
  ///@dev
  /*~~~>
    itemId: internal id of item listed for sale;
    _price: market price update
  <~~~*/
  function updateMarketItemPrice(uint itemId, uint price) external nonReentrant {
    MktItem memory it = idToMktItem[itemId];
    require(msg.sender == it.seller);
    idToMktItem[it.itemId] = MktItem(it.is1155, it.itemId, price, it.amount1155, it.tokenId, it.nftContract, it.seller);
    emit ItemUpdated(itemId, it.tokenId, price, it.nftContract, it.seller);
  }

  ///@notice //*~~~> Read functions for internal contract state
  function fetchMarketItems() public view returns (MktItem[] memory) {
    uint itemCount = itemIds;
    MktItem[] memory items = new MktItem[](itemCount);
    for (uint i = 0; i < itemCount; i++) {
      if (idToMktItem[i + 1].itemId > 0) {
        MktItem storage currentItem = idToMktItem[i + 1];
        items[i] = currentItem;
      }
    }
    return items;
  }
  
  function fetchItemsBySeller(address userAdd) public view returns (MktItem[] memory) {
    uint itemCount = itemIds;
    MktItem[] memory items = new MktItem[](itemCount);
    for (uint i=0; i < itemCount; i++) {
      if (idToMktItem[i + 1].seller == userAdd) {
        MktItem storage currentItem = idToMktItem[i + 1];
        items[i] = currentItem;
      }
    }
    return items;
  }

  function fetchAmountListed(address userAdd) public view returns (uint howMany){
    uint user = addressToUserBal[userAdd];
    return user;
  }

  /// @notice 
  /*~~~> 
    Internal function for removing elements from an array
    Only used for internal storage array index recycling

      In order to reduce storage array size of listed items 
        while maintaining specific enumerable bidId's, 
        any sold or removed item spots are recycled by referring to their index,
        else a new storage spot is created;

        We use the last item in the storage (length of array - 1 for 0 based index position),
        in order to pop off the item and avoid rewriting 
  <~~~*/
  function _remove() internal {
      openStorage.pop();
    }

  ///@notice
  /*~~~> ERC20 withdraw ability for funds accidentally sent
    Only ETH is exchanged here, so there is no avenue for attack.
  <~~~*/
  function withdrawToken(address receiver, address tokenContract, uint256 amount) external nonReentrant hasDevAdmin returns(bool) {
    require(IERC20(tokenContract).transfer(receiver, amount));
    return true;
  }

  ///@notice internal function to transfer NFT only this contract can call
  function transferForSale(address receiver, uint itemId) internal {

    address bidsAdd = IRoleProvider(roleAdd).fetchAddress(BIDS);
    address tradesAdd = IRoleProvider(roleAdd).fetchAddress(TRADES);
    address offersAdd = IRoleProvider(roleAdd).fetchAddress(OFFERS);

    MktItem memory it = idToMktItem[itemId];
    if ( it.is1155 ){
        IERC1155(it.nftContract).safeTransferFrom(address(this), payable(receiver), it.tokenId, it.amount1155, "");
      } else {
        require(transferERC721(it.nftContract, payable(receiver), it.tokenId));
      }
      uint bidId = IBids(bidsAdd).fetchBidId(itemId);
      if (bidId>0) {
      /*~~~> Kill bid and refund bidValue <~~~*/
        //~~~> Call the contract to refund the ETH offered for a bid
        require(IBids(bidsAdd).refundBid(bidId));
      }
        /*~~~> Check for the case where there is a trade and refund it. <~~~*/
      uint offerId = IOffers(offersAdd).fetchOfferId(itemId);
      if (offerId > 0) {
      /*~~~> Kill offer and refund amount <~~~*/
        //*~~~> Call the contract to refund the NFT offered for trade
        require(IOffers(offersAdd).refundOffer(itemId, offerId));
      }
      /*~~~> Check for the case where there is an offer and refund it. <~~~*/
      uint tradeId = ITrades(tradesAdd).fetchTradeId(itemId);
      if (tradeId > 0) {
      /*~~~> Kill offer and refund amount <~~~*/
        //*~~~> Call the contract to refund the ERC20 offered for trade
        require(ITrades(tradesAdd).refundTrade(itemId, tradeId));
      }
      openStorage.push(itemId);
      idToMktItem[itemId] = MktItem(false, itemId, 0, 0, 0, address(0x0), payable(0x0));
      emit ItemBought(itemId, it.tokenId, it.nftContract, it.seller, receiver);
  }

  ///@notice external function to transfer NFT
  /*~~~>
    Only marketplace proxy contracts can call the function. 
  <~~~*/
  function transferNftForSale(address receiver, uint itemId) public nonReentrant hasContractAdmin returns(bool) {
    transferForSale(receiver, itemId);
    return true;
  }

  /// @notice
  /*~~~> 
    Internal function for sending ether
  <~~~*/
  /// @return Bool
  function sendEther(address recipient, uint ethvalue) internal nonReentrant returns (bool){
    (bool success, bytes memory data) = address(recipient).call{value: ethvalue}("");
    return(success);
  }

  //*~~~> Fallback functions
  ///@notice
  /*~~~> External ETH transfer without function call forwarded to role provider contract <~~~*/
  event FundsForwarded(uint value, address from, address to);
  receive() external payable {
    require(sendEther(roleAdd, msg.value));
    emit FundsForwarded(msg.value, msg.sender, roleAdd);
  }
  function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
        return this.onERC1155Received.selector;
    }
  function onERC721Received(
      address, 
      address, 
      uint256, 
      bytes calldata
    )external pure returns(bytes4) {
        return bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));
  }
}