// SPDX-License-Identifier: MIT
// 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;
    }
}

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

pragma solidity ^0.8.0;

import "../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.
 *
 * 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 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 {
        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);
    }
}

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

import "./SignedMinting.sol";

import "erc721a/ERC721A.sol";

import "openzeppelin-contracts/contracts/access/Ownable.sol";
import "openzeppelin-contracts/contracts/utils/Address.sol";
import "openzeppelin-contracts/contracts/utils/Strings.sol";

contract RottenAntiSocialClub is ERC721A, Ownable, SignedMinting {
    using Address for address;
    using Strings for string;

    uint256 public constant MAX_SUPPLY = 9582;
    uint256 public constant NUM_PRESALE = 5000;
    uint256 public constant TEAM_RESERVED = 500;

    uint256 public presaleWalletLimit = 2;
    uint256 public walletLimit = 3;

    string public baseURI;
    bool public metadataFrozen;
    bool public preminted;
    bool public isSaleActive;
    bool public isPresaleActive;

    address public developer;

    constructor(address owner_, address signer_)
        ERC721A("Rotten Anti Social Club", "RASC")
        Ownable()
        SignedMinting(signer_)
    {
        require(owner_ != address(0), "No owner specified");

        developer = _msgSender();
        _transferOwnership(owner_);
    }

    function mint(uint256 _amount) public {
        require(isSaleActive, "Sale inactive");
        require(tx.origin == msg.sender, "No contracts");
        require(
            _amount + _numberMinted(msg.sender) <= walletLimit,
            "Wallet limit exceeded"
        );
        _performMint(msg.sender, _amount);
    }

    function mintPresale(uint256 _amount, bytes calldata signature)
        public
        isValidSignature(signature, msg.sender)
    {
        require(
            _amount + totalSupply() <= NUM_PRESALE + TEAM_RESERVED,
            "Not enough available"
        );
        require(isPresaleActive, "Presale inactive");
        require(tx.origin == msg.sender, "No contracts");
        require(
            _amount + _numberMinted(msg.sender) <= presaleWalletLimit,
            "Wallet limit exceeded"
        );
        _performMint(msg.sender, _amount);
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }

    function numberMinted(address _address) public view returns (uint256) {
        return _numberMinted(_address);
    }

    function freezeMetadata() public onlyAuthorized {
        require(!metadataFrozen, "Metadata Frozen");
        metadataFrozen = true;
    }

    function setBaseURI(string calldata __baseURI) public onlyAuthorized {
        require(!metadataFrozen, "Metadata Frozen");
        baseURI = __baseURI;
    }

    function premint() public onlyAuthorized {
        require(!preminted, "Already preminted");
        _performMint(owner(), TEAM_RESERVED);
        preminted = true;
    }

    function adminMint(address _to, uint256 _amount) public onlyAuthorized {
        _performMint(_to, _amount);
    }

    function setIsSaleActive(bool _isSaleActive) public onlyAuthorized {
        isSaleActive = _isSaleActive;
    }

    function setIsPresaleActive(bool _isPresaleActive) public onlyAuthorized {
        isPresaleActive = _isPresaleActive;
    }

    function setWalletLimit(uint256 _walletLimit) public onlyAuthorized {
        walletLimit = _walletLimit;
    }

    function setPresaleWalletLimit(uint256 _presaleWalletLimit) public onlyAuthorized {
        presaleWalletLimit = _presaleWalletLimit;
    }

    function setMintingSigner(address _signer) public onlyAuthorized {
        _setMintingSigner(_signer);
    }

    function setDeveloper(address _developer) public onlyOwner  {
        developer = _developer;
    }

    function _performMint(address _to, uint256 amount) private {
        require(_to != address(0), "Cannot mint to 0x0");
        require(amount > 0, "Amount cannot be 0");
        require(amount + totalSupply() <= MAX_SUPPLY, "Amount not available");
        _safeMint(_to, amount);
    }

    // Modifiers
    modifier onlyAuthorized() {
        require(
            msg.sender == owner() || msg.sender == developer,
            "Unauthorized"
        );
        _;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.15;

import "openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol";
import "openzeppelin-contracts/contracts/utils/Strings.sol";
import "openzeppelin-contracts/contracts/utils/Address.sol";

contract SignedMinting {
    using ECDSA for bytes32;
    using ECDSA for bytes;

    using Address for address;

    address public mintingSigner;

    constructor(address _signer) {
        mintingSigner = _signer;
    }

    function _setMintingSigner(address _signer) internal {
        mintingSigner = _signer;
    }

    function validateSignature(bytes memory signature)
        internal
        view
        returns (bool)
    {
        return validateSignature(signature, msg.sender);
    }

    function validateSignature(bytes memory signature, address _to)
        internal
        view
        returns (bool)
    {
        bytes32 messageHash = ECDSA.toEthSignedMessageHash(
            bytes(toAsciiString(_to))
        );
        address _signer = messageHash.recover(signature);
        return mintingSigner == _signer;
    }

    modifier isValidSignature(bytes memory signature, address _of) {
        require(validateSignature(signature, _of), "Invalid signature");
        _;
    }

    function recoveredAddress(bytes memory signature, address _of)
        public
        pure
        returns (bytes memory)
    {
        address recoveredSigner = recover(signature, _of);
        return abi.encodePacked(recoveredSigner);
    }

    function recover(bytes memory signature, address _of)
        public
        pure
        returns (address)
    {
        bytes32 messageHash = ECDSA.toEthSignedMessageHash(
            bytes(asciiSender(_of))
        );
        address recoveredSigner = messageHash.recover(signature);
        return recoveredSigner;
    }

    function generateSenderHash(address _of) public pure returns (bytes32) {
        return ECDSA.toEthSignedMessageHash(bytes(asciiSender(_of)));
    }

    function asciiSender(address _of) public pure returns (string memory) {
        return toAsciiString(_of);
    }

    function toAsciiString(address x) internal pure returns (string memory) {
        bytes memory s = new bytes(40);
        for (uint256 i = 0; i < 20; i++) {
            bytes1 b = bytes1(uint8(uint256(uint160(x)) / (2**(8 * (19 - i)))));
            bytes1 hi = bytes1(uint8(b) / 16);
            bytes1 lo = bytes1(uint8(b) - 16 * uint8(hi));
            s[2 * i] = char(hi);
            s[2 * i + 1] = char(lo);
        }
        return string(s);
    }

    function char(bytes1 b) internal pure returns (bytes1 c) {
        if (uint8(b) < 10) return bytes1(uint8(b) + 0x30);
        else return bytes1(uint8(b) + 0x57);
    }
}

{
  "compilationTarget": {
    "src/RottenAntiSocialClub.sol": "RottenAntiSocialClub"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 500
  },
  "remappings": [
    ":ds-test/=lib/forge-std/lib/ds-test/src/",
    ":erc721a/=lib/erc721a/contracts/",
    ":forge-std/=lib/forge-std/src/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/",
    ":script/=script/",
    ":src/=src/",
    ":test/=test/"
  ]
}