文件 1 的 1：XCART.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
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;
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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 IERC1155Receiver is IERC165 {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
pragma solidity ^0.8.0;
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
mapping(uint256 => mapping(address => uint256)) private _balances;
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner nor approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner nor approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
pragma solidity ^0.8.7;
error MintedQueryForZeroAddress();
error PiecesNotEnoughToSynthesize();
contract XCART is ERC1155, Ownable {
using SafeERC20 for IERC20;
enum Status {
Waiting,
Started,
Opened,
Finished
}
struct AddressData {
uint64 nft_balance;
uint64 nft_num_minted;
mapping(uint8 => uint16) piecesData;
}
Status public status;
string private _baseURI;
uint256 private NFT_PRICE = 0.168 * 10**18;
uint256 private PIECE_PRICE = 0.0188 * 10**18;
uint8 private MAX_MINT_PER_ADDR = 2;
uint16 private SYN_SUPPLY = 0;
uint16 private MINT_SUPPLY = 0;
uint16 private _offset = 7205;
uint256 private _currentMintNFTIndex;
uint256 private _currentSynNFTIndex;
uint8 public constant ID_P1 = 0;
uint8 public constant ID_P2 = 1;
uint8 public constant ID_P3 = 2;
uint8 public constant ID_P4 = 3;
uint8 public constant ID_P5 = 4;
uint16 public constant MAX_PIECES = 2800;
mapping(address => AddressData) private _addressData;
mapping(uint8 => uint16) private _piecesMinted;
event NFTMinted(address indexed minter, uint256 amount, uint256 firstTokenId, address inviter);
event NFTSynthesized(address owner, uint256 tokenId);
event NFTExchanged(address indexed owner, uint256 tokenId);
event PiecesMinted(address indexed minter, uint256 amount, uint256 tokenId, address inviter);
event PiecesAirdropped(address indexed receiver, uint256 amount);
event StatusChanged(Status status);
event BaseURIChanged(string newBaseURI);
constructor(string memory uri_) ERC1155("XCART") {
_baseURI = uri_;
_currentMintNFTIndex = _genesisNFTId();
_currentSynNFTIndex = _offset;
}
function _genesisNFTId() internal view virtual returns (uint256) {
return 5;
}
function totalSupply() public view returns (uint256) {
unchecked {
return MINT_SUPPLY + SYN_SUPPLY;
}
}
function totalMintSupply() public view returns (uint256) {
unchecked {
return MINT_SUPPLY;
}
}
function totalSynSupply() public view returns (uint256) {
unchecked {
return SYN_SUPPLY;
}
}
function perAccountSupply() public view returns (uint256) {
unchecked {
return MAX_MINT_PER_ADDR;
}
}
function totalNFTMinted() public view returns (uint256) {
unchecked {
return _currentMintNFTIndex - _genesisNFTId();
}
}
function totalNFTSynthesized() public view returns (uint256) {
unchecked {
return _currentSynNFTIndex - _offset;
}
}
function maxMintNumberPerAddress() public view returns (uint256) {
unchecked {
return uint256(MAX_MINT_PER_ADDR);
}
}
function piecesMinted(uint8 pid) public view returns (uint256) {
unchecked {
return uint256(_piecesMinted[pid]);
}
}
function numberMinted(address owner_) public view returns (uint256) {
if (owner_ == address(0)) revert MintedQueryForZeroAddress();
return uint256(_addressData[owner_].nft_num_minted);
}
function nftPrice() public view returns (uint256) {
unchecked {
return NFT_PRICE;
}
}
function piecePrice() public view returns (uint256) {
unchecked {
return PIECE_PRICE;
}
}
function mintNFT(uint256 quantity_, address inviter_) public payable {
require(status == Status.Started || status == Status.Opened, "Sale has not started");
require(tx.origin == msg.sender, "Contract calls are not allowed");
require(quantity_ > 0, "At least one NFT must be minted");
require(
totalNFTMinted() + quantity_ <= MINT_SUPPLY,
"Short minted supply(NFT)"
);
require(
numberMinted(msg.sender) + quantity_ <= MAX_MINT_PER_ADDR,
"This address has reached the limit of minting."
);
require(msg.value >= NFT_PRICE * quantity_, "Not enough ETH sent: check price.");
uint256[] memory ids = new uint256[] (quantity_);
uint256[] memory amounts = new uint256[] (quantity_);
uint256 index = _currentMintNFTIndex;
for (uint256 i = 0; i < quantity_; i++) {
ids[i] = index;
amounts[i] = 1;
index ++;
}
_mintBatch(msg.sender, ids, amounts, "");
_currentMintNFTIndex += quantity_;
_addressData[msg.sender].nft_balance += uint64(quantity_);
_addressData[msg.sender].nft_num_minted += uint64(quantity_);
_refundIfOver(NFT_PRICE * quantity_);
emit NFTMinted(msg.sender, quantity_, ids[0], inviter_);
}
function mintPiece(address inviter_) public payable {
require(status == Status.Started || status == Status.Opened, "Sale has not started");
require(tx.origin == msg.sender, "Contract calls are not allowed");
require(
piecesMinted(ID_P1) +
piecesMinted(ID_P2) +
piecesMinted(ID_P3) +
piecesMinted(ID_P4) +
piecesMinted(ID_P5) < MAX_PIECES * 5, "Short minted supply(Pieces)");
require(msg.value >= PIECE_PRICE, "Not enough ETH sent: check price.");
uint8 random = _randomInFive();
if (piecesMinted(random) == MAX_PIECES) {
for (uint8 i = 0; i < 5; i++) {
if (piecesMinted(i) < MAX_PIECES) {
random = i;
break;
}
}
}
_mint(msg.sender, random, 1, "");
_piecesMinted[random] += 1;
_addressData[msg.sender].piecesData[random] += 1;
uint256 tokenId = random;
_refundIfOver(PIECE_PRICE);
emit PiecesMinted(msg.sender, 1, tokenId, inviter_);
}
function synthesize() public payable {
require(status >= Status.Started, "Sale has not started");
require(tx.origin == msg.sender, "Contract calls are not allowed");
require(
totalNFTSynthesized() <= SYN_SUPPLY,
"Short synthesized NFT supply"
);
for(uint8 i = 0 ; i < 5 ; i ++) {
if(_addressData[msg.sender].piecesData[i] <= 0) {
revert PiecesNotEnoughToSynthesize();
}
}
for (uint8 i = 0 ; i < 5 ; i ++) {
_burn(msg.sender, i, 1);
_addressData[msg.sender].piecesData[i] -= 1;
}
_synthesizeNFT();
}
function exchange(uint256 nft_id_) public payable {
require(status >= Status.Started, "Sale has not started");
require(tx.origin == msg.sender, "Contract calls are not allowed");
require(balanceOf(msg.sender, nft_id_) > 0, "Address does not have any NFTs");
require(nft_id_ >= _genesisNFTId(), "Cannot exchange a piece.");
_burn(msg.sender, nft_id_, 1);
_addressData[msg.sender].nft_balance -= 1;
emit NFTExchanged(msg.sender, nft_id_);
}
function _synthesizeNFT() private {
require(status >= Status.Started, "Sale has not started");
require(tx.origin == msg.sender, "Contract calls are not allowed");
require(
totalNFTSynthesized() <= SYN_SUPPLY,
"Short synthesized NFT supply"
);
uint256 tokenId = _currentSynNFTIndex;
_mint(msg.sender, _currentSynNFTIndex, 1, "");
_currentSynNFTIndex += 1;
_addressData[msg.sender].nft_balance += 1;
emit NFTSynthesized(msg.sender, tokenId);
}
function setStatus(Status status_) public onlyOwner {
status = status_;
emit StatusChanged(status);
}
function uri(uint256 tokenId_) public view virtual override returns (string memory) {
if (tokenId_ < _genesisNFTId()) {
return "https://bafybeie2mbntsrgcgiw3svgqutbz7ovtpfcxjuotu5mbhjy4s3xduiugry.ipfs.nftstorage.link/{id}.json";
}
return _baseURI;
}
function setURI(string calldata newURI_) public onlyOwner {
_baseURI = newURI_;
emit BaseURIChanged(newURI_);
}
function setMintSupply(uint16 mintSupply_) public onlyOwner {
require(mintSupply_ > MINT_SUPPLY, "Mint supply value must be greater than original value");
require(mintSupply_ <= 7200, "Mint supply value must be less than or equal 7200");
MINT_SUPPLY = mintSupply_;
}
function setSynSupply(uint16 synSupply_) public onlyOwner {
require(synSupply_ > SYN_SUPPLY, "Syn supply value must be greater than original value");
require(synSupply_ <= 2800, "Syn supply value must be less than or equal 2800");
SYN_SUPPLY = synSupply_;
}
function setMaxMintNumberPerAddress(uint8 maxMintNumber_) public onlyOwner {
require(maxMintNumber_ > 0, "Value must greater than 0");
require(maxMintNumber_ < 256, "Value must less than 256");
MAX_MINT_PER_ADDR = maxMintNumber_;
}
function setMintPrice(uint256 mintPrice_) public onlyOwner {
require(mintPrice_ > 0, "Mint price must be greater than 0");
NFT_PRICE = mintPrice_;
}
function setPiecePrice(uint256 pPrice_) public onlyOwner {
require(pPrice_ > 0, "Piece price must be greater than 0");
PIECE_PRICE = pPrice_;
}
function _refundIfOver(uint256 price_) private {
if (msg.value > price_) {
payable(msg.sender).transfer(msg.value - price_);
}
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner nor approved"
);
require(amount < 65536, "Amount cannot over 65536");
_safeTransferFrom(from, to, id, amount, data);
if (id < _genesisNFTId()) {
_addressData[from].piecesData[uint8(id)] -= uint16(amount);
_addressData[to].piecesData[uint8(id)] += uint16(amount);
} else {
_addressData[from].nft_balance -= uint16(amount);
_addressData[to].nft_balance += uint16(amount);
}
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner nor approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
require(amounts[i] < 65536, "Amount cannot over 65536");
if (ids[i] < _genesisNFTId()) {
_addressData[from].piecesData[uint8(ids[i])] -= uint16(amounts[i]);
_addressData[to].piecesData[uint8(ids[i])] += uint16(amounts[i]);
} else {
_addressData[from].nft_balance -= uint16(amounts[i]);
_addressData[to].nft_balance += uint16(amounts[i]);
}
}
}
function _randomInFive() private view returns (uint8) {
uint256 x = uint256(keccak256(abi.encodePacked(
(block.timestamp) +
(block.difficulty) +
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (block.timestamp)) +
(block.gaslimit) +
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (block.timestamp)) +
(block.number)
))) % 5;
return uint8(x);
}
function withdrawETH(address payable recipient_) external onlyOwner {
uint256 balance = address(this).balance;
(bool success, ) = recipient_.call{value: balance}("");
require(success, "Withdraw successfully");
}
function withdrawSafeERC20Token(address tokenContract_, address payable recipient_, uint256 amount_) external onlyOwner {
IERC20 tokenContract = IERC20(tokenContract_);
tokenContract.safeTransfer(recipient_, amount_);
}
function airdropPieces(address receiver_, uint16 amount_) external onlyOwner {
require(piecesMinted(ID_P1) < MAX_PIECES - amount_, "Short minted supply(Piece id: 0)");
require(piecesMinted(ID_P2) < MAX_PIECES - amount_, "Short minted supply(Piece id: 1)");
require(piecesMinted(ID_P3) < MAX_PIECES - amount_, "Short minted supply(Piece id: 2)");
require(piecesMinted(ID_P4) < MAX_PIECES - amount_, "Short minted supply(Piece id: 3)");
require(piecesMinted(ID_P5) < MAX_PIECES - amount_, "Short minted supply(Piece id: 4)");
for (uint8 i = 0; i < 5; i ++) {
_mint(receiver_, i, amount_, "");
_piecesMinted[i] += amount_;
_addressData[receiver_].piecesData[i] += amount_;
}
emit PiecesAirdropped(receiver_, amount_);
}
}
