文件 1 的 1：IERC20NFTMintMarketplace.sol
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner nor approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
pragma solidity ^0.8.0;
abstract contract ERC721URIStorage is ERC721 {
using Strings for uint256;
mapping(uint256 => string) private _tokenURIs;
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory _tokenURI = _tokenURIs[tokenId];
string memory base = _baseURI();
if (bytes(base).length == 0) {
return _tokenURI;
}
if (bytes(_tokenURI).length > 0) {
return string(abi.encodePacked(base, _tokenURI));
}
return super.tokenURI(tokenId);
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
function _burn(uint256 tokenId) internal virtual override {
super._burn(tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
pragma solidity ^0.8.0;
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
pragma solidity ^0.8.4;
interface IP {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract IERC20NFTMintMarketplace is ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _Ids;
Counters.Counter private _iSold;
Counters.Counter private _mIds;
address public PTA;
uint256 public minMintablePerSubmission = 1;
uint256 public maxMintablePerSubmission = 1000;
uint256 public maxMintablePerTX = 8;
uint256 public listingPrice = 21000000 ether;
uint public maxMintableDays = 15;
uint public mintToUserPercentagePoint = 500;
uint public mintToUserMaxCount = 10;
uint inBids;
uint public platformFees = 500;
uint public platformFeesAftermarket = 150;
uint public burnPercentagePoints = 6500;
uint public burnPercentagePointsMint = 1000;
uint256 fees;
uint256 feesCollected;
bool paused = false;
mapping(uint256 => MI) m;
mapping(uint256 => Offer[]) idOM;
mapping(uint256 => Offer[]) idOT;
mapping(uint256 => MItem) idM;
struct MI {
address payable creator;
uint256 mintPrice;
uint256 close;
uint256 max;
string tokenURI;
uint supply;
uint accrued;
uint collected;
uint id;
bool approved;
uint artistMints;
}
struct MItem {
uint256 tokenId;
uint256 mintId;
address payable seller;
address payable owner;
address payable creator;
uint256 price;
bool sold;
}
struct MItemO {
MItem item;
Offer[] oM;
Offer[] oT;
}
struct Offer {
address from;
uint bid;
}
constructor( address cAddress) ERC721("Seeing Red", "CNRED") {
PTA = cAddress;
}
function ceil(uint a, uint mo) pure public returns (uint ) {
return ((a + mo - 1) / mo) * mo;
}
function updateListingPrice(uint _price) public payable onlyOwner {
listingPrice = _price;
}
function updateMaxMintsPerTX(uint _max) public payable onlyOwner {
maxMintablePerTX = _max;
}
function updateMaxMintableDays(uint _max) public payable onlyOwner {
maxMintableDays = _max;
}
function updateMintToUserMaxCount(uint _max) public payable onlyOwner {
mintToUserMaxCount = _max;
}
function updateMaxMintablePerSubmission(uint _max) public payable onlyOwner {
maxMintablePerSubmission = _max;
}
function updateMinMintablePerSubmission(uint _min) public payable onlyOwner {
minMintablePerSubmission = _min;
}
function updatePlatFees(uint _fee) public payable onlyOwner {
platformFees = _fee;
}
function updatePlatFeesAftermarket(uint _fee) public payable onlyOwner {
platformFeesAftermarket = _fee;
}
function updatePaused(bool _p) public payable onlyOwner {
paused = _p;
}
function updatePaymentToken(address _new) public payable onlyOwner {
PTA = _new;
}
function updateMintToUserPoints(uint _min) public payable onlyOwner {
mintToUserPercentagePoint = _min;
}
function updateBurnPercentagePoints(uint _burnPoints) public payable onlyOwner {
burnPercentagePoints = _burnPoints;
}
function updateBurnPercentagePointsMint(uint _burnPointsM) public payable onlyOwner {
burnPercentagePointsMint = _burnPointsM;
}
function getListingPrice() public view returns (uint256) {
return listingPrice;
}
function updateArweaveHash(uint id, string memory _hash) public onlyOwner(){
uint iCT = _Ids.current();
m[id].tokenURI = _hash;
for (uint i=1; i <= iCT; i++) {
if(idM[i].mintId == id){
_setTokenURI(i, string(abi.encodePacked('https://arweave.net/',m[id].tokenURI)));
}
}
}
function offerOnMintId(uint id, uint bid) public payable{
require(m[id].id == id,"id match");
require(m[id].approved,'approved');
require(bid>0,"0 bid");
require(IP(PTA).allowance(msg.sender, address(this)) >= bid, "allowance");
require(IP(PTA).balanceOf(msg.sender)>= bid,"bid");
bool has = false;
for (uint i; i < idOM[id].length ; i++) {
if(idOM[id][i].from == msg.sender){
idOM[id][i].bid = bid;
has = true;
}
}
if(!has){
idOM[id].push(Offer(msg.sender, bid));
}
require(IP(PTA).transferFrom(msg.sender, address(this),bid),"transfer");
inBids += bid;
}
function getFees() public view onlyOwner returns (uint256) {
return fees;
}
function offerOnTokenId(uint id, uint bid) public payable{
require(_exists(id),"exist");
require(bid>0,"bid");
require(IP(PTA).allowance(msg.sender, address(this)) >= bid, "allowance");
require(IP(PTA).balanceOf(msg.sender)>= bid,"balance");
bool has;
for (uint i; i < idOT[id].length ; i++) {
if(idOT[id][i].from == msg.sender){
idOT[id][i].bid = bid;
has = true;
}
}
if(!has){
idOT[id].push(Offer(msg.sender, bid));
}
require(IP(PTA).transferFrom(msg.sender, address(this),bid),"transfer");
inBids += bid;
}
function cancelOfferOnMintId(uint id) public payable{
uint removalIndex;
bool has;
for (uint i ; i < idOM[id].length ; i++) {
if(idOM[id][i].from == msg.sender){
require(IP(PTA).approve(address(this), idOM[id][i].bid), "approve");
require(IP(PTA).transfer(msg.sender, idOM[id][i].bid), "funds");
inBids -= idOM[id][i].bid;
idOM[id][i].bid = 0;
has = true;
removalIndex = i;
}
}
if(has){
removeMOffer(id,removalIndex);
}
}
function removeMOffer(uint id, uint index) private{
idOM[id][index] = idOM[id][idOM[id].length-1];
idOM[id].pop();
}
function cancelOfferTokenId(uint id) public payable{
uint removalIndex;
bool has;
for (uint i; i < idOT[id].length ; i++) {
if(idOT[id][i].from == msg.sender){
require(IP(PTA).approve(address(this), idOT[id][i].bid), "funds");
require(IP(PTA).transfer(msg.sender, idOT[id][i].bid), "funds");
inBids -= idOT[id][i].bid;
idOT[id][i].bid = 0;
has = true;
removalIndex = i;
}
}
if(has){
removeTOffer(id,removalIndex);
}
}
function removeTOffer(uint id, uint index) private{
idOT[id][index] = idOT[id][idOT[id].length-1];
idOT[id].pop();
}
function acceptOffer(uint tId, uint mId, uint bid, address from, bool isTokenBuy) public payable {
require(idM[tId].owner == msg.sender || idM[tId].seller == msg.sender, "owns");
require(isTokenBuy ? true:idM[tId].mintId == mId, "mintId");
Offer[] memory offers = isTokenBuy ? idOT[tId]:idOM[mId];
bool hasBid;
uint oI;
for (uint i; i < offers.length ; i++) {
if(offers[i].bid == bid && offers[i].from == from){
hasBid = true;
oI = i;
}
}
require(hasBid,"no matching offer");
if(!idM[tId].sold){
_iSold.increment();
idM[tId].sold = true;
}
if(idM[tId].owner == msg.sender){
_transfer(msg.sender, from, tId);
} else {
_transfer(address(this), from, tId);
}
idM[tId].owner = payable(from);
idM[tId].seller = payable(address(0));
idM[tId].price = 0;
inBids -= offers[oI].bid;
uint platFees = (offers[oI].bid*platformFeesAftermarket)/10000;
fees += platFees;
uint256 toSeller = (offers[oI].bid-platFees);
require(IP(PTA).approve(address(this), toSeller));
require(IP(PTA).transfer(msg.sender, toSeller));
isTokenBuy ? removeTOffer(tId,oI) : removeMOffer(mId,oI);
}
function createMintable(uint256 price, uint256 close, uint256 max, string memory tokenURI) public {
require(!paused, "paused.");
require(maxMintablePerSubmission>=max,"many");
require(minMintablePerSubmission<=max,"low");
require(close> (block.timestamp + (1 * 1 days)), "short");
require(close<= (block.timestamp + (maxMintableDays * 1 days)), "long");
require(IP(PTA).allowance(msg.sender, address(this)) >= listingPrice,"NA");
require(IP(PTA).balanceOf(msg.sender)>= listingPrice,"balance");
require(price > 0, "price");
uint burn = (listingPrice*burnPercentagePoints)/10000;
fees += (listingPrice-burn);
require(IP(PTA).transferFrom(msg.sender, address(this),listingPrice),"Send");
require(IP(PTA).transfer(0x000000000000000000000000000000000000dEaD, burn),"Burn");
uint256 mId = _mIds.current();
uint uM = ceil((max*mintToUserPercentagePoint)/10000,1);
if(uM > mintToUserMaxCount){
uM = mintToUserMaxCount;
}
m[mId] = MI(payable(msg.sender),price,close,max,tokenURI,0,0,0,mId, false, uM);
_mIds.increment();
}
function artistMint(uint mId, uint count) public payable {
require(!paused, "paused");
require(msg.sender == m[mId].creator,"creator");
require(m[mId].artistMints >= count,"avail");
uint256 cMId = _mIds.current();
require(mId<cMId,'ID');
require(m[mId].approved == true,'NA');
require(m[mId].supply+count<=m[mId].max, "many");
require(m[mId].close>block.timestamp,"closed");
inMint(mId, count);
m[mId].artistMints = m[mId].artistMints - count;
return;
}
function mint(uint mId, uint count) public payable {
require(!paused, "paused");
uint256 cMId = _mIds.current();
require(mId<cMId,'id');
require(m[mId].approved,'NA');
require(m[mId].supply+count<=m[mId].max, "avail");
require(m[mId].close>block.timestamp,"active");
uint price = m[mId].mintPrice*count;
require(IP(PTA).allowance(msg.sender, address(this)) >= price,"NA");
uint burn = (price*burnPercentagePointsMint)/10000;
uint platFees = (price*platformFees)/10000;
require(IP(PTA).transferFrom(msg.sender, address(this),price),"send");
require(IP(PTA).transfer(0x000000000000000000000000000000000000dEaD, burn),"burn");
m[mId].accrued += (price-burn)-platFees;
fees += platFees;
inMint(mId, count);
return;
}
function inMint(uint mId, uint count) private {
for (uint i; i < count; i++) {
_iSold.increment();
_Ids.increment();
m[mId].supply ++;
uint256 tId = _Ids.current();
idM[tId] = MItem(tId,m[mId].id,payable(address(0)), payable(msg.sender),m[mId].creator,0,true);
_mint(msg.sender, tId);
_setTokenURI(tId, string(abi.encodePacked('https://arweave.net/',m[mId].tokenURI)));
}
return;
}
function approveMintable(uint mId, bool approved) public payable onlyOwner{
m[mId].approved = approved;
}
function sellToken(uint256 tId, uint256 price) public payable {
require(idM[tId].owner == msg.sender, "owns");
require(price > 0, "price");
idM[tId].sold = false;
idM[tId].price = price;
idM[tId].seller = payable(msg.sender);
idM[tId].owner = payable(address(this));
_iSold.decrement();
_transfer(msg.sender, address(this), tId);
}
function buyToken(uint256 tId) public payable {
uint price = idM[tId].price;
require(idM[tId].sold ==false,"sold");
require(ownerOf(tId)>= address(this),"escrow");
require(IP(PTA).balanceOf(msg.sender)>= (price),"balance");
require(IP(PTA).allowance(msg.sender, address(this)) >= (price),"NA");
uint platFees = (price*platformFeesAftermarket)/10000;
fees += platFees;
uint256 toSeller = (price-platFees);
require(IP(PTA).transferFrom(msg.sender, address(this),platFees),"fees");
require(IP(PTA).transferFrom(msg.sender, address(idM[tId].seller),toSeller),"payment");
idM[tId].owner = payable(msg.sender);
idM[tId].sold = true;
idM[tId].seller = payable(address(0));
idM[tId].price = 0;
_iSold.increment();
_transfer(address(this), msg.sender, tId);
}
function cancelListing(uint256 tId) public payable {
require(idM[tId].seller == msg.sender, "owner");
idM[tId].owner = payable(msg.sender);
idM[tId].sold = true;
idM[tId].price = 0;
idM[tId].seller = payable(address(0));
_iSold.increment();
_transfer(address(this), msg.sender, tId);
}
function fetchMintables(bool approved) public view returns (MI[] memory) {
uint itemCount = _mIds.current();
uint vMs;
for (uint i; i < itemCount; i++) {
bool p = approved ? m[i].approved:true;
if(m[i].close > block.timestamp && p){
vMs++;
}
}
uint cI;
MI[] memory it = new MI[](vMs);
for (uint i; i <= itemCount; i++) {
bool p = approved ? m[i].approved:true;
if(m[i].close > block.timestamp && p){
uint cID = i;
MI storage cItem = m[cID];
it[cI] = cItem;
cI += 1;
}
}
return it;
}
function fetchMyMintables(address mOwner) public view returns (MI[] memory) {
uint iC = _mIds.current();
uint vMs;
for (uint i; i < iC + 1; i++) {
if(m[i].creator == mOwner){
vMs++;
}
}
uint cI;
MI[] memory it = new MI[](vMs);
for (uint i; i < iC; i++) {
if(m[i].creator == mOwner){
uint cID = i;
MI storage cItem = m[cID];
it[cI] = cItem;
cI += 1;
}
}
return it;
}
function marketItems() public view returns ( MItemO[] memory) {
uint iC = _Ids.current();
uint cSold = _iSold.current();
uint x = (_Ids.current() - cSold);
uint cI;
MItemO[] memory it = new MItemO[](x);
if((_Ids.current() - cSold) == 0){
return it;
}
for (uint i; i < iC; i++) {
if (idM[i+1].owner == address(this)) {
uint cID = i + 1;
MItem storage cItem = idM[cID];
it[cI] = MItemO(cItem,idOM[idM[cID].mintId],idOT[cID]);
cI += 1;
}
}
return it;
}
function myCollection(address user) public view returns (MItemO[] memory) {
uint tIC = _Ids.current();
uint iC;
uint cI;
for (uint i; i < tIC; i++) {
if (idM[i+1].owner == user || idM[i+1].seller == user) {
iC += 1;
}
}
MItemO[] memory it = new MItemO[](iC);
for (uint i; i < tIC; i++) {
if (idM[i+1].owner == user || idM[i+1].seller == user) {
uint cID = i+1;
MItem storage cItem = idM[cID];
it[cI] = MItemO(cItem,idOM[idM[cID].mintId],idOT[cID]);
cI += 1;
}
}
return it;
}
function getMarketItem(uint id) public view returns (MItemO memory){
return MItemO(idM[id],idOM[idM[id].mintId],idOT[id]);
}
function listings() public view returns (MItemO[] memory) {
uint tIC = _Ids.current();
uint iC;
uint cI;
for (uint i; i < tIC; i++) {
if (idM[i + 1].seller == msg.sender) {
iC++;
}
}
MItemO[] memory it = new MItemO[](iC);
for (uint i; i < tIC; i++) {
if (idM[i + 1].seller == msg.sender) {
uint cID = i + 1;
MItem storage cItem = idM[cID];
it[cI] = MItemO(cItem,idOM[idM[cID].mintId],idOT[cID]);
cI ++;
}
}
return it;
}
function withdrawMikaForToken(uint id) external payable {
require(m[id].creator == msg.sender,"creator");
require(IP(PTA).approve(address(this), m[id].accrued));
require(IP(PTA).transfer(msg.sender, m[id].accrued));
m[id].collected += m[id].accrued;
m[id].accrued = 0;
}
function withdraw() external payable onlyOwner{
require(IP(PTA).approve(address(this), fees));
require(IP(PTA).transfer(msg.sender, fees));
feesCollected += fees;
fees = 0;
payable(msg.sender).transfer(address(this).balance);
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) override internal {
super._beforeTokenTransfer(from, to, tokenId);
if(!(from == address(0) || ((to == address(this) && (from == idM[tokenId].seller||from == idM[tokenId].owner ))||(from == address(this) && (to == idM[tokenId].seller||to == idM[tokenId].owner )) ))) {
if(idM[tokenId].sold == false){
_iSold.increment();
idM[tokenId].sold = true;
}
idM[tokenId].owner = payable(address(to));
idM[tokenId].seller = payable(address(0));
idM[tokenId].price = 0;
}
}
}
