// 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: UNLICENSED
pragma solidity ^0.8.23;

import {Ownable} from 'lib/openzeppelin-contracts/contracts/access/Ownable.sol';
import {Pausable} from 'lib/openzeppelin-contracts/contracts/security/Pausable.sol';
import {IEFPAccountMetadata} from './interfaces/IEFPAccountMetadata.sol';
import {IEFPListRegistry} from './interfaces/IEFPListRegistry.sol';
import {IEFPListRecords} from './interfaces/IEFPListRecords.sol';
import {ENSReverseClaimer} from './lib/ENSReverseClaimer.sol';

interface IEFPListRegistry_ERC721 is IEFPListRegistry {
  function ownerOf(uint256 tokenId) external view returns (address);

  function totalSupply() external view returns (uint256);
}

/**
 * @title EFPListMetadata
 * @author Cory Gabrielsen (cory.eth)
 * @custom:contributor throw; (0xthrpw.eth)
 * @custom:benediction DEVS BENEDICAT ET PROTEGAT CONTRACTVS MEAM
 *
 * @notice This contract mints and assigns primary lists to users, and sets
 * EFP List metadata.
 */
contract EFPListMinter is ENSReverseClaimer, Pausable {
  IEFPListRegistry_ERC721 public registry;
  IEFPAccountMetadata public accountMetadata;
  IEFPListRecords public listRecordsL1;

  constructor(address _registryAddress, address _accountMetadataAddress, address _listRecordsL1) {
    registry = IEFPListRegistry_ERC721(_registryAddress);
    accountMetadata = IEFPAccountMetadata(_accountMetadataAddress);
    listRecordsL1 = IEFPListRecords(_listRecordsL1);
  }

  /////////////////////////////////////////////////////////////////////////////
  // Pausable
  /////////////////////////////////////////////////////////////////////////////

  /**
   * @dev Pauses the contract. Can only be called by the contract owner.
   */
  function pause() public onlyOwner {
    _pause();
  }

  /**
   * @dev Unpauses the contract. Can only be called by the contract owner.
   */
  function unpause() public onlyOwner {
    _unpause();
  }

  /////////////////////////////////////////////////////////////////////////////
  // minting
  /////////////////////////////////////////////////////////////////////////////

  /**
   * @dev Decode a list storage location with no metadata.
   * @param listStorageLocation The storage location of the list.
   * @return slot The slot of the list.
   * @return contractAddress The contract address of the list.
   */
  function decodeL1ListStorageLocation(bytes calldata listStorageLocation) internal pure returns (uint256, address) {
    // the list storage location is
    // - version (1 byte)
    // - list storate location type (1 byte)
    // - chain id (32 bytes)
    // - contract address (20 bytes)
    // - slot (32 bytes)
    require(listStorageLocation.length == 1 + 1 + 32 + 20 + 32, 'EFPListMinter: invalid list storage location');
    require(listStorageLocation[0] == 0x01, 'EFPListMinter: invalid list storage location version');
    require(listStorageLocation[1] == 0x01, 'EFPListMinter: invalid list storage location type');
    address contractAddress = _bytesToAddress(listStorageLocation, 34);

    uint256 slot = _bytesToUint(listStorageLocation, 54);
    return (slot, contractAddress);
  }

  /**
   * @dev Mint a primary list.
   * @param listStorageLocation The storage location of the list.
   */
  function easyMint(bytes calldata listStorageLocation) public payable whenNotPaused {
    // validate the list storage location
    (uint256 slot, address recordsContract) = decodeL1ListStorageLocation(listStorageLocation);

    uint256 tokenId = registry.totalSupply();
    registry.mintTo{value: msg.value}(msg.sender, listStorageLocation);
    _setDefaultListForAccount(msg.sender, tokenId);
    if (recordsContract == address(listRecordsL1)) {
      listRecordsL1.setListUser(slot, msg.sender);
      listRecordsL1.setListManager(slot, msg.sender);
    }
  }

  /**
   * @dev Mint a primary list to a specific address.
   * @param to The address to mint the list to.
   * @param listStorageLocation The storage location of the list.
   */
  function easyMintTo(address to, bytes calldata listStorageLocation) public payable whenNotPaused {
    // validate the list storage location
    (uint256 slot, address recordsContract) = decodeL1ListStorageLocation(listStorageLocation);

    uint256 tokenId = registry.totalSupply();
    registry.mintTo{value: msg.value}(to, listStorageLocation);
    _setDefaultListForAccount(msg.sender, tokenId);
    if (recordsContract == address(listRecordsL1)) {
      listRecordsL1.setListUser(slot, msg.sender);
      listRecordsL1.setListManager(slot, msg.sender);
    }
  }

  /**
   * @dev Mint a primary list without metadata.
   * @param listStorageLocation The storage location of the list.
   */
  function mintPrimaryListNoMeta(bytes calldata listStorageLocation) public payable whenNotPaused {
    // validate the list storage location
    decodeL1ListStorageLocation(listStorageLocation);
    uint256 tokenId = registry.totalSupply();
    _setDefaultListForAccount(msg.sender, tokenId);
    registry.mintTo{value: msg.value}(msg.sender, listStorageLocation);
  }

  /**
   * @dev Mint a primary list without metadata to a specific address.
   * @param listStorageLocation The storage location of the list.
   */
  function mintNoMeta(bytes calldata listStorageLocation) public payable whenNotPaused {
    // validate the list storage location
    decodeL1ListStorageLocation(listStorageLocation);

    registry.mintTo{value: msg.value}(msg.sender, listStorageLocation);
  }

  /**
   * @dev Mint a primary list without metadata to a specific address.
   * @param to The address to mint the list to.
   * @param listStorageLocation The storage location of the list.
   */
  function mintToNoMeta(address to, bytes calldata listStorageLocation) public payable whenNotPaused {
    // validate the list storage location
    decodeL1ListStorageLocation(listStorageLocation);

    registry.mintTo{value: msg.value}(to, listStorageLocation);
  }

  /**
   * @dev Set the default list for an account.
   * @param to The address to set the default list for.
   * @param tokenId The token ID of the list.
   */
  function _setDefaultListForAccount(address to, uint256 tokenId) internal {
    accountMetadata.setValueForAddress(to, 'primary-list', abi.encodePacked(tokenId));
  }

  function _getChainId() internal view returns (uint256) {
    uint256 id;
    assembly {
      id := chainid()
    }
    return id;
  }

  // Generalized function to convert bytes to uint256 with a given offset
  function _bytesToUint(bytes memory data, uint256 offset) internal pure returns (uint256) {
    require(data.length >= offset + 32, 'Data too short');
    uint256 value;
    assembly {
      value := mload(add(data, add(32, offset)))
    }
    return value;
  }

  // Helper function to convert bytes to address with a given offset
  function _bytesToAddress(bytes memory data, uint256 offset) internal pure returns (address addr) {
    require(data.length >= offset + 20, 'Data too short');
    assembly {
      // Extract 20 bytes from the specified offset
      addr := mload(add(add(data, 20), offset))
      // clear the 12 least significant bits of the address
      addr := and(addr, 0x000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
    }
    return addr;
  }
}

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

import {Ownable} from 'lib/openzeppelin-contracts/contracts/access/Ownable.sol';

interface ENS {
  /**
   * @dev Returns the address that owns the specified node.
   * @param node The specified node.
   * @return address of the owner.
   */
  function owner(bytes32 node) external view returns (address);
}

interface IReverseRegistrar {
  /**
   * @dev Transfers ownership of the reverse ENS record associated with the
   *      calling account.
   * @param owner The address to set as the owner of the reverse record in ENS.
   * @return The ENS node hash of the reverse record.
   */
  function claim(address owner) external returns (bytes32);

  /**
   * @dev Sets the `name()` record for the reverse ENS record associated with
   * the calling account. First updates the resolver to the default reverse
   * resolver if necessary.
   * @param name The name to set for this address.
   * @return The ENS node hash of the reverse record.
   */
  function setName(string memory name) external returns (bytes32);
}

/**
 * @title ENSReverseClaimer
 * @dev This contract is used to claim reverse ENS records.
 */
abstract contract ENSReverseClaimer is Ownable {
  /// @dev The namehash of 'addr.reverse', the domain at which reverse records
  ///      are stored in ENS.
  bytes32 constant ADDR_REVERSE_NODE = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2;

  /**
   * @dev Transfers ownership of the reverse ENS record associated with the
   *      contract.
   * @param ens The ENS registry.
   * @param claimant The address to set as the owner of the reverse record in
   *                 ENS.
   * @return The ENS node hash of the reverse record.
   */
  function claimReverseENS(ENS ens, address claimant) external onlyOwner returns (bytes32) {
    return IReverseRegistrar(ens.owner(ADDR_REVERSE_NODE)).claim(claimant);
  }

  /**
   * @dev Sets the reverse ENS record associated with the contract.
   * @param ens The ENS registry.
   * @param name The name to set as the reverse record in ENS.
   * @return The ENS node hash of the reverse record.
   */
  function setReverseENS(ENS ens, string calldata name) external onlyOwner returns (bytes32) {
    return IReverseRegistrar(ens.owner(ADDR_REVERSE_NODE)).setName(name);
  }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.23;

/**
 * @title IEFPAccountMetadata
 */
interface IEFPAccountMetadata {
  function addProxy(address proxy) external;

  function removeProxy(address proxy) external;

  function isProxy(address proxy) external view returns (bool);

  event UpdateAccountMetadata(address indexed addr, string key, bytes value);

  /**
   * @title Key-value Record
   * @notice A key-value string pair.
   */
  struct KeyValue {
    string key;
    bytes value;
  }

  function getValue(address addr, string calldata key) external view returns (bytes memory);

  function setValue(string calldata key, bytes calldata value) external;

  function setValueForAddress(address addr, string calldata key, bytes calldata value) external;

  function setValues(KeyValue[] calldata records) external;

  function setValuesForAddress(address addr, KeyValue[] calldata records) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.23;

/**
 * @title IEFPListMetadata
 */
interface IEFPListMetadata {
  event UpdateListMetadata(uint256 indexed slot, string key, bytes value);

  struct KeyValue {
    string key;
    bytes value;
  }

  function getMetadataValue(uint256 slot, string calldata key) external view returns (bytes memory);

  function getMetadataValues(uint256 slot, string[] calldata keys) external view returns (bytes[] memory);

  function setMetadataValue(uint256 slot, string calldata key, bytes calldata value) external;

  function setMetadataValues(uint256 slot, KeyValue[] calldata records) external;

  // List Manager Functions
  function claimListManager(uint256 slot) external;

  function claimListManagerForAddress(uint256 slot, address manager) external;

  function getListManager(uint256 slot) external view returns (address);

  function setListManager(uint256 slot, address manager) external;

  // List User Functions
  function getListUser(uint256 slot) external view returns (address);

  function setListUser(uint256 slot, address user) external;
}

/**
 * @title IEFPListRecords
 * @notice Interface for the ListRecords contract.
 */
interface IEFPListRecords is IEFPListMetadata {
  // Events
  event ListOp(uint256 indexed slot, bytes op);

  // List Operation Functions - Read
  function getListOpCount(uint256 slot) external view returns (uint256);

  function getListOp(uint256 slot, uint256 index) external view returns (bytes memory);

  function getListOpsInRange(uint256 slot, uint256 start, uint256 end) external view returns (bytes[] memory);

  function getAllListOps(uint256 slot) external view returns (bytes[] memory);

  // List Operation Functions - Write
  function applyListOp(uint256 slot, bytes calldata op) external;

  function applyListOps(uint256 slot, bytes[] calldata ops) external;

  function setMetadataValuesAndApplyListOps(uint256 slot, KeyValue[] calldata records, bytes[] calldata ops) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.23;

/**
 * @title EFPListRegistry
 * @notice A registry connecting token IDs with data such as managers, users, and list locations.
 */
interface IEFPListRegistry {
  ///////////////////////////////////////////////////////////////////////////
  // Enums
  ///////////////////////////////////////////////////////////////////////////

  enum MintState {
    Disabled,
    OwnerOnly,
    PublicMint,
    PublicBatch
  }

  ///////////////////////////////////////////////////////////////////////////
  // Events
  ///////////////////////////////////////////////////////////////////////////

  /// @notice Emitted when a list storage location is set
  event UpdateListStorageLocation(uint256 indexed tokenId, bytes listStorageLocation);

  ///////////////////////////////////////////////////////////////////////////
  // ListStorageLocation
  ///////////////////////////////////////////////////////////////////////////

  function getListStorageLocation(uint256 tokenId) external view returns (bytes memory);

  function setListStorageLocation(uint256 tokenId, bytes calldata listStorageLocation) external;

  ///////////////////////////////////////////////////////////////////////////
  // Mint
  ///////////////////////////////////////////////////////////////////////////

  /// @notice Fetches the mint state.
  function getMintState() external view returns (MintState);

  /// @notice Sets the mint state.
  /// @param _mintState The new mint state.
  function setMintState(MintState _mintState) external;

  /// @notice Fetches the max mint batch size.
  function getMaxMintBatchSize() external view returns (uint256);

  /// @notice Sets the max mint batch size.
  /// @param _maxMintBatchSize The new max mint batch size.
  function setMaxMintBatchSize(uint256 _maxMintBatchSize) external;

  /// @notice Mints a new token.
  function mint(bytes calldata listStorageLocation) external payable;

  /**
   * @notice Mints a new token to the given address.
   * @param recipient The address to mint the token to.
   */
  function mintTo(address recipient, bytes calldata listStorageLocation) external payable;

  /// @notice Mints a new token to the given address.
  function mintBatch(uint256 quantity) external payable;

  /// @notice Mints a new token to the given address.
  function mintBatchTo(address recipient, uint256 quantity) external payable;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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. 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 {
        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
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

{
  "compilationTarget": {
    "src/EFPListMinter.sol": "EFPListMinter"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":ERC721A/=lib/ERC721A/contracts/",
    ":ds-test/=lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/",
    ":openzeppelin/=lib/openzeppelin-contracts/contracts/"
  ]
}