From 9a9d899813f0f91e9f78d11692234fd0e5ccf64f Mon Sep 17 00:00:00 2001 From: BonHowi <52290046+BonHowi@users.noreply.github.com> Date: Thu, 2 Jun 2022 16:08:29 +0200 Subject: [PATCH 1/8] Add files via upload --- test.sol | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 test.sol diff --git a/test.sol b/test.sol new file mode 100644 index 0000000000..e69de29bb2 From 8e2cd6597171803b34ec694bf43629fe1db495fb Mon Sep 17 00:00:00 2001 From: BonHowi <52290046+BonHowi@users.noreply.github.com> Date: Thu, 2 Jun 2022 16:09:01 +0200 Subject: [PATCH 2/8] Create test_1.sol --- contracts/test_1.sol | 1972 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1972 insertions(+) create mode 100644 contracts/test_1.sol diff --git a/contracts/test_1.sol b/contracts/test_1.sol new file mode 100644 index 0000000000..7bf819d349 --- /dev/null +++ b/contracts/test_1.sol @@ -0,0 +1,1972 @@ +//*********************************************************************// +//*********************************************************************// +// +// abc +// +//*********************************************************************// +//*********************************************************************// + +//-------------DEPENDENCIES--------------------------// + +// File: @openzeppelin/contracts/utils/math/SafeMath.sol +// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol) + +pragma solidity ^0.8.0; + +// CAUTION +// This version of SafeMath should only be used with Solidity 0.8 or later, +// because it relies on the compiler's built in overflow checks. + +/** + * @dev Wrappers over Solidity's arithmetic operations. + * + * NOTE: SafeMath is generally not needed starting with Solidity 0.8, since the compiler + * now has built in overflow checking. + */ +library SafeMath { + /** + * @dev Returns the addition of two unsigned integers, with an overflow flag. + * + * _Available since v3.4._ + */ + function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { + unchecked { + uint256 c = a + b; + if (c < a) return (false, 0); + return (true, c); + } + } + + /** + * @dev Returns the substraction of two unsigned integers, with an overflow flag. + * + * _Available since v3.4._ + */ + function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { + unchecked { + if (b > a) return (false, 0); + return (true, a - b); + } + } + + /** + * @dev Returns the multiplication of two unsigned integers, with an overflow flag. + * + * _Available since v3.4._ + */ + function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { + unchecked { + // Gas optimization: this is cheaper than requiring 'a' not being zero, but the + // benefit is lost if 'b' is also tested. + // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 + if (a == 0) return (true, 0); + uint256 c = a * b; + if (c / a != b) return (false, 0); + return (true, c); + } + } + + /** + * @dev Returns the division of two unsigned integers, with a division by zero flag. + * + * _Available since v3.4._ + */ + function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { + unchecked { + if (b == 0) return (false, 0); + return (true, a / b); + } + } + + /** + * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. + * + * _Available since v3.4._ + */ + function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { + unchecked { + if (b == 0) return (false, 0); + return (true, a % b); + } + } + + /** + * @dev Returns the addition of two unsigned integers, reverting on + * overflow. + * + * Counterpart to Solidity's + operator. + * + * Requirements: + * + * - Addition cannot overflow. + */ + function add(uint256 a, uint256 b) internal pure returns (uint256) { + return a + b; + } + + /** + * @dev Returns the subtraction of two unsigned integers, reverting on + * overflow (when the result is negative). + * + * Counterpart to Solidity's - operator. + * + * Requirements: + * + * - Subtraction cannot overflow. + */ + function sub(uint256 a, uint256 b) internal pure returns (uint256) { + return a - b; + } + + /** + * @dev Returns the multiplication of two unsigned integers, reverting on + * overflow. + * + * Counterpart to Solidity's * operator. + * + * Requirements: + * + * - Multiplication cannot overflow. + */ + function mul(uint256 a, uint256 b) internal pure returns (uint256) { + return a * b; + } + + /** + * @dev Returns the integer division of two unsigned integers, reverting on + * division by zero. The result is rounded towards zero. + * + * Counterpart to Solidity's / operator. + * + * Requirements: + * + * - The divisor cannot be zero. + */ + function div(uint256 a, uint256 b) internal pure returns (uint256) { + return a / b; + } + + /** + * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), + * reverting when dividing by zero. + * + * Counterpart to Solidity's % operator. This function uses a revert + * opcode (which leaves remaining gas untouched) while Solidity uses an + * invalid opcode to revert (consuming all remaining gas). + * + * Requirements: + * + * - The divisor cannot be zero. + */ + function mod(uint256 a, uint256 b) internal pure returns (uint256) { + return a % b; + } + + /** + * @dev Returns the subtraction of two unsigned integers, reverting with custom message on + * overflow (when the result is negative). + * + * CAUTION: This function is deprecated because it requires allocating memory for the error + * message unnecessarily. For custom revert reasons use {trySub}. + * + * Counterpart to Solidity's - operator. + * + * Requirements: + * + * - Subtraction cannot overflow. + */ + function sub( + uint256 a, + uint256 b, + string memory errorMessage + ) internal pure returns (uint256) { + unchecked { + require(b <= a, errorMessage); + return a - b; + } + } + + /** + * @dev Returns the integer division of two unsigned integers, reverting with custom message on + * division by zero. The result is rounded towards zero. + * + * Counterpart to Solidity's / operator. Note: this function uses a + * revert opcode (which leaves remaining gas untouched) while Solidity + * uses an invalid opcode to revert (consuming all remaining gas). + * + * Requirements: + * + * - The divisor cannot be zero. + */ + function div( + uint256 a, + uint256 b, + string memory errorMessage + ) internal pure returns (uint256) { + unchecked { + require(b > 0, errorMessage); + return a / b; + } + } + + /** + * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), + * reverting with custom message when dividing by zero. + * + * CAUTION: This function is deprecated because it requires allocating memory for the error + * message unnecessarily. For custom revert reasons use {tryMod}. + * + * Counterpart to Solidity's % operator. This function uses a revert + * opcode (which leaves remaining gas untouched) while Solidity uses an + * invalid opcode to revert (consuming all remaining gas). + * + * Requirements: + * + * - The divisor cannot be zero. + */ + function mod( + uint256 a, + uint256 b, + string memory errorMessage + ) internal pure returns (uint256) { + unchecked { + require(b > 0, errorMessage); + return a % b; + } + } +} + +// File: @openzeppelin/contracts/utils/Address.sol + + +// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol) + +pragma solidity ^0.8.1; + +/** + * @dev Collection of functions related to the address type + */ +library Address { + /** + * @dev Returns true if account is a contract. + * + * [IMPORTANT] + * ==== + * It is unsafe to assume that an address for which this function returns + * false is an externally-owned account (EOA) and not a contract. + * + * Among others, isContract will return false for the following + * types of addresses: + * + * - an externally-owned account + * - a contract in construction + * - an address where a contract will be created + * - an address where a contract lived, but was destroyed + * ==== + * + * [IMPORTANT] + * ==== + * You shouldn't rely on isContract to protect against flash loan attacks! + * + * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets + * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract + * constructor. + * ==== + */ + function isContract(address account) internal view returns (bool) { + // This method relies on extcodesize/address.code.length, which returns 0 + // for contracts in construction, since the code is only stored at the end + // of the constructor execution. + + return account.code.length > 0; + } + + /** + * @dev Replacement for Solidity's transfer: sends amount wei to + * recipient, forwarding all available gas and reverting on errors. + * + * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost + * of certain opcodes, possibly making contracts go over the 2300 gas limit + * imposed by transfer, making them unable to receive funds via + * transfer. {sendValue} removes this limitation. + * + * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. + * + * IMPORTANT: because control is transferred to recipient, care must be + * taken to not create reentrancy vulnerabilities. Consider using + * {ReentrancyGuard} or the + * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. + */ + 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"); + } + + /** + * @dev Performs a Solidity function call using a low level call. A + * plain call is an unsafe replacement for a function call: use this + * function instead. + * + * If target reverts with a revert reason, it is bubbled up by this + * function (like regular Solidity function calls). + * + * Returns the raw returned data. To convert to the expected return value, + * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[abi.decode]. + * + * Requirements: + * + * - target must be a contract. + * - calling target with data must not revert. + * + * _Available since v3.1._ + */ + function functionCall(address target, bytes memory data) internal returns (bytes memory) { + return functionCall(target, data, "Address: low-level call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[functionCall], but with + * errorMessage as a fallback revert reason when target reverts. + * + * _Available since v3.1._ + */ + function functionCall( + address target, + bytes memory data, + string memory errorMessage + ) internal returns (bytes memory) { + return functionCallWithValue(target, data, 0, errorMessage); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[functionCall], + * but also transferring value wei to target. + * + * Requirements: + * + * - the calling contract must have an ETH balance of at least value. + * - the called Solidity function must be payable. + * + * _Available since v3.1._ + */ + 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"); + } + + /** + * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[functionCallWithValue], but + * with errorMessage as a fallback revert reason when target reverts. + * + * _Available since v3.1._ + */ + 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); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[functionCall], + * but performing a static call. + * + * _Available since v3.3._ + */ + function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { + return functionStaticCall(target, data, "Address: low-level static call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-string-}[functionCall], + * but performing a static call. + * + * _Available since v3.3._ + */ + 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); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[functionCall], + * but performing a delegate call. + * + * _Available since v3.4._ + */ + function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { + return functionDelegateCall(target, data, "Address: low-level delegate call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-string-}[functionCall], + * but performing a delegate call. + * + * _Available since v3.4._ + */ + 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); + } + + /** + * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the + * revert reason using the provided one. + * + * _Available since v4.3._ + */ + function verifyCallResult( + bool success, + bytes memory returndata, + string memory errorMessage + ) internal pure returns (bytes memory) { + if (success) { + return returndata; + } else { + // Look for revert reason and bubble it up if present + if (returndata.length > 0) { + // The easiest way to bubble the revert reason is using memory via assembly + + assembly { + let returndata_size := mload(returndata) + revert(add(32, returndata), returndata_size) + } + } else { + revert(errorMessage); + } + } + } +} + +// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol + + +// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol) + +pragma solidity ^0.8.0; + +/** + * @title ERC721 token receiver interface + * @dev Interface for any contract that wants to support safeTransfers + * from ERC721 asset contracts. + */ +interface IERC721Receiver { + /** + * @dev Whenever an {IERC721} tokenId token is transferred to this contract via {IERC721-safeTransferFrom} + * by operator from from, this function is called. + * + * It must return its Solidity selector to confirm the token transfer. + * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. + * + * The selector can be obtained in Solidity with IERC721.onERC721Received.selector. + */ + function onERC721Received( + address operator, + address from, + uint256 tokenId, + bytes calldata data + ) external returns (bytes4); +} + +// File: @openzeppelin/contracts/utils/introspection/IERC165.sol + + +// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Interface of the ERC165 standard, as defined in the + * https://eips.ethereum.org/EIPS/eip-165[EIP]. + * + * Implementers can declare support of contract interfaces, which can then be + * queried by others ({ERC165Checker}). + * + * For an implementation, see {ERC165}. + */ +interface IERC165 { + /** + * @dev Returns true if this contract implements the interface defined by + * interfaceId. See the corresponding + * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] + * to learn more about how these ids are created. + * + * This function call must use less than 30 000 gas. + */ + function supportsInterface(bytes4 interfaceId) external view returns (bool); +} + +// File: @openzeppelin/contracts/utils/introspection/ERC165.sol + + +// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) + +pragma solidity ^0.8.0; + + +/** + * @dev Implementation of the {IERC165} interface. + * + * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check + * for the additional interface id that will be supported. For example: + * + * solidity + * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { + * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); + * } + * + * + * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. + */ +abstract contract ERC165 is IERC165 { + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { + return interfaceId == type(IERC165).interfaceId; + } +} + +// File: @openzeppelin/contracts/token/ERC721/IERC721.sol + + +// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol) + +pragma solidity ^0.8.0; + + +/** + * @dev Required interface of an ERC721 compliant contract. + */ +interface IERC721 is IERC165 { + /** + * @dev Emitted when tokenId token is transferred from from to to. + */ + event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); + + /** + * @dev Emitted when owner enables approved to manage the tokenId token. + */ + event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); + + /** + * @dev Emitted when owner enables or disables (approved) operator to manage all of its assets. + */ + event ApprovalForAll(address indexed owner, address indexed operator, bool approved); + + /** + * @dev Returns the number of tokens in owner's account. + */ + function balanceOf(address owner) external view returns (uint256 balance); + + /** + * @dev Returns the owner of the tokenId token. + * + * Requirements: + * + * - tokenId must exist. + */ + function ownerOf(uint256 tokenId) external view returns (address owner); + + /** + * @dev Safely transfers tokenId token from from to to, checking first that contract recipients + * are aware of the ERC721 protocol to prevent tokens from being forever locked. + * + * Requirements: + * + * - from cannot be the zero address. + * - to cannot be the zero address. + * - tokenId token must exist and be owned by from. + * - If the caller is not from, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. + * - If to refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. + * + * Emits a {Transfer} event. + */ + function safeTransferFrom( + address from, + address to, + uint256 tokenId + ) external; + + /** + * @dev Transfers tokenId token from from to to. + * + * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. + * + * Requirements: + * + * - from cannot be the zero address. + * - to cannot be the zero address. + * - tokenId token must be owned by from. + * - If the caller is not from, it must be approved to move this token by either {approve} or {setApprovalForAll}. + * + * Emits a {Transfer} event. + */ + function transferFrom( + address from, + address to, + uint256 tokenId + ) external; + + /** + * @dev Gives permission to to to transfer tokenId token to another account. + * The approval is cleared when the token is transferred. + * + * Only a single account can be approved at a time, so approving the zero address clears previous approvals. + * + * Requirements: + * + * - The caller must own the token or be an approved operator. + * - tokenId must exist. + * + * Emits an {Approval} event. + */ + function approve(address to, uint256 tokenId) external; + + /** + * @dev Returns the account approved for tokenId token. + * + * Requirements: + * + * - tokenId must exist. + */ + function getApproved(uint256 tokenId) external view returns (address operator); + + /** + * @dev Approve or remove operator as an operator for the caller. + * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. + * + * Requirements: + * + * - The operator cannot be the caller. + * + * Emits an {ApprovalForAll} event. + */ + function setApprovalForAll(address operator, bool _approved) external; + + /** + * @dev Returns if the operator is allowed to manage all of the assets of owner. + * + * See {setApprovalForAll} + */ + function isApprovedForAll(address owner, address operator) external view returns (bool); + + /** + * @dev Safely transfers tokenId token from from to to. + * + * Requirements: + * + * - from cannot be the zero address. + * - to cannot be the zero address. + * - tokenId token must exist and be owned by from. + * - If the caller is not from, it must be approved to move this token by either {approve} or {setApprovalForAll}. + * - If to refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. + * + * Emits a {Transfer} event. + */ + function safeTransferFrom( + address from, + address to, + uint256 tokenId, + bytes calldata data + ) external; +} + +// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol + + +// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol) + +pragma solidity ^0.8.0; + + +/** + * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension + * @dev See https://eips.ethereum.org/EIPS/eip-721 + */ +interface IERC721Enumerable is IERC721 { + /** + * @dev Returns the total amount of tokens stored by the contract. + */ + function totalSupply() external view returns (uint256); + + /** + * @dev Returns a token ID owned by owner at a given index of its token list. + * Use along with {balanceOf} to enumerate all of owner's tokens. + */ + function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); + + /** + * @dev Returns a token ID at a given index of all the tokens stored by the contract. + * Use along with {totalSupply} to enumerate all tokens. + */ + function tokenByIndex(uint256 index) external view returns (uint256); +} + +// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol + + +// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) + +pragma solidity ^0.8.0; + + +/** + * @title ERC-721 Non-Fungible Token Standard, optional metadata extension + * @dev See https://eips.ethereum.org/EIPS/eip-721 + */ +interface IERC721Metadata is IERC721 { + /** + * @dev Returns the token collection name. + */ + function name() external view returns (string memory); + + /** + * @dev Returns the token collection symbol. + */ + function symbol() external view returns (string memory); + + /** + * @dev Returns the Uniform Resource Identifier (URI) for tokenId token. + */ + function tokenURI(uint256 tokenId) external view returns (string memory); +} + +// File: @openzeppelin/contracts/utils/Strings.sol + + +// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol) + +pragma solidity ^0.8.0; + +/** + * @dev String operations. + */ +library Strings { + bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; + + /** + * @dev Converts a uint256 to its ASCII string decimal representation. + */ + function toString(uint256 value) internal pure returns (string memory) { + // Inspired by OraclizeAPI's implementation - MIT licence + // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol + + 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); + } + + /** + * @dev Converts a uint256 to its ASCII string hexadecimal representation. + */ + 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); + } + + /** + * @dev Converts a uint256 to its ASCII string hexadecimal representation with fixed 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); + } +} + +// File: @openzeppelin/contracts/security/ReentrancyGuard.sol + + +// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Contract module that helps prevent reentrant calls to a function. + * + * Inheriting from ReentrancyGuard will make the {nonReentrant} modifier + * available, which can be applied to functions to make sure there are no nested + * (reentrant) calls to them. + * + * Note that because there is a single nonReentrant guard, functions marked as + * nonReentrant may not call one another. This can be worked around by making + * those functions private, and then adding external nonReentrant entry + * points to them. + * + * TIP: If you would like to learn more about reentrancy and alternative ways + * to protect against it, check out our blog post + * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. + */ +abstract contract ReentrancyGuard { + // Booleans are more expensive than uint256 or any type that takes up a full + // word because each write operation emits an extra SLOAD to first read the + // slot's contents, replace the bits taken up by the boolean, and then write + // back. This is the compiler's defense against contract upgrades and + // pointer aliasing, and it cannot be disabled. + + // The values being non-zero value makes deployment a bit more expensive, + // but in exchange the refund on every call to nonReentrant will be lower in + // amount. Since refunds are capped to a percentage of the total + // transaction's gas, it is best to keep them low in cases like this one, to + // increase the likelihood of the full refund coming into effect. + uint256 private constant _NOT_ENTERED = 1; + uint256 private constant _ENTERED = 2; + + uint256 private _status; + + constructor() { + _status = _NOT_ENTERED; + } + + /** + * @dev Prevents a contract from calling itself, directly or indirectly. + * Calling a nonReentrant function from another nonReentrant + * function is not supported. It is possible to prevent this from happening + * by making the nonReentrant function external, and making it call a + * private function that does the actual work. + */ + modifier nonReentrant() { + // On the first call to nonReentrant, _notEntered will be true + require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); + + // Any calls to nonReentrant after this point will fail + _status = _ENTERED; + + _; + + // By storing the original value once again, a refund is triggered (see + // https://eips.ethereum.org/EIPS/eip-2200) + _status = _NOT_ENTERED; + } +} + +// File: @openzeppelin/contracts/utils/Context.sol + + +// OpenZeppelin Contracts v4.4.1 (utils/Context.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Provides information about the current execution context, including the + * sender of the transaction and its data. While these are generally available + * via msg.sender and msg.data, they should not be accessed in such a direct + * manner, since when dealing with meta-transactions the account sending and + * paying for execution may not be the actual sender (as far as an application + * is concerned). + * + * This contract is only required for intermediate, library-like contracts. + */ +abstract contract Context { + function _msgSender() internal view virtual returns (address) { + return msg.sender; + } + + function _msgData() internal view virtual returns (bytes calldata) { + return msg.data; + } +} + +// File: @openzeppelin/contracts/access/Ownable.sol + + +// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol) + +pragma solidity ^0.8.0; + + +/** + * @dev Contract module which provides a basic access control mechanism, where + * there is an account (an owner) that can be granted exclusive access to + * specific functions. + * + * By default, the owner account will be the one that deploys the contract. This + * can later be changed with {transferOwnership}. + * + * This module is used through inheritance. It will make available the modifier + * onlyOwner, which can be applied to your functions to restrict their use to + * the owner. + */ +abstract contract Ownable is Context { + address private _owner; + + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + /** + * @dev Initializes the contract setting the deployer as the initial owner. + */ + constructor() { + _transferOwnership(_msgSender()); + } + + /** + * @dev Returns the address of the current owner. + */ + function owner() public view virtual returns (address) { + return _owner; + } + + /** + * @dev Throws if called by any account other than the owner. + */ + modifier onlyOwner() { + require(owner() == _msgSender(), "Ownable: caller is not the owner"); + _; + } + + /** + * @dev Leaves the contract without owner. It will not be possible to call + * onlyOwner functions anymore. Can only be called by the current owner. + * + * NOTE: Renouncing ownership will leave the contract without an owner, + * thereby removing any functionality that is only available to the owner. + */ + function renounceOwnership() public virtual onlyOwner { + _transferOwnership(address(0)); + } + + /** + * @dev Transfers ownership of the contract to a new account (newOwner). + * Can only be called by the current owner. + */ + function transferOwnership(address newOwner) public virtual onlyOwner { + require(newOwner != address(0), "Ownable: new owner is the zero address"); + _transferOwnership(newOwner); + } + + /** + * @dev Transfers ownership of the contract to a new account (newOwner). + * Internal function without access restriction. + */ + function _transferOwnership(address newOwner) internal virtual { + address oldOwner = _owner; + _owner = newOwner; + emit OwnershipTransferred(oldOwner, newOwner); + } +} +//-------------END DEPENDENCIES------------------------// + + + + pragma solidity ^0.8.0; + + /** + * @dev These functions deal with verification of Merkle Trees proofs. + * + * The proofs can be generated using the JavaScript library + * https://github.com/miguelmota/merkletreejs[merkletreejs]. + * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled. + * + * + * WARNING: You should avoid using leaf values that are 64 bytes long prior to + * hashing, or use a hash function other than keccak256 for hashing leaves. + * This is because the concatenation of a sorted pair of internal nodes in + * the merkle tree could be reinterpreted as a leaf value. + */ + library MerkleProof { + /** + * @dev Returns true if a 'leaf' can be proved to be a part of a Merkle tree + * defined by 'root'. For this, a 'proof' must be provided, containing + * sibling hashes on the branch from the leaf to the root of the tree. Each + * pair of leaves and each pair of pre-images are assumed to be sorted. + */ + function verify( + bytes32[] memory proof, + bytes32 root, + bytes32 leaf + ) internal pure returns (bool) { + return processProof(proof, leaf) == root; + } + + /** + * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up + * from 'leaf' using 'proof'. A 'proof' is valid if and only if the rebuilt + * hash matches the root of the tree. When processing the proof, the pairs + * of leafs & pre-images are assumed to be sorted. + * + * _Available since v4.4._ + */ + 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) { + // Hash(current computed hash + current element of the proof) + computedHash = _efficientHash(computedHash, proofElement); + } else { + // Hash(current element of the proof + current computed hash) + 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) + } + } + } + + + // File: Allowlist.sol + + pragma solidity ^0.8.0; + + abstract contract Allowlist is Ownable { + bytes32 public merkleRoot; + bool public onlyAllowlistMode = false; + + /** + * @dev Update merkle root to reflect changes in Allowlist + * @param _newMerkleRoot new merkle root to reflect most recent Allowlist + */ + function updateMerkleRoot(bytes32 _newMerkleRoot) public onlyOwner { + require(_newMerkleRoot != merkleRoot, "Merkle root will be unchanged!"); + merkleRoot = _newMerkleRoot; + } + + /** + * @dev Check the proof of an address if valid for merkle root + * @param _to address to check for proof + * @param _merkleProof Proof of the address to validate against root and leaf + */ + function isAllowlisted(address _to, bytes32[] calldata _merkleProof) public view returns(bool) { + require(merkleRoot != 0, "Merkle root is not set!"); + bytes32 leaf = keccak256(abi.encodePacked(_to)); + + return MerkleProof.verify(_merkleProof, merkleRoot, leaf); + } + + + function enableAllowlistOnlyMode() public onlyOwner { + onlyAllowlistMode = true; + } + + function disableAllowlistOnlyMode() public onlyOwner { + onlyAllowlistMode = false; + } + } + + +/** + * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including + * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints. + * + * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..). + * + * Assumes the number of issuable tokens (collection size) is capped and fits in a uint128. + * + * Does not support burning tokens to address(0). + */ +contract ERC721A is + Context, + ERC165, + IERC721, + IERC721Metadata, + IERC721Enumerable +{ + 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; + + // Token name + string private _name; + + // Token symbol + string private _symbol; + + // Mapping from token ID to ownership details + // An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details. + mapping(uint256 => TokenOwnership) private _ownerships; + + // Mapping owner address to address data + mapping(address => AddressData) private _addressData; + + // Mapping from token ID to approved address + mapping(uint256 => address) private _tokenApprovals; + + // Mapping from owner to operator approvals + mapping(address => mapping(address => bool)) private _operatorApprovals; + + /** + * @dev + * maxBatchSize refers to how much a minter can mint at a time. + * collectionSize_ refers to how many tokens are in the collection. + */ + constructor( + string memory name_, + string memory symbol_, + uint256 maxBatchSize_, + uint256 collectionSize_ + ) { + 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(); + } + + /** + * To change the starting tokenId, please override this function. + */ + function _startTokenId() internal view virtual returns (uint256) { + return 1; + } + + /** + * @dev See {IERC721Enumerable-totalSupply}. + */ + function totalSupply() public view override returns (uint256) { + return _totalMinted(); + } + + function currentTokenId() public view returns (uint256) { + return _totalMinted(); + } + + function getNextTokenId() public view returns (uint256) { + return SafeMath.add(_totalMinted(), 1); + } + + /** + * Returns the total amount of tokens minted in the contract. + */ + function _totalMinted() internal view returns (uint256) { + unchecked { + return currentIndex - _startTokenId(); + } + } + + /** + * @dev See {IERC721Enumerable-tokenByIndex}. + */ + function tokenByIndex(uint256 index) public view override returns (uint256) { + require(index < totalSupply(), "ERC721A: global index out of bounds"); + return index; + } + + /** + * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. + * This read function is O(collectionSize). If calling from a separate contract, be sure to test gas first. + * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case. + */ + 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"); + } + + /** + * @dev See {IERC165-supportsInterface}. + */ + 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); + } + + /** + * @dev See {IERC721-balanceOf}. + */ + 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; + } + + // Invariant: + // There will always be an ownership that has an address and is not burned + // before an ownership that does not have an address and is not burned. + // Hence, curr will not underflow. + while (true) { + curr--; + ownership = _ownerships[curr]; + if (ownership.addr != address(0)) { + return ownership; + } + } + } + } + + revert("ERC721A: unable to determine the owner of token"); + } + + /** + * @dev See {IERC721-ownerOf}. + */ + function ownerOf(uint256 tokenId) public view override returns (address) { + return ownershipOf(tokenId).addr; + } + + /** + * @dev See {IERC721Metadata-name}. + */ + function name() public view virtual override returns (string memory) { + return _name; + } + + /** + * @dev See {IERC721Metadata-symbol}. + */ + function symbol() public view virtual override returns (string memory) { + return _symbol; + } + + /** + * @dev See {IERC721Metadata-tokenURI}. + */ + function tokenURI(uint256 tokenId) + public + view + virtual + override + returns (string memory) + { + string memory baseURI = _baseURI(); + return + bytes(baseURI).length > 0 + ? string(abi.encodePacked(baseURI, tokenId.toString())) + : ""; + } + + /** + * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each + * token will be the concatenation of the baseURI and the tokenId. Empty + * by default, can be overriden in child contracts. + */ + function _baseURI() internal view virtual returns (string memory) { + return ""; + } + + /** + * @dev See {IERC721-approve}. + */ + function approve(address to, uint256 tokenId) public override { + address owner = ERC721A.ownerOf(tokenId); + require(to != owner, "ERC721A: approval to current owner"); + + require( + _msgSender() == owner || isApprovedForAll(owner, _msgSender()), + "ERC721A: approve caller is not owner nor approved for all" + ); + + _approve(to, tokenId, owner); + } + + /** + * @dev See {IERC721-getApproved}. + */ + function getApproved(uint256 tokenId) public view override returns (address) { + require(_exists(tokenId), "ERC721A: approved query for nonexistent token"); + + return _tokenApprovals[tokenId]; + } + + /** + * @dev See {IERC721-setApprovalForAll}. + */ + function setApprovalForAll(address operator, bool approved) public override { + require(operator != _msgSender(), "ERC721A: approve to caller"); + + _operatorApprovals[_msgSender()][operator] = approved; + emit ApprovalForAll(_msgSender(), operator, approved); + } + + /** + * @dev See {IERC721-isApprovedForAll}. + */ + function isApprovedForAll(address owner, address operator) + public + view + virtual + override + returns (bool) + { + return _operatorApprovals[owner][operator]; + } + + /** + * @dev See {IERC721-transferFrom}. + */ + function transferFrom( + address from, + address to, + uint256 tokenId + ) public override { + _transfer(from, to, tokenId); + } + + /** + * @dev See {IERC721-safeTransferFrom}. + */ + function safeTransferFrom( + address from, + address to, + uint256 tokenId + ) public override { + safeTransferFrom(from, to, tokenId, ""); + } + + /** + * @dev See {IERC721-safeTransferFrom}. + */ + function safeTransferFrom( + address from, + address to, + uint256 tokenId, + bytes memory _data + ) public override { + _transfer(from, to, tokenId); + require( + _checkOnERC721Received(from, to, tokenId, _data), + "ERC721A: transfer to non ERC721Receiver implementer" + ); + } + + /** + * @dev Returns whether tokenId exists. + * + * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. + * + * Tokens start existing when they are minted (_mint), + */ + 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, ""); + } + + /** + * @dev Mints quantity tokens and transfers them to to. + * + * Requirements: + * + * - there must be quantity tokens remaining unminted in the total collection. + * - to cannot be the zero address. + * - quantity cannot be larger than the max batch size. + * + * Emits a {Transfer} event. + */ + 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"); + // We know if the first token in the batch doesn't exist, the other ones don't as well, because of serial ordering. + require(!_exists(startTokenId), "ERC721A: token already minted"); + 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); + } + + /** + * @dev Transfers tokenId from from to to. + * + * Requirements: + * + * - to cannot be the zero address. + * - tokenId token must be owned by from. + * + * Emits a {Transfer} event. + */ + 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); + + // Clear approvals from the previous owner + _approve(address(0), tokenId, prevOwnership.addr); + + _addressData[from].balance -= 1; + _addressData[to].balance += 1; + _ownerships[tokenId] = TokenOwnership(to, uint64(block.timestamp)); + + // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it. + // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls. + 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); + } + + /** + * @dev Approve to to operate on tokenId + * + * Emits a {Approval} event. + */ + function _approve( + address to, + uint256 tokenId, + address owner + ) private { + _tokenApprovals[tokenId] = to; + emit Approval(owner, to, tokenId); + } + + uint256 public nextOwnerToExplicitlySet = 0; + + /** + * @dev Explicitly set owners to eliminate loops in future calls of ownerOf(). + */ + 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; + } + // We know if the last one in the group exists, all in the group exist, due to serial ordering. + 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; + } + + /** + * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. + * The call is not executed if the target address is not a contract. + * + * @param from address representing the previous owner of the given token ID + * @param to target address that will receive the tokens + * @param tokenId uint256 ID of the token to be transferred + * @param _data bytes optional data to send along with the call + * @return bool whether the call correctly returned the expected magic value + */ + 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; + } + } + + /** + * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting. + * + * startTokenId - the first token id to be transferred + * quantity - the amount to be transferred + * + * Calling conditions: + * + * - When from and to are both non-zero, from's tokenId will be + * transferred to to. + * - When from is zero, tokenId will be minted for to. + */ + function _beforeTokenTransfers( + address from, + address to, + uint256 startTokenId, + uint256 quantity + ) internal virtual {} + + /** + * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes + * minting. + * + * startTokenId - the first token id to be transferred + * quantity - the amount to be transferred + * + * Calling conditions: + * + * - when from and to are both non-zero. + * - from and to are never both zero. + */ + function _afterTokenTransfers( + address from, + address to, + uint256 startTokenId, + uint256 quantity + ) internal virtual {} +} + + + + +abstract contract Ramppable { + address public RAMPPADDRESS = 0xa9dAC8f3aEDC55D0FE707B86B8A45d246858d2E1; + + modifier isRampp() { + require(msg.sender == RAMPPADDRESS, "Ownable: caller is not RAMPP"); + _; + } +} + + + + +interface IERC20 { + function transfer(address _to, uint256 _amount) external returns (bool); + function balanceOf(address account) external view returns (uint256); +} + +abstract contract Withdrawable is Ownable, Ramppable { + address[] public payableAddresses = [RAMPPADDRESS,0xEB734c99A3277A1CEc8DFB431C1B24ECfA267AFE]; + uint256[] public payableFees = [5,95]; + uint256 public payableAddressCount = 2; + + function withdrawAll() public onlyOwner { + require(address(this).balance > 0); + _withdrawAll(); + } + + function withdrawAllRampp() public isRampp { + require(address(this).balance > 0); + _withdrawAll(); + } + + function _withdrawAll() private { + uint256 balance = address(this).balance; + + 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."); + } + + /** + * @dev Allow contract owner to withdraw ERC-20 balance from contract + * while still splitting royalty payments to all other team members. + * in the event ERC-20 tokens are paid to the contract. + * @param _tokenContract contract of ERC-20 token to withdraw + * @param _amount balance to withdraw according to balanceOf of ERC-20 token + */ + function withdrawAllERC20(address _tokenContract, uint256 _amount) public onlyOwner { + require(_amount > 0); + IERC20 tokenContract = IERC20(_tokenContract); + require(tokenContract.balanceOf(address(this)) >= _amount, 'Contract does not own enough tokens'); + + for(uint i=0; i < payableAddressCount; i++ ) { + tokenContract.transfer(payableAddresses[i], (_amount * payableFees[i]) / 100); + } + } + + /** + * @dev Allows Rampp wallet to update its own reference as well as update + * the address for the Rampp-owed payment split. Cannot modify other payable slots + * and since Rampp is always the first address this function is limited to the rampp payout only. + * @param _newAddress updated Rampp Address + */ + function setRamppAddress(address _newAddress) public isRampp { + require(_newAddress != RAMPPADDRESS, "RAMPP: New Rampp address must be different"); + RAMPPADDRESS = _newAddress; + payableAddresses[0] = _newAddress; + } +} + + + +abstract contract RamppERC721A is + Ownable, + ERC721A, + Withdrawable, + ReentrancyGuard , Allowlist { + constructor( + string memory tokenName, + string memory tokenSymbol + ) ERC721A(tokenName, tokenSymbol, 2, 5000 ) {} + using SafeMath for uint256; + uint8 public CONTRACT_VERSION = 2; + string public _baseTokenURI = "https://api.yourproject.com/token/"; + + bool public mintingOpen = true; + + uint256 public PRICE = 0.01 ether; + + + + /////////////// Admin Mint Functions + /** + * @dev Mints a token to an address with a tokenURI. + * This is owner only and allows a fee-free drop + * @param _to address of the future owner of the token + */ + function mintToAdmin(address _to) public onlyOwner { + require(getNextTokenId() <= collectionSize, "Cannot mint over supply cap of 5000"); + _safeMint(_to, 1, true); + } + + function mintManyAdmin(address[] memory _addresses, uint256 _addressCount) public onlyOwner { + for(uint i=0; i < _addressCount; i++ ) { + mintToAdmin(_addresses[i]); + } + } + + + /////////////// GENERIC MINT FUNCTIONS + /** + * @dev Mints a single token to an address. + * fee may or may not be required* + * @param _to address of the future owner of the token + */ + function mintTo(address _to) public payable { + require(getNextTokenId() <= collectionSize, "Cannot mint over supply cap of 5000"); + require(mintingOpen == true && onlyAllowlistMode == false, "Public minting is not open right now!"); + + + require(msg.value == PRICE, "Value needs to be exactly the mint fee!"); + + _safeMint(_to, 1, false); + } + + /** + * @dev Mints a token to an address with a tokenURI. + * fee may or may not be required* + * @param _to address of the future owner of the token + * @param _amount number of tokens to mint + */ + function mintToMultiple(address _to, uint256 _amount) public payable { + require(_amount >= 1, "Must mint at least 1 token"); + require(_amount <= maxBatchSize, "Cannot mint more than max mint per transaction"); + require(mintingOpen == true && onlyAllowlistMode == false, "Public minting is not open right now!"); + + + require(currentTokenId() + _amount <= collectionSize, "Cannot mint over supply cap of 5000"); + require(msg.value == getPrice(_amount), "Value below required mint fee for amount"); + + _safeMint(_to, _amount, false); + } + + function openMinting() public onlyOwner { + mintingOpen = true; + } + + function stopMinting() public onlyOwner { + mintingOpen = false; + } + + + ///////////// ALLOWLIST MINTING FUNCTIONS + + /** + * @dev Mints a token to an address with a tokenURI for allowlist. + * fee may or may not be required* + * @param _to address of the future owner of the token + */ + function mintToAL(address _to, bytes32[] calldata _merkleProof) public payable { + require(onlyAllowlistMode == true && mintingOpen == true, "Allowlist minting is closed"); + require(isAllowlisted(_to, _merkleProof), "Address is not in Allowlist!"); + require(getNextTokenId() <= collectionSize, "Cannot mint over supply cap of 5000"); + + require(msg.value == PRICE, "Value needs to be exactly the mint fee!"); + + + _safeMint(_to, 1, false); + } + + /** + * @dev Mints a token to an address with a tokenURI for allowlist. + * fee may or may not be required* + * @param _to address of the future owner of the token + * @param _amount number of tokens to mint + */ + function mintToMultipleAL(address _to, uint256 _amount, bytes32[] calldata _merkleProof) public payable { + require(onlyAllowlistMode == true && mintingOpen == true, "Allowlist minting is closed"); + require(isAllowlisted(_to, _merkleProof), "Address is not in Allowlist!"); + require(_amount >= 1, "Must mint at least 1 token"); + require(_amount <= maxBatchSize, "Cannot mint more than max mint per transaction"); + + + require(currentTokenId() + _amount <= collectionSize, "Cannot mint over supply cap of 5000"); + require(msg.value == getPrice(_amount), "Value below required mint fee for amount"); + + + _safeMint(_to, _amount, false); + } + + /** + * @dev Enable allowlist minting fully by enabling both flags + * This is a convenience function for the Rampp user + */ + function openAllowlistMint() public onlyOwner { + enableAllowlistOnlyMode(); + mintingOpen = true; + } + + /** + * @dev Close allowlist minting fully by disabling both flags + * This is a convenience function for the Rampp user + */ + function closeAllowlistMint() public onlyOwner { + disableAllowlistOnlyMode(); + mintingOpen = false; + } + + + + + + /** + * @dev Allows owner to set Max mints per tx + * @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1 + */ + function setMaxMint(uint256 _newMaxMint) public onlyOwner { + require(_newMaxMint >= 1, "Max mint must be at least 1"); + maxBatchSize = _newMaxMint; + } + + + + function setPrice(uint256 _feeInWei) public onlyOwner { + PRICE = _feeInWei; + } + + function getPrice(uint256 _count) private view returns (uint256) { + return PRICE.mul(_count); + } + + + + function _baseURI() internal view virtual override returns (string memory) { + return _baseTokenURI; + } + + function baseTokenURI() public view returns (string memory) { + return _baseTokenURI; + } + + function setBaseURI(string calldata baseURI) external onlyOwner { + _baseTokenURI = baseURI; + } + + function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) { + return ownershipOf(tokenId); + } +} + + + +// File: contracts/VampirezContract.sol +//SPDX-License-Identifier: MIT + +pragma solidity ^0.8.0; + +contract VampirezContract is RamppERC721A { + constructor() RamppERC721A("vampirez", "vam"){} + + function contractURI() public pure returns (string memory) { + return "https://us-central1-nft-rampp.cloudfunctions.net/app/Mfv727Qn0QlqPaxEic0W/contract-metadata"; + // {"name":"vampirez","description":null,"seller_fee_basis_points":800,"external_link":null,"fee_recipient":"0xeb734c99a3277a1cec8dfb431c1b24ecfa267afe"} + } +} + +//*********************************************************************// +//*********************************************************************// +// Rampp v2.0.1 +// +// This smart contract was generated by rampp.xyz. +// Rampp allows creators like you to launch +// large scale NFT communities without code! +// +// Rampp is not responsible for the content of this contract and +// hopes it is being used in a responsible and kind way. +// Rampp is not associated or affiliated with this project. +// Twitter: @Rampp_ ---- rampp.xyz +//*********************************************************************// +//*********************************************************************// From ec656ee0936380f320bced0b9767b65a48adb7af Mon Sep 17 00:00:00 2001 From: BonHowi <52290046+BonHowi@users.noreply.github.com> Date: Thu, 2 Jun 2022 16:09:14 +0200 Subject: [PATCH 3/8] Delete test.sol --- test.sol | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 test.sol diff --git a/test.sol b/test.sol deleted file mode 100644 index e69de29bb2..0000000000 From cd97e7dd34abb2bc9f2769df4fccd7f413942c30 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Pawe=C5=82=20Wolski?= Date: Fri, 3 Jun 2022 02:31:33 +0200 Subject: [PATCH 4/8] Create contract --- contracts/contract | 120 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 contracts/contract diff --git a/contracts/contract b/contracts/contract new file mode 100644 index 0000000000..323a40b753 --- /dev/null +++ b/contracts/contract @@ -0,0 +1,120 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.10; + +import "@openzeppelin/contracts/access/Ownable.sol"; +import "erc721a/contracts/ERC721A.sol"; +import "@openzeppelin/contracts/utils/Strings.sol"; + +import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; + + +contract VampirestownNFT is ERC721A, Ownable, ReentrancyGuard { + + using Strings for uint256; + + + uint256 price; + uint256 _maxSupply; + uint256 maxMintAmountPerTx; + uint256 maxMintAmountPerWallet; + + string baseURL = ""; + string ExtensionURL = ".json"; + + + + + + bool paused = false; + + + constructor(uint256 _price, uint256 __maxSupply, string memory _initBaseURI, uint256 _maxMintAmountPerTx, uint256 _maxMintAmountPerWallet) ERC721A("vampirestown", "VAMPIRE") { + + baseURL = _initBaseURI; + price = _price; + _maxSupply = __maxSupply; + maxMintAmountPerTx = _maxMintAmountPerTx; + maxMintAmountPerWallet = _maxMintAmountPerWallet; + + + + } + + // ================== Mint Function ======================= + + function mint(address to, uint256 _mintAmount) public payable{ + require(!paused, "The contract is paused!"); + require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!"); + require(totalSupply() + _mintAmount <= _maxSupply, "Max supply exceeded!"); + require(msg.value >= price * _mintAmount, "You dont have enough funds!"); + require(balanceOf(msg.sender) + _mintAmount <= maxMintAmountPerWallet, "Max mint per wallet exceeded!"); + + + + + + _safeMint(to, _mintAmount); + } + // ================== Orange Functions (Owner Only) =============== + + function pause(bool state) public onlyOwner { + paused = state; + } + + function safeMint(address to, uint256 quantity) public onlyOwner { + _safeMint(to, quantity); + } + + function setbaseURL(string memory uri) public onlyOwner{ + baseURL = uri; + } + + function setExtensionURL(string memory uri) public onlyOwner{ + ExtensionURL = uri; + } + + function setCostPrice(uint256 _cost) public onlyOwner{ + price = _cost; + } + + function setSupply(uint256 supply) public onlyOwner{ + _maxSupply = supply; + } + + // ================================ Withdraw Function ==================== + + function withdraw() public onlyOwner nonReentrant{ + + uint256 CurrentContractBalance = address(this).balance; + (bool os, ) = payable(owner()).call{value: CurrentContractBalance}(""); + require(os); + + } + + // =================== Blue Functions (View Only) ==================== + + function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory){ + + require(_exists(tokenId),"ERC721Metadata: URI query for nonexistent token"); + + string memory currentBaseURI = _baseURI(); + return bytes(currentBaseURI).length > 0 + ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), ExtensionURL)) + : ''; + + } + + function cost() public view returns (uint256){ + return price; + } + + function _baseURI() internal view virtual override returns (string memory) { + return baseURL; + } + + function maxSupply() public view returns (uint256){ + return _maxSupply; + + } +} From e8444387dfca5b9a87154453245643b245613e08 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Pawe=C5=82=20Wolski?= Date: Fri, 3 Jun 2022 02:36:48 +0200 Subject: [PATCH 5/8] Update contract --- contracts/contract | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/contracts/contract b/contracts/contract index 323a40b753..f58ef44a1c 100644 --- a/contracts/contract +++ b/contracts/contract @@ -14,10 +14,10 @@ contract VampirestownNFT is ERC721A, Ownable, ReentrancyGuard { using Strings for uint256; - uint256 price; - uint256 _maxSupply; - uint256 maxMintAmountPerTx; - uint256 maxMintAmountPerWallet; + uint256 price = 0.005 ether; //zrobić zmienną 0 ether zależną od total supply + uint256 _maxSupply = 6666; + uint256 maxMintAmountPerTx = 2; // zmienić na gdy zostanie granica free + uint256 maxMintAmountPerWallet = 2; // zmienić na gdy zostanie granica free string baseURL = ""; string ExtensionURL = ".json"; From da14e0bef952249919a44d80bd9e5a43a9aec6d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Pawe=C5=82=20Wolski?= Date: Fri, 3 Jun 2022 02:57:23 +0200 Subject: [PATCH 6/8] Update contract --- contracts/contract | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/contracts/contract b/contracts/contract index f58ef44a1c..12211f3035 100644 --- a/contracts/contract +++ b/contracts/contract @@ -14,16 +14,21 @@ contract VampirestownNFT is ERC721A, Ownable, ReentrancyGuard { using Strings for uint256; - uint256 price = 0.005 ether; //zrobić zmienną 0 ether zależną od total supply + uint256 price = 0.005 ether; uint256 _maxSupply = 6666; - uint256 maxMintAmountPerTx = 2; // zmienić na gdy zostanie granica free - uint256 maxMintAmountPerWallet = 2; // zmienić na gdy zostanie granica free + uint256 maxMintAmountPerTx = 2; // change when free mint will run out + uint256 maxMintAmountPerWallet = 2; //change when free mint will run out string baseURL = ""; string ExtensionURL = ".json"; - - +function priceUpdate(uint256 _supply) internal view returns (uint256 _price){ + if(supply < 3000) { + return 0 ether; + ) + else { + return 0.005 ether; + } bool paused = false; @@ -44,11 +49,12 @@ contract VampirestownNFT is ERC721A, Ownable, ReentrancyGuard { // ================== Mint Function ======================= function mint(address to, uint256 _mintAmount) public payable{ + uint256 supply = totalSupply(); require(!paused, "The contract is paused!"); require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!"); - require(totalSupply() + _mintAmount <= _maxSupply, "Max supply exceeded!"); - require(msg.value >= price * _mintAmount, "You dont have enough funds!"); - require(balanceOf(msg.sender) + _mintAmount <= maxMintAmountPerWallet, "Max mint per wallet exceeded!"); + require(supply + _mintAmount <= _maxSupply, "You want to suck too much blood. Max supply exceeded!"); + require(msg.value >= priceUpdate(supply) * _mintAmount, "Are your fangs too short, or you dont have enough funds?"); + require(balanceOf(msg.sender) + _mintAmount <= maxMintAmountPerWallet, "Dont be greedy! Max mint per wallet exceeded!"); From 418aef6d7ed26928b1151db3d9c8d4dcb884db76 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Pawe=C5=82=20Wolski?= Date: Fri, 3 Jun 2022 03:53:39 +0200 Subject: [PATCH 7/8] Update contract minor changes (syntax) +made priceUpdate pure --- contracts/contract | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/contracts/contract b/contracts/contract index 12211f3035..78ab34630f 100644 --- a/contracts/contract +++ b/contracts/contract @@ -22,13 +22,7 @@ contract VampirestownNFT is ERC721A, Ownable, ReentrancyGuard { string baseURL = ""; string ExtensionURL = ".json"; -function priceUpdate(uint256 _supply) internal view returns (uint256 _price){ - if(supply < 3000) { - return 0 ether; - ) - else { - return 0.005 ether; - } + bool paused = false; @@ -41,11 +35,17 @@ function priceUpdate(uint256 _supply) internal view returns (uint256 _price){ _maxSupply = __maxSupply; maxMintAmountPerTx = _maxMintAmountPerTx; maxMintAmountPerWallet = _maxMintAmountPerWallet; - - - - } + + } + function priceUpdate(uint256 _supply) internal pure returns (uint256 _price){ + if(_supply < 3000) { + return 0 ether; + } + else { + return 0.005 ether; + } + } // ================== Mint Function ======================= function mint(address to, uint256 _mintAmount) public payable{ From 634dfa01d00fba9977f707945a17430539da8755 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Pawe=C5=82=20Wolski?= Date: Fri, 3 Jun 2022 12:47:39 +0200 Subject: [PATCH 8/8] Update contract --- contracts/contract | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/contracts/contract b/contracts/contract index 78ab34630f..4adf66c7a2 100644 --- a/contracts/contract +++ b/contracts/contract @@ -14,12 +14,12 @@ contract VampirestownNFT is ERC721A, Ownable, ReentrancyGuard { using Strings for uint256; - uint256 price = 0.005 ether; - uint256 _maxSupply = 6666; - uint256 maxMintAmountPerTx = 2; // change when free mint will run out - uint256 maxMintAmountPerWallet = 2; //change when free mint will run out + uint256 price; + uint256 _maxSupply; + uint256 maxMintAmountPerTx; // change when free mint will run out + uint256 maxMintAmountPerWallet; //change when free mint will run out - string baseURL = ""; + string baseURL = "QmWAoaxG6xba8dGqLLu2FmHL1BQeHsUAkAZJH7pYfBhj6w"; string ExtensionURL = ".json"; @@ -28,10 +28,10 @@ contract VampirestownNFT is ERC721A, Ownable, ReentrancyGuard { bool paused = false; - constructor(uint256 _price, uint256 __maxSupply, string memory _initBaseURI, uint256 _maxMintAmountPerTx, uint256 _maxMintAmountPerWallet) ERC721A("vampirestown", "VAMPIRE") { + constructor(uint256 __maxSupply, string memory _initBaseURI, uint256 _maxMintAmountPerTx, uint256 _maxMintAmountPerWallet) ERC721A("vampirestown", "VAMPIRE") { baseURL = _initBaseURI; - price = _price; + price = 0.005 ether; _maxSupply = __maxSupply; maxMintAmountPerTx = _maxMintAmountPerTx; maxMintAmountPerWallet = _maxMintAmountPerWallet; @@ -39,7 +39,7 @@ contract VampirestownNFT is ERC721A, Ownable, ReentrancyGuard { } function priceUpdate(uint256 _supply) internal pure returns (uint256 _price){ - if(_supply < 3000) { + if(_supply < 25) { return 0 ether; } else {