Código Fuente del Contrato
Archivo 1 de 1: MetaMafiosoContract.sol
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;
}
}
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);
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
error TransactionCapExceeded ();
error PublicMintingClosed ();
error ExcessiveOwnedMints ();
error MintZeroQuantity ();
error InvalidPayment ();
error SoftCapExceeded ();
error CapExceeded ();
error IsAlreadyUnveiled ();
error ValueCannotBeZero ();
error CannotBeNullAddress ();
error NoStateChange ();
error PublicMintClosed ();
error AllowlistMintClosed ();
error AddressNotAllowlisted ();
error AllowlistDropTimeHasNotPassed ();
error PublicDropTimeHasNotPassed ();
error DropTimeNotInFuture ();
error ClaimModeDisabled ();
error IneligibleRedemptionContract ();
error TokenAlreadyRedeemed ();
error InvalidOwnerForRedemption ();
error InvalidApprovalForRedemption ();
error ERC721RestrictedApprovalAddressRestricted ();
error NotMaintainer ();
error InvalidTeamAddress ();
error DuplicateTeamAddress ();
error AffiliateNotFound ();
abstract contract Teams is Ownable {
mapping(address => bool) internal team;
function addToTeam(address _address) public onlyOwner {
if (_address == address(0)) revert InvalidTeamAddress();
if (inTeam(_address)) revert DuplicateTeamAddress();
team[_address] = true;
}
function removeFromTeam(address _address) public onlyOwner {
if (_address == address(0)) revert InvalidTeamAddress();
if (!inTeam(_address)) revert InvalidTeamAddress();
team[_address] = false;
}
function inTeam(address _address) public view returns (bool) {
if (_address == address(0)) revert InvalidTeamAddress();
return team[_address] == true;
}
function _onlyTeamOrOwner() private view {
bool _isOwner = owner() == _msgSender();
bool _isTeam = inTeam(_msgSender());
require(_isOwner || _isTeam, "Team: caller is not the owner or in Team.");
}
modifier onlyTeamOrOwner() {
_onlyTeamOrOwner();
_;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
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);
}
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);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
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 functionCallWithValue(target, data, 0, "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");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
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] = _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);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry =
IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
if (address(operatorFilterRegistry).code.length > 0) {
if (subscribe) {
operatorFilterRegistry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
} else {
if (subscriptionOrRegistrantToCopy != address(0)) {
operatorFilterRegistry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
} else {
operatorFilterRegistry.register(address(this));
}
}
}
}
function _onlyAllowedOperator(address from) private view {
if (
!(operatorFilterRegistry.isOperatorAllowed(address(this), msg.sender) &&
operatorFilterRegistry.isOperatorAllowed(address(this), from))
) {
revert OperatorNotAllowed(msg.sender);
}
}
modifier onlyAllowedOperator(address from) virtual {
if (address(operatorFilterRegistry).code.length > 0) {
if (from == msg.sender) {
_;
return;
}
_onlyAllowedOperator(from);
}
_;
}
modifier onlyAllowedOperatorApproval(address operator) virtual {
_checkFilterOperator(operator);
_;
}
function _checkFilterOperator(address operator) internal view virtual {
if (address(operatorFilterRegistry).code.length > 0) {
if (!operatorFilterRegistry.isOperatorAllowed(address(this), operator)) {
revert OperatorNotAllowed(operator);
}
}
}
}
abstract contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, Teams, OperatorFilterer {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex;
uint256 public immutable collectionSize;
uint256 public maxBatchSize;
string private _name;
string private _symbol;
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(address => bool) public restrictedApprovalAddresses;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) OperatorFilterer(address(0), false) {
require(collectionSize_ > 0, "ERC721A: collection must have a nonzero supply");
require(maxBatchSize_ > 0, "ERC721A: max batch size must be nonzero");
_name = name_;
_symbol = symbol_;
maxBatchSize = maxBatchSize_;
collectionSize = collectionSize_;
currentIndex = _startTokenId();
}
function _startTokenId() internal view virtual returns (uint256) {
return 1;
}
function totalSupply() public view override returns (uint256) {
return _totalMinted();
}
function currentTokenId() public view returns (uint256) {
return _totalMinted();
}
function getNextTokenId() public view returns (uint256) {
return _totalMinted() + 1;
}
function _totalMinted() internal view returns (uint256) {
unchecked {
return currentIndex - _startTokenId();
}
}
function tokenByIndex(uint256 index) public view override returns (uint256) {
require(index < totalSupply(), "ERC721A: global index out of bounds");
return index;
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
uint256 numMintedSoFar = totalSupply();
uint256 tokenIdsIdx = 0;
address currOwnershipAddr = address(0);
for (uint256 i = 0; i < numMintedSoFar; i++) {
TokenOwnership memory ownership = _ownerships[i];
if (ownership.addr != address(0)) {
currOwnershipAddr = ownership.addr;
}
if (currOwnershipAddr == owner) {
if (tokenIdsIdx == index) {
return i;
}
tokenIdsIdx++;
}
}
revert("ERC721A: unable to get token of owner by index");
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
interfaceId == type(IERC721Enumerable).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view override returns (uint256) {
require(owner != address(0), "ERC721A: balance query for the zero address");
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
require(owner != address(0), "ERC721A: number minted query for the zero address");
return uint256(_addressData[owner].numberMinted);
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr && curr < currentIndex) {
TokenOwnership memory ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
while (true) {
curr--;
ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
}
}
revert("ERC721A: unable to determine the owner of token");
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return ownershipOf(tokenId).addr;
}
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) {
string memory baseURI = _baseURI();
string memory extension = _baseURIExtension();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString(), extension)) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function _baseURIExtension() internal view virtual returns (string memory) {
return "";
}
function setApprovalRestriction(address _address, bool _isRestricted) public onlyTeamOrOwner {
restrictedApprovalAddresses[_address] = _isRestricted;
}
function approve(address to, uint256 tokenId) public override onlyAllowedOperatorApproval(to) {
address owner = ERC721A.ownerOf(tokenId);
require(to != owner, "ERC721A: approval to current owner");
if (restrictedApprovalAddresses[to]) revert ERC721RestrictedApprovalAddressRestricted();
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721A: approve caller is not owner nor approved for all"
);
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId) public view override returns (address) {
require(_exists(tokenId), "ERC721A: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
require(operator != _msgSender(), "ERC721A: approve to caller");
if (restrictedApprovalAddresses[operator]) revert ERC721RestrictedApprovalAddressRestricted();
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_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 override onlyAllowedOperator(from) {
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override onlyAllowedOperator(from) {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721A: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view returns (bool) {
return _startTokenId() <= tokenId && tokenId < currentIndex;
}
function _safeMint(address to, uint256 quantity, bool isAdminMint) internal {
_safeMint(to, quantity, isAdminMint, "");
}
function _safeMint(address to, uint256 quantity, bool isAdminMint, bytes memory _data) internal {
uint256 startTokenId = currentIndex;
require(to != address(0), "ERC721A: mint to the zero address");
require(!_exists(startTokenId), "ERC721A: token already minted");
if (isAdminMint == false) {
require(quantity <= maxBatchSize, "ERC721A: quantity to mint too high");
}
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
AddressData memory addressData = _addressData[to];
_addressData[to] = AddressData(
addressData.balance + uint128(quantity),
addressData.numberMinted + (isAdminMint ? 0 : uint128(quantity))
);
_ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));
uint256 updatedIndex = startTokenId;
for (uint256 i = 0; i < quantity; i++) {
emit Transfer(address(0), to, updatedIndex);
require(
_checkOnERC721Received(address(0), to, updatedIndex, _data),
"ERC721A: transfer to non ERC721Receiver implementer"
);
updatedIndex++;
}
currentIndex = updatedIndex;
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _transfer(address from, address to, uint256 tokenId) private {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
getApproved(tokenId) == _msgSender() ||
isApprovedForAll(prevOwnership.addr, _msgSender()));
require(isApprovedOrOwner, "ERC721A: transfer caller is not owner nor approved");
require(prevOwnership.addr == from, "ERC721A: transfer from incorrect owner");
require(to != address(0), "ERC721A: transfer to the zero address");
_beforeTokenTransfers(from, to, tokenId, 1);
_approve(address(0), tokenId, prevOwnership.addr);
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
_ownerships[tokenId] = TokenOwnership(to, uint64(block.timestamp));
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
if (_exists(nextTokenId)) {
_ownerships[nextTokenId] = TokenOwnership(prevOwnership.addr, prevOwnership.startTimestamp);
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _approve(address to, uint256 tokenId, address owner) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet;
require(quantity > 0, "quantity must be nonzero");
if (currentIndex == _startTokenId()) revert("No Tokens Minted Yet");
uint256 endIndex = oldNextOwnerToSet + quantity - 1;
if (endIndex > collectionSize - 1) {
endIndex = collectionSize - 1;
}
require(_exists(endIndex), "not enough minted yet for this cleanup");
for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) {
if (_ownerships[i].addr == address(0)) {
TokenOwnership memory ownership = ownershipOf(i);
_ownerships[i] = TokenOwnership(ownership.addr, ownership.startTimestamp);
}
}
nextOwnerToExplicitlySet = endIndex + 1;
}
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(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721A: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual {}
function _afterTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual {}
}
contract Affiliate is Context, Teams {
struct AffiliateAccount {
address addr;
uint256 rate;
uint256 balance;
uint256 lifetimeBalance;
uint256 mints;
}
uint256 internal affiliateBalance = 0;
mapping(string => AffiliateAccount) private affiliates;
mapping(string => bool) internal affiliateExists;
mapping(address => string) private affiliateCodes;
function affiliateStatus(address _address) external view returns (string memory code, uint256 rate, uint256 mints, uint256 balance, uint256 lifetimeBalance) {
string memory _code = affiliateCodes[_address];
require(affiliateExists[_code], "Address is not an affiliate");
AffiliateAccount memory affiliate = affiliates[_code];
return (_code, affiliate.rate, affiliate.mints, affiliate.balance, affiliate.lifetimeBalance);
}
function addAffiliate(string calldata _code, address _address, uint256 _rate) external onlyTeamOrOwner {
require(bytes(_code).length > 0, "Invalid code");
require(_address != address(0), "Invalid address");
require(_rate > 0, "Rate must be greater than zero");
require(bytes(affiliateCodes[_address]).length == 0, "Affiliate address already exists");
require(!affiliateExists[_code], "Affiliate code already exists");
AffiliateAccount memory affiliate = AffiliateAccount(_address, _rate, 0, 0, 0);
affiliates[_code] = affiliate;
affiliateExists[_code] = true;
affiliateCodes[_address] = _code;
}
function creditAffiliate(string calldata _code, uint256 _value, uint256 _mints) internal {
if (affiliateExists[_code]) {
AffiliateAccount storage affiliate = affiliates[_code];
uint256 earnings = (_value * affiliate.rate) / 100;
affiliate.mints += _mints;
affiliate.balance += earnings;
affiliate.lifetimeBalance += earnings;
affiliateBalance += earnings;
}
}
function _payAffiliate(string memory _code) private {
require(affiliateExists[_code], "Affiliate does not exist");
AffiliateAccount storage affiliate = affiliates[_code];
uint256 _balance = affiliate.balance;
address _address = affiliate.addr;
require(_balance > 0, "Affiliate does not have a balance");
require(_address != address(0), "Invalid address");
(bool success, ) = _address.call{value: _balance}("");
require(success, "Withdrawal failed");
affiliate.balance = 0;
affiliateBalance -= _balance;
}
function affiliateWithdraw() external {
string memory _code = affiliateCodes[_msgSender()];
require(affiliateExists[_code], "You are not an affiliate");
_payAffiliate(_code);
}
}
abstract contract WithdrawableV2 is Teams, Affiliate {
address[] public payableAddresses = [
0x8e8772E32F700C623FED03Ce29e2dE47073dB972,
0x5b409126085223d28f3e2257bcf9eF6fB1c9D735
];
uint256[] public payableFees = [2, 98];
uint256 public payableAddressCount = 2;
function withdrawAll() public onlyTeamOrOwner {
uint256 _balance = address(this).balance;
uint256 _availableBalance = _balance - affiliateBalance;
if (_availableBalance <= 0) revert ValueCannotBeZero();
_withdrawAll(_availableBalance);
}
function _withdrawAll(uint256 balance) private {
for (uint i = 0; i < payableAddressCount; i++) {
_widthdraw(payableAddresses[i], (balance * payableFees[i]) / 100);
}
}
function _widthdraw(address _address, uint256 _amount) private {
(bool success, ) = _address.call{value: _amount}("");
require(success, "Transfer failed.");
}
}
abstract contract Feeable is Teams {
uint256 public PRICE_BASE = 1 ether;
uint256 public INCREMENT_PERCENT = 6;
uint256 public INCREMENT_BATCH = 100;
function setPriceBase(uint256 _feeInWei) external onlyTeamOrOwner {
PRICE_BASE = _feeInWei;
}
function setPriceIncrementPercent(uint256 _incrementPercent) external onlyTeamOrOwner {
INCREMENT_PERCENT = _incrementPercent;
}
function setPriceIncrementBatch(uint256 _incrementBatch) external onlyTeamOrOwner {
INCREMENT_BATCH = _incrementBatch;
}
function getPrice(uint256 _count, uint256 _supply) internal view returns (uint256) {
uint256 batch = _supply / INCREMENT_BATCH;
uint256 price = PRICE_BASE;
for (uint i = 0; i < batch; i++) {
price += price * INCREMENT_PERCENT / 100;
}
return price * _count;
}
}
abstract contract Allowlist is Teams {
bytes32 public merkleRoot;
bool public onlyAllowlistMode = false;
function updateMerkleRoot(bytes32 _newMerkleRoot) public onlyTeamOrOwner {
if (_newMerkleRoot == merkleRoot) revert NoStateChange();
merkleRoot = _newMerkleRoot;
}
function isAllowlisted(address _to, bytes32[] calldata _merkleProof) public view returns (bool) {
if (merkleRoot == 0) revert ValueCannotBeZero();
bytes32 leaf = keccak256(abi.encodePacked(_to));
return MerkleProof.verify(_merkleProof, merkleRoot, leaf);
}
function enableAllowlistOnlyMode() public onlyTeamOrOwner {
onlyAllowlistMode = true;
}
function disableAllowlistOnlyMode() public onlyTeamOrOwner {
onlyAllowlistMode = false;
}
}
library MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
computedHash = _efficientHash(computedHash, proofElement);
} else {
computedHash = _efficientHash(proofElement, computedHash);
}
}
return computedHash;
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
abstract contract ERC721APlus is
Ownable,
Teams,
ERC721A,
WithdrawableV2,
ReentrancyGuard,
Feeable,
Allowlist
{
constructor(string memory tokenName, string memory tokenSymbol) ERC721A(tokenName, tokenSymbol, 20, 2000) {}
uint8 public constant CONTRACT_VERSION = 2;
uint256 public softCap = 100;
bool public softCapEnforced = false;
string public _baseTokenURI = "ipfs://QmPhkMVtcTCs3Y97XygG73aCj3dGhF1xZ4gwXjjWBRxC7i/";
string public _baseTokenExtension = ".json";
bool public mintingOpen = false;
bool public soulbound = false;
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal override(ERC721A) {
if (soulbound) {
require(from == address(0), "Transfers are not permitted at the moment");
}
super._beforeTokenTransfers(from, to, startTokenId, quantity);
}
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner {
if (_qty == 0) revert MintZeroQuantity();
if (currentTokenId() + _qty > collectionSize) revert CapExceeded();
_safeMint(_to, _qty, true);
}
function mintToMultiple(address _to, uint256 _amount) public payable {
if (_amount == 0) revert MintZeroQuantity();
if (_amount > maxBatchSize) revert TransactionCapExceeded();
if (!mintingOpen) revert PublicMintClosed();
if (mintingOpen && onlyAllowlistMode) revert PublicMintClosed();
if (currentTokenId() + _amount > softCap && softCapEnforced) revert SoftCapExceeded();
if (currentTokenId() + _amount > collectionSize) revert CapExceeded();
if (msg.value != getPrice(_amount)) revert InvalidPayment();
_safeMint(_to, _amount, false);
}
function mintToMultipleAF(address _to, uint256 _amount, string calldata _code) public payable {
if (_amount == 0) revert MintZeroQuantity();
if (_amount > maxBatchSize) revert TransactionCapExceeded();
if (!mintingOpen) revert PublicMintClosed();
if (mintingOpen && onlyAllowlistMode) revert PublicMintClosed();
if (currentTokenId() + _amount > softCap && softCapEnforced) revert SoftCapExceeded();
if (currentTokenId() + _amount > collectionSize) revert CapExceeded();
if (msg.value != getPrice(_amount)) revert InvalidPayment();
if (!affiliateExists[_code]) revert AffiliateNotFound();
creditAffiliate(_code, msg.value, _amount);
_safeMint(_to, _amount, false);
}
function openMinting() public onlyTeamOrOwner {
mintingOpen = true;
}
function stopMinting() public onlyTeamOrOwner {
mintingOpen = false;
}
function mintToMultipleAL(address _to, uint256 _amount, bytes32[] calldata _merkleProof) public payable {
if (!onlyAllowlistMode || !mintingOpen) revert AllowlistMintClosed();
if (!isAllowlisted(_to, _merkleProof)) revert AddressNotAllowlisted();
if (_amount == 0) revert MintZeroQuantity();
if (_amount > maxBatchSize) revert TransactionCapExceeded();
if (currentTokenId() + _amount > softCap && softCapEnforced) revert SoftCapExceeded();
if (currentTokenId() + _amount > collectionSize) revert CapExceeded();
if (msg.value != getPrice(_amount)) revert InvalidPayment();
_safeMint(_to, _amount, false);
}
function mintToMultipleALAF(address _to, uint256 _amount, bytes32[] calldata _merkleProof, string calldata _code) public payable {
if (!onlyAllowlistMode || !mintingOpen) revert AllowlistMintClosed();
if (!isAllowlisted(_to, _merkleProof)) revert AddressNotAllowlisted();
if (_amount == 0) revert MintZeroQuantity();
if (_amount > maxBatchSize) revert TransactionCapExceeded();
if (currentTokenId() + _amount > softCap && softCapEnforced) revert SoftCapExceeded();
if (currentTokenId() + _amount > collectionSize) revert CapExceeded();
if (msg.value != getPrice(_amount)) revert InvalidPayment();
if (!affiliateExists[_code]) revert AffiliateNotFound();
creditAffiliate(_code, msg.value, _amount);
_safeMint(_to, _amount, false);
}
function openAllowlistMint() public onlyTeamOrOwner {
enableAllowlistOnlyMode();
mintingOpen = true;
}
function closeAllowlistMint() public onlyTeamOrOwner {
disableAllowlistOnlyMode();
mintingOpen = false;
}
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
if (_newMaxMint == 0) revert ValueCannotBeZero();
maxBatchSize = _newMaxMint;
}
function contractURI() public pure returns (string memory) {
return "ipfs://QmXHmWuxDQSRK6JYahXzGK7um5tB5cyHahwaChyBj2DQNw";
}
function _baseURI() internal view virtual override returns (string memory) {
return _baseTokenURI;
}
function _baseURIExtension() internal view virtual override returns (string memory) {
return _baseTokenExtension;
}
function baseTokenURI() public view returns (string memory) {
return _baseTokenURI;
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
_baseTokenURI = baseURI;
}
function setBaseTokenExtension(string calldata baseExtension) external onlyTeamOrOwner {
_baseTokenExtension = baseExtension;
}
function setSoftCap(uint256 _softCap) external onlyTeamOrOwner {
softCap = _softCap;
}
function setSoftCapEnforced(bool _enforced) external onlyTeamOrOwner {
softCapEnforced = _enforced;
}
function getPrice(uint256 _count) public view returns (uint256) {
return super.getPrice(_count, totalSupply());
}
function setSoulbound(bool _sb) external onlyTeamOrOwner {
soulbound = _sb;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A) returns (bool) {
return super.supportsInterface(interfaceId);
}
}
interface IMetaSignals {
function affiliateStatus(address _address) external view returns (string memory, uint256, uint256, uint256, uint256);
function addAffiliate(string calldata _code, address _address, uint256 _rate) external;
function affiliateWithdraw() external;
function setPriceBase(uint256 _feeInWei) external;
function setPriceIncrementPercent(uint256 _incrementPercent) external;
function setPriceIncrementBatch(uint256 _incrementBatch) external;
function setSoulbound(bool _sb) external;
}
contract MetaMafiosoContract is ERC721APlus {
constructor() ERC721APlus("MetaMafioso", "METSIG") {}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721APlus) returns (bool) {
return interfaceId == type(IMetaSignals).interfaceId
|| super.supportsInterface(interfaceId);
}
}
