Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.0.2/contracts/access/Ownable.sol";
import "./libs/SafeTransferLib.sol";

contract AUPresale is Ownable {
  INFT private immutable CONTRACT_AD; // mainnet: 0x9CF0aB1cc434dB83097B7E9c831a764481DEc747
  INFT private immutable CONTRACT_AU;
  uint256 public immutable startTime;

  uint256 private constant SPLIT = 70;
  IDelegateRegistry private constant REGISTRY = IDelegateRegistry(0x00000000000000447e69651d841bD8D104Bed493);
  uint256 private constant SAFE_GAS_LIMIT = 30_000;
  uint256 private constant hatchlingPrice = 0.4 ether;
  uint256 private constant familiesPrice = 0.15 ether;

  address public artist;
  address public beneficiary;
  bool public paused;

  mapping(address => uint256) public discountCount;
  mapping(uint256 => bool) public sold;

  event Sold(
    uint256 indexed tokenId,
    address indexed buyer
  );

  constructor(
    address _alignDraw,
    address _abyssalUnseen,
    address _artist,
    uint256 _startTime
  ) Ownable(msg.sender) {
    artist = _artist;
    beneficiary = msg.sender;
    CONTRACT_AD = INFT(_alignDraw);
    CONTRACT_AU = INFT(_abyssalUnseen);
    startTime = _startTime;
  }

  function buyNow(
    uint256 tokenId
  ) external payable {
    require(tokenId >= 1 && tokenId <= 1000);
    require(!paused, 'Buying is paused');
    require(block.timestamp >= startTime && block.timestamp < startTime + 48 hours, 'Presale not active.');
    require(sold[tokenId] == false, 'Token already sold.');
    uint256 amountToPay = tokenId <= 100 ? hatchlingPrice : familiesPrice;
    if (aDCount(msg.sender) > discountCount[msg.sender]) {
        amountToPay = amountToPay / 2;
        discountCount[msg.sender] += 1;
    }
    require(msg.value == amountToPay, 'Incorrect ETH sent.');
    sold[tokenId] = true;
    emit Sold(tokenId, msg.sender);
    _mint(msg.sender, tokenId);
    uint256 amountForArtist = amountToPay * SPLIT / 100;
    SafeTransferLib.forceSafeTransferETH(artist, amountForArtist, SAFE_GAS_LIMIT);
    SafeTransferLib.forceSafeTransferETH(beneficiary, amountToPay - amountForArtist, SAFE_GAS_LIMIT);
  }

  function buyNowMultiple(
    uint256[] calldata tokenIds
  ) external payable {
    require(!paused, 'Buying is paused');
    require(block.timestamp >= startTime && block.timestamp < startTime + 48 hours, 'Presale not active.');

    uint256 totalPrice;
    uint256 adCount = aDCount(msg.sender);
    uint256 dCount = discountCount[msg.sender];
    for(uint256 i; i < tokenIds.length; ++i) {
      uint256 tokenId = tokenIds[i];
      if (sold[tokenId] == true) {
        continue;
      }
      uint256 amountToPay = tokenId <= 100 ? hatchlingPrice : familiesPrice;
      if (adCount > dCount) {
        amountToPay = amountToPay / 2;
        dCount += 1;
      }
      totalPrice += amountToPay;
      sold[tokenId] = true;
      emit Sold(tokenId, msg.sender);
      _mint(msg.sender, tokenId);
    }
    discountCount[msg.sender] = dCount;
    require(totalPrice <= msg.value, 'Incorrect ETH amount sent.');

    uint256 amountForArtist = totalPrice * SPLIT / 100;
    SafeTransferLib.forceSafeTransferETH(artist, amountForArtist, SAFE_GAS_LIMIT);
    SafeTransferLib.forceSafeTransferETH(beneficiary, totalPrice - amountForArtist, SAFE_GAS_LIMIT);

    uint256 overrage = msg.value - totalPrice;
    if (overrage > 0) {
      SafeTransferLib.forceSafeTransferETH(msg.sender, overrage, SAFE_GAS_LIMIT);
    }
  }

  function _mint(
    address to,
    uint256 tokenId
  ) internal {
    CONTRACT_AU.mint(to, tokenId);
  }

  // ONLY OWNER

  function setArtist(
    address _artist
  ) external onlyOwner {
    artist = _artist;
  }

  function setBeneficiary(
    address _beneficiary
  ) external onlyOwner {
    beneficiary = _beneficiary;
  }

  function setPaused(
    bool _paused
  ) external onlyOwner {
    paused = _paused;
  }

  // GETTERS

  function aDCount(address user) public view returns (uint256 total) {
    total = CONTRACT_AD.balanceOf(user);
    IDelegateRegistry.Delegation[] memory delegations = REGISTRY.getIncomingDelegations(user);
    for(uint256 i; i < delegations.length; i++) {
      IDelegateRegistry.Delegation memory dele = delegations[i];
      if (dele.type_ == IDelegateRegistry.DelegationType.ALL) {
        total += CONTRACT_AD.balanceOf(dele.from);
      }
      if (dele.type_ == IDelegateRegistry.DelegationType.CONTRACT && dele.contract_ == address(CONTRACT_AD)) {
        total += CONTRACT_AD.balanceOf(dele.from);
      }
    }
  }
}

interface INFT {
  function balanceOf(address account) external view returns (uint256);
  function mint(address to, uint256 tokenId) external;
  function ownerOf(uint256 tokenId) external view returns (address);
  function transferFrom(address from, address to, uint256 tokenId) external;
}

interface IDelegateRegistry {
    /// @notice Delegation type, NONE is used when a delegation does not exist or is revoked
    enum DelegationType {
        NONE,
        ALL,
        CONTRACT,
        ERC721,
        ERC20,
        ERC1155
    }

    /// @notice Struct for returning delegations
    struct Delegation {
        DelegationType type_;
        address to;
        address from;
        bytes32 rights;
        address contract_;
        uint256 tokenId;
        uint256 amount;
    }

    function getIncomingDelegations(address to) external view returns (Delegation[] memory delegations);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.4;

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
///
/// @dev Note:
/// - For ETH transfers, please use `forceSafeTransferETH` for gas griefing protection.
/// - For ERC20s, this implementation won't check that a token has code,
/// responsibility is delegated to the caller.
library SafeTransferLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ETH transfer has failed.
    error ETHTransferFailed();

    /// @dev The ERC20 `transferFrom` has failed.
    error TransferFromFailed();

    /// @dev The ERC20 `transfer` has failed.
    error TransferFailed();

    /// @dev The ERC20 `approve` has failed.
    error ApproveFailed();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Suggested gas stipend for contract receiving ETH
    /// that disallows any storage writes.
    uint256 internal constant _GAS_STIPEND_NO_STORAGE_WRITES = 2300;

    /// @dev Suggested gas stipend for contract receiving ETH to perform a few
    /// storage reads and writes, but low enough to prevent griefing.
    /// Multiply by a small constant (e.g. 2), if needed.
    uint256 internal constant _GAS_STIPEND_NO_GRIEF = 100000;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       ETH OPERATIONS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Sends `amount` (in wei) ETH to `to`.
    /// Reverts upon failure.
    ///
    /// Note: This implementation does NOT protect against gas griefing.
    /// Please use `forceSafeTransferETH` for gas griefing protection.
    function safeTransferETH(address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(gas(), to, amount, 0, 0, 0, 0)) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    /// The `gasStipend` can be set to a low enough value to prevent
    /// storage writes or gas griefing.
    ///
    /// If sending via the normal procedure fails, force sends the ETH by
    /// creating a temporary contract which uses `SELFDESTRUCT` to force send the ETH.
    ///
    /// Reverts if the current contract has insufficient balance.
    function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // If insufficient balance, revert.
            if lt(selfbalance(), amount) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(gasStipend, to, amount, 0, 0, 0, 0)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                // We can directly use `SELFDESTRUCT` in the contract creation.
                // Compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758
                if iszero(create(amount, 0x0b, 0x16)) {
                    // To coerce gas estimation to provide enough gas for the `create` above.
                    if iszero(gt(gas(), 1000000)) { revert(0, 0) }
                }
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with a gas stipend
    /// equal to `_GAS_STIPEND_NO_GRIEF`. This gas stipend is a reasonable default
    /// for 99% of cases and can be overridden with the three-argument version of this
    /// function if necessary.
    ///
    /// If sending via the normal procedure fails, force sends the ETH by
    /// creating a temporary contract which uses `SELFDESTRUCT` to force send the ETH.
    ///
    /// Reverts if the current contract has insufficient balance.
    function forceSafeTransferETH(address to, uint256 amount) internal {
        // Manually inlined because the compiler doesn't inline functions with branches.
        /// @solidity memory-safe-assembly
        assembly {
            // If insufficient balance, revert.
            if lt(selfbalance(), amount) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(_GAS_STIPEND_NO_GRIEF, to, amount, 0, 0, 0, 0)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                // We can directly use `SELFDESTRUCT` in the contract creation.
                // Compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758
                if iszero(create(amount, 0x0b, 0x16)) {
                    // To coerce gas estimation to provide enough gas for the `create` above.
                    if iszero(gt(gas(), 1000000)) { revert(0, 0) }
                }
            }
        }
    }

    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    /// The `gasStipend` can be set to a low enough value to prevent
    /// storage writes or gas griefing.
    ///
    /// Simply use `gasleft()` for `gasStipend` if you don't need a gas stipend.
    ///
    /// Note: Does NOT revert upon failure.
    /// Returns whether the transfer of ETH is successful instead.
    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
        internal
        returns (bool success)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and check if it succeeded or not.
            success := call(gasStipend, to, amount, 0, 0, 0, 0)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      ERC20 OPERATIONS                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have at least `amount` approved for
    /// the current contract to manage.
    function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.

            mstore(0x60, amount) // Store the `amount` argument.
            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            // Store the function selector of `transferFrom(address,address,uint256)`.
            mstore(0x0c, 0x23b872dd000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends all of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have their entire balance approved for
    /// the current contract to manage.
    function safeTransferAllFrom(address token, address from, address to)
        internal
        returns (uint256 amount)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.

            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            // Store the function selector of `balanceOf(address)`.
            mstore(0x0c, 0x70a08231000000000000000000000000)
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // Store the function selector of `transferFrom(address,address,uint256)`.
            mstore(0x00, 0x23b872dd)
            // The `amount` argument is already written to the memory word at 0x60.
            amount := mload(0x60)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransfer(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            // Store the function selector of `transfer(address,uint256)`.
            mstore(0x00, 0xa9059cbb000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Sends all of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransferAll(address token, address to) internal returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.
            mstore(0x20, address()) // Store the address of the current contract.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x14, to) // Store the `to` argument.
            // The `amount` argument is already written to the memory word at 0x34.
            amount := mload(0x34)
            // Store the function selector of `transfer(address,uint256)`.
            mstore(0x00, 0xa9059cbb000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
    /// Reverts upon failure.
    function safeApprove(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            // Store the function selector of `approve(address,uint256)`.
            mstore(0x00, 0x095ea7b3000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `ApproveFailed()`.
                mstore(0x00, 0x3e3f8f73)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Returns the amount of ERC20 `token` owned by `account`.
    /// Returns zero if the `token` does not exist.
    function balanceOf(address token, address account) internal view returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, account) // Store the `account` argument.
            // Store the function selector of `balanceOf(address)`.
            mstore(0x00, 0x70a08231000000000000000000000000)
            amount :=
                mul(
                    mload(0x20),
                    and( // The arguments of `and` are evaluated from right to left.
                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
                    )
                )
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "remappings": []
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_alignDraw","type":"address"},{"internalType":"address","name":"_abyssalUnseen","type":"address"},{"internalType":"address","name":"_artist","type":"address"},{"internalType":"uint256","name":"_startTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"buyer","type":"address"}],"name":"Sold","type":"event"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"aDCount","outputs":[{"internalType":"uint256","name":"total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"artist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"buyNow","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"buyNowMultiple","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"discountCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_artist","type":"address"}],"name":"setArtist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"setBeneficiary","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"sold","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

202:4385:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1263:936;;;;;;:::i;:::-;;:::i;:::-;;3963:622;;;;;;;;;;-1:-1:-1;3963:622:0;;;;;:::i;:::-;;:::i;:::-;;;733:25:4;;;721:2;706:18;3963:622:0;;;;;;;;3858:87;;;;;;;;;;-1:-1:-1;3858:87:0;;;;;:::i;:::-;;:::i;3744:110::-;;;;;;;;;;-1:-1:-1;3744:110:0;;;;;:::i;:::-;;:::i;744:26::-;;;;;;;;;;-1:-1:-1;744:26:0;;;;-1:-1:-1;;;;;744:26:0;;;;;;-1:-1:-1;;;;;1211:32:4;;;1193:51;;1181:2;1166:18;744:26:0;1047:203:4;719:21:0;;;;;;;;;;-1:-1:-1;719:21:0;;;;-1:-1:-1;;;;;719:21:0;;;797:48;;;;;;;;;;-1:-1:-1;797:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;2203:1317;;;;;;:::i;:::-;;:::i;774:18::-;;;;;;;;;;-1:-1:-1;774:18:0;;;;-1:-1:-1;;;774:18:0;;;;;;;;;2040:14:4;;2033:22;2015:41;;2003:2;1988:18;774::0;1875:187:4;2293:101:2;;;;;;;;;;;;;:::i;367:34:0:-;;;;;;;;;;;;;;;1638:85:2;;;;;;;;;;-1:-1:-1;1684:7:2;1710:6;-1:-1:-1;;;;;1710:6:2;1638:85;;849:36:0;;;;;;;;;;-1:-1:-1;849:36:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;3650:90;;;;;;;;;;-1:-1:-1;3650:90:0;;;;;:::i;:::-;;:::i;2543:215:2:-;;;;;;;;;;-1:-1:-1;2543:215:2;;;;;:::i;:::-;;:::i;1263:936:0:-;1346:1;1335:7;:12;;:31;;;;;1362:4;1351:7;:15;;1335:31;1327:40;;;;;;1382:6;;-1:-1:-1;;;1382:6:0;;;;1381:7;1373:36;;;;-1:-1:-1;;;1373:36:0;;2269:2:4;1373:36:0;;;2251:21:4;2308:2;2288:18;;;2281:30;-1:-1:-1;;;2327:18:4;;;2320:46;2383:18;;1373:36:0;;;;;;;;;1442:9;1423:15;:28;;:70;;;;-1:-1:-1;1473:20:0;:9;1485:8;1473:20;:::i;:::-;1455:15;:38;1423:70;1415:102;;;;-1:-1:-1;;;1415:102:0;;2876:2:4;1415:102:0;;;2858:21:4;2915:2;2895:18;;;2888:30;-1:-1:-1;;;2934:18:4;;;2927:49;2993:18;;1415:102:0;2674:343:4;1415:102:0;1531:13;;;;:4;:13;;;;;;;;:22;1523:54;;;;-1:-1:-1;;;1523:54:0;;3224:2:4;1523:54:0;;;3206:21:4;3263:2;3243:18;;;3236:30;-1:-1:-1;;;3282:18:4;;;3275:49;3341:18;;1523:54:0;3022:343:4;1523:54:0;1583:19;1616:3;1605:7;:14;;:47;;704:10;1605:47;;;650:9;1605:47;1698:10;1684:25;;;;:13;:25;;;;;;1583:69;;-1:-1:-1;1662:19:0;;:7;:19::i;:::-;:47;1658:139;;;1735:15;1749:1;1735:11;:15;:::i;:::-;1774:10;1760:25;;;;:13;:25;;;;;:30;;1721:29;;-1:-1:-1;1789:1:0;;1760:25;;;:30;;1789:1;;1760:30;:::i;:::-;;;;-1:-1:-1;;1658:139:0;1823:11;1810:9;:24;1802:56;;;;-1:-1:-1;;;1802:56:0;;3794:2:4;1802:56:0;;;3776:21:4;3833:2;3813:18;;;3806:30;-1:-1:-1;;;3852:18:4;;;3845:49;3911:18;;1802:56:0;3592:343:4;1802:56:0;1864:13;;;;:4;:13;;;;;;:20;;-1:-1:-1;;1864:20:0;1880:4;1864:20;;;1895:25;1909:10;;1869:7;;1895:25;;1864:13;1895:25;1926:26;1932:10;1944:7;1926:5;:26::i;:::-;1958:23;2006:3;1984:19;439:2;1984:11;:19;:::i;:::-;:25;;;;:::i;:::-;2052:6;;1958:51;;-1:-1:-1;2015:77:0;;-1:-1:-1;;;;;2052:6:0;1958:51;598:6;2015:36;:77::i;:::-;2135:11;;2098:96;;-1:-1:-1;;;;;2135:11:0;2148:29;2162:15;2148:11;:29;:::i;:::-;598:6;2098:36;:96::i;:::-;1321:878;;1263:936;:::o;3963:622::-;4044:27;;-1:-1:-1;;;4044:27:0;;-1:-1:-1;;;;;1211:32:4;;;4044:27:0;;;1193:51:4;4015:13:0;;4044:11;:21;;;;;;1166:18:4;;4044:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4129:37;;-1:-1:-1;;;4129:37:0;;-1:-1:-1;;;;;1211:32:4;;4129:37:0;;;1193:51:4;4036:35:0;;-1:-1:-1;4077:49:0;;509:42;;4129:31;;1166:18:4;;4129:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4129:37:0;;;;;;;;;;;;:::i;:::-;4077:89;;4176:9;4172:409;4191:11;:18;4187:1;:22;4172:409;;;4224:40;4267:11;4279:1;4267:14;;;;;;;;:::i;:::-;;;;;;;4224:57;;4307:36;4293:50;;;;;;;;:::i;:::-;:10;;:50;;;;;;;;:::i;:::-;;4289:116;;4386:9;;;;;4364:32;;-1:-1:-1;;;4364:32:0;;-1:-1:-1;;;;;1211:32:4;;;4364::0;;;1193:51:4;4364:11:0;:21;;;;;;1166:18:4;;4364:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4355:41;;;;:::i;:::-;;;4289:116;4430:41;4416:10;;:55;;;;;;;;:::i;:::-;;:97;;;;;4501:11;-1:-1:-1;;;;;4475:38:0;:4;:14;;;-1:-1:-1;;;;;4475:38:0;;4416:97;4412:163;;;4556:9;;;;;4534:32;;-1:-1:-1;;;4534:32:0;;-1:-1:-1;;;;;1211:32:4;;;4534::0;;;1193:51:4;4534:11:0;:21;;;;;;1166:18:4;;4534:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4525:41;;;;:::i;:::-;;;4412:163;-1:-1:-1;4211:3:0;;4172:409;;;;4030:555;3963:622;;;:::o;3858:87::-;1531:13:2;:11;:13::i;:::-;3924:6:0::1;:16:::0;;;::::1;;-1:-1:-1::0;;;3924:16:0::1;-1:-1:-1::0;;;;3924:16:0;;::::1;::::0;;;::::1;::::0;;3858:87::o;3744:110::-;1531:13:2;:11;:13::i;:::-;3823:11:0::1;:26:::0;;-1:-1:-1;;;;;;3823:26:0::1;-1:-1:-1::0;;;;;3823:26:0;;;::::1;::::0;;;::::1;::::0;;3744:110::o;2203:1317::-;2296:6;;-1:-1:-1;;;2296:6:0;;;;2295:7;2287:36;;;;-1:-1:-1;;;2287:36:0;;2269:2:4;2287:36:0;;;2251:21:4;2308:2;2288:18;;;2281:30;-1:-1:-1;;;2327:18:4;;;2320:46;2383:18;;2287:36:0;2067:340:4;2287:36:0;2356:9;2337:15;:28;;:70;;;;-1:-1:-1;2387:20:0;:9;2399:8;2387:20;:::i;:::-;2369:15;:38;2337:70;2329:102;;;;-1:-1:-1;;;2329:102:0;;2876:2:4;2329:102:0;;;2858:21:4;2915:2;2895:18;;;2888:30;-1:-1:-1;;;2934:18:4;;;2927:49;2993:18;;2329:102:0;2674:343:4;2329:102:0;2438:18;2462:15;2480:19;2488:10;2480:7;:19::i;:::-;2536:10;2505:14;2522:25;;;:13;:25;;;;;;2462:37;;-1:-1:-1;2553:454:0;2568:19;;;2553:454;;;2602:15;2620:8;;2629:1;2620:11;;;;;;;:::i;:::-;;;;;;;;;;2643:13;;;;:4;:13;;;;;;;;2620:11;;-1:-1:-1;;2643:13:0;;:21;;:13;:21;2639:54;;2676:8;;;2639:54;2700:19;2733:3;2722:7;:14;;:47;;704:10;2722:47;;;650:9;2722:47;2700:69;;2791:6;2781:7;:16;2777:91;;;2823:15;2837:1;2823:11;:15;:::i;:::-;2809:29;-1:-1:-1;2848:11:0;2858:1;2848:11;;:::i;:::-;;;2777:91;2875:25;2889:11;2875:25;;:::i;:::-;2908:13;;;;:4;:13;;;;;;:20;;-1:-1:-1;;2908:20:0;2924:4;2908:20;;;2941:25;2875;;-1:-1:-1;2955:10:0;;2913:7;;2941:25;;;2974:26;2980:10;2992:7;2974:5;:26::i;:::-;2594:413;;2553:454;2589:3;;2553:454;;;-1:-1:-1;3026:10:0;3012:25;;;;:13;:25;;;;;:34;;;3074:9;3060:23;;;3052:62;;;;-1:-1:-1;;;3052:62:0;;7464:2:4;3052:62:0;;;7446:21:4;7503:2;7483:18;;;7476:30;7542:28;7522:18;;;7515:56;7588:18;;3052:62:0;7262:350:4;3052:62:0;3121:23;3168:3;3147:18;439:2;3147:10;:18;:::i;:::-;:24;;;;:::i;:::-;3214:6;;3121:50;;-1:-1:-1;3177:77:0;;-1:-1:-1;;;;;3214:6:0;3121:50;598:6;3177:36;:77::i;:::-;3297:11;;3260:95;;-1:-1:-1;;;;;3297:11:0;3310:28;3323:15;3310:10;:28;:::i;3260:95::-;3362:16;3381:22;3393:10;3381:9;:22;:::i;:::-;3362:41;-1:-1:-1;3413:12:0;;3409:107;;3435:74;3472:10;3484:8;598:6;3435:36;:74::i;:::-;2281:1239;;;;;2203:1317;;:::o;2293:101:2:-;1531:13;:11;:13::i;:::-;2357:30:::1;2384:1;2357:18;:30::i;:::-;2293:101::o:0;3650:90:0:-;1531:13:2;:11;:13::i;:::-;3719:6:0::1;:16:::0;;-1:-1:-1;;;;;;3719:16:0::1;-1:-1:-1::0;;;;;3719:16:0;;;::::1;::::0;;;::::1;::::0;;3650:90::o;2543:215:2:-;1531:13;:11;:13::i;:::-;-1:-1:-1;;;;;2627:22:2;::::1;2623:91;;2672:31;::::0;-1:-1:-1;;;2672:31:2;;2700:1:::1;2672:31;::::0;::::1;1193:51:4::0;1166:18;;2672:31:2::1;1047:203:4::0;2623:91:2::1;2723:28;2742:8;2723:18;:28::i;:::-;2543:215:::0;:::o;3524:105:0:-;3595:29;;-1:-1:-1;;;3595:29:0;;-1:-1:-1;;;;;7809:32:4;;;3595:29:0;;;7791:51:4;7858:18;;;7851:34;;;3595:11:0;:16;;;;7764:18:4;;3595:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3524:105;;:::o;3371:1204:1:-;3603:6;3588:13;3585:25;3582:240;;;3715:10;3709:4;3702:24;3803:4;3797;3790:18;3582:240;3949:1;3946;3943;3940;3932:6;3928:2;3916:10;3911:40;3901:658;;3984:2;3978:4;3971:16;4057:4;4051;4043:19;4113:4;4107;4099:19;4358:4;4352;4344:6;4337:26;4327:218;;4501:7;4494:5;4491:18;4481:46;;4523:1;4520;4513:12;1796:162:2;1684:7;1710:6;-1:-1:-1;;;;;1710:6:2;735:10:3;1855:23:2;1851:101;;1901:40;;-1:-1:-1;;;1901:40:2;;735:10:3;1901:40:2;;;1193:51:4;1166:18;;1901:40:2;1047:203:4;2912:187:2;2985:16;3004:6;;-1:-1:-1;;;;;3020:17:2;;;-1:-1:-1;;;;;;3020:17:2;;;;;;3052:40;;3004:6;;;;;;;3052:40;;2985:16;3052:40;2975:124;2912:187;:::o;14:180:4:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:4;;14:180;-1:-1:-1;14:180:4:o;199:131::-;-1:-1:-1;;;;;274:31:4;;264:42;;254:70;;320:1;317;310:12;335:247;394:6;447:2;435:9;426:7;422:23;418:32;415:52;;;463:1;460;453:12;415:52;502:9;489:23;521:31;546:5;521:31;:::i;:::-;571:5;335:247;-1:-1:-1;;;335:247:4:o;769:273::-;825:6;878:2;866:9;857:7;853:23;849:32;846:52;;;894:1;891;884:12;846:52;933:9;920:23;986:5;979:13;972:21;965:5;962:32;952:60;;1008:1;1005;998:12;1255:615;1341:6;1349;1402:2;1390:9;1381:7;1377:23;1373:32;1370:52;;;1418:1;1415;1408:12;1370:52;1458:9;1445:23;1487:18;1528:2;1520:6;1517:14;1514:34;;;1544:1;1541;1534:12;1514:34;1582:6;1571:9;1567:22;1557:32;;1627:7;1620:4;1616:2;1612:13;1608:27;1598:55;;1649:1;1646;1639:12;1598:55;1689:2;1676:16;1715:2;1707:6;1704:14;1701:34;;;1731:1;1728;1721:12;1701:34;1784:7;1779:2;1769:6;1766:1;1762:14;1758:2;1754:23;1750:32;1747:45;1744:65;;;1805:1;1802;1795:12;1744:65;1836:2;1828:11;;;;;1858:6;;-1:-1:-1;1255:615:4;;-1:-1:-1;;;;1255:615:4:o;2412:127::-;2473:10;2468:3;2464:20;2461:1;2454:31;2504:4;2501:1;2494:15;2528:4;2525:1;2518:15;2544:125;2609:9;;;2630:10;;;2627:36;;;2643:18;;:::i;:::-;2544:125;;;;:::o;3370:217::-;3410:1;3436;3426:132;;3480:10;3475:3;3471:20;3468:1;3461:31;3515:4;3512:1;3505:15;3543:4;3540:1;3533:15;3426:132;-1:-1:-1;3572:9:4;;3370:217::o;3940:168::-;4013:9;;;4044;;4061:15;;;4055:22;;4041:37;4031:71;;4082:18;;:::i;4113:128::-;4180:9;;;4201:11;;;4198:37;;;4215:18;;:::i;4246:184::-;4316:6;4369:2;4357:9;4348:7;4344:23;4340:32;4337:52;;;4385:1;4382;4375:12;4337:52;-1:-1:-1;4408:16:4;;4246:184;-1:-1:-1;4246:184:4:o;4435:127::-;4496:10;4491:3;4487:20;4484:1;4477:31;4527:4;4524:1;4517:15;4551:4;4548:1;4541:15;4567:253;4639:2;4633:9;4681:4;4669:17;;4716:18;4701:34;;4737:22;;;4698:62;4695:88;;;4763:18;;:::i;:::-;4799:2;4792:22;4567:253;:::o;4825:275::-;4896:2;4890:9;4961:2;4942:13;;-1:-1:-1;;4938:27:4;4926:40;;4996:18;4981:34;;5017:22;;;4978:62;4975:88;;;5043:18;;:::i;:::-;5079:2;5072:22;4825:275;;-1:-1:-1;4825:275:4:o;5105:138::-;5184:13;;5206:31;5184:13;5206:31;:::i;:::-;5105:138;;;:::o;5248:1745::-;5370:6;5401:2;5444;5432:9;5423:7;5419:23;5415:32;5412:52;;;5460:1;5457;5450:12;5412:52;5493:9;5487:16;5522:18;5563:2;5555:6;5552:14;5549:34;;;5579:1;5576;5569:12;5549:34;5617:6;5606:9;5602:22;5592:32;;5662:7;5655:4;5651:2;5647:13;5643:27;5633:55;;5684:1;5681;5674:12;5633:55;5713:2;5707:9;5735:2;5731;5728:10;5725:36;;;5741:18;;:::i;:::-;5781:36;5813:2;5808;5805:1;5801:10;5797:19;5781:36;:::i;:::-;5851:15;;;5882:12;;;;-1:-1:-1;5913:4:4;5952:13;;;5944:22;;5940:31;;;5983:19;;;5980:39;;;6015:1;6012;6005:12;5980:39;6039:11;;;;6059:904;6075:6;6070:3;6067:15;6059:904;;;6155:2;6149:3;6140:7;6136:17;6132:26;6129:46;;;6171:1;6168;6161:12;6129:46;6201:22;;:::i;:::-;6257:3;6251:10;6296:1;6287:7;6284:14;6274:42;;6312:1;6309;6302:12;6274:42;6329:22;;6387:43;6417:12;;;6387:43;:::i;:::-;6382:2;6375:5;6371:14;6364:67;6454:2;6492:43;6531:2;6526:3;6522:12;6492:43;:::i;:::-;6476:14;;;6469:67;6559:2;6603:12;;;6597:19;6581:14;;;6574:43;6640:3;6679:43;6709:12;;;6679:43;:::i;:::-;6663:14;;;6656:67;6746:3;6791:12;;;6785:19;6769:14;;;6762:43;6829:3;6875:13;;;6869:20;6852:15;;;6845:45;6903:18;;6092:12;;;;6941;;;;6059:904;;;-1:-1:-1;6982:5:4;5248:1745;-1:-1:-1;;;;;;;5248:1745:4:o;6998:127::-;7059:10;7054:3;7050:20;7047:1;7040:31;7090:4;7087:1;7080:15;7114:4;7111:1;7104:15;7130:127;7191:10;7186:3;7182:20;7179:1;7172:31;7222:4;7219:1;7212:15;7246:4;7243:1;7236:15

ipfs://d9d22959cc8d8c19449f09bf0f31aff6de545507c770236c9208141b5f968b4c