// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.19;

import {ISequenceMarket} from "./interfaces/ISequenceMarket.sol";
import {IERC721} from "./interfaces/IERC721.sol";
import {IERC2981} from "./interfaces/IERC2981.sol";
import {IERC20} from "@0xsequence/erc-1155/contracts/interfaces/IERC20.sol";
import {IERC165} from "@0xsequence/erc-1155/contracts/interfaces/IERC165.sol";
import {IERC1155} from "@0xsequence/erc-1155/contracts/interfaces/IERC1155.sol";
import {TransferHelper} from "@uniswap/lib/contracts/libraries/TransferHelper.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract SequenceMarket is ISequenceMarket, Ownable, ReentrancyGuard {
  mapping(uint256 => Request) internal _requests;
  mapping(address => CustomRoyalty) public customRoyalties;

  uint256 private _nextRequestId;

  constructor(address _owner) {
    _transferOwnership(_owner);
  }

  /**
   * Creates a request.
   * @param request The request's details.
   * @return requestId The ID of the request.
   */
  function createRequest(RequestParams calldata request) external nonReentrant returns (uint256 requestId) {
    return _createRequest(request);
  }

  /**
   * Creates requests.
   * @param requests The requests' details.
   * @return requestIds The IDs of the requests.
   */
  function createRequestBatch(RequestParams[] calldata requests) external nonReentrant returns (uint256[] memory requestIds) {
    uint256 len = requests.length;
    requestIds = new uint256[](len);
    for (uint256 i; i < len; i++) {
      requestIds[i] = _createRequest(requests[i]);
    }
  }

  /**
   * Performs creation of a request.
   * @param params The request's params.
   * @return requestId The ID of the request.
   */
  function _createRequest(RequestParams calldata params) internal returns (uint256 requestId) {
    uint256 quantity = params.quantity;
    address tokenContract = params.tokenContract;

    if (params.pricePerToken == 0) {
      revert InvalidPrice();
    }
    // solhint-disable-next-line not-rely-on-time
    if (params.expiry <= block.timestamp) {
      revert InvalidExpiry();
    }

    // Check interfaces
    _requireInterface(tokenContract, params.isERC1155 ? type(IERC1155).interfaceId : type(IERC721).interfaceId);
    if (params.currency == address(0)) {
      revert InvalidCurrency();
    }

    if (params.isListing) {
      // Check valid token for listing
      if (!_hasApprovedTokens(params.isERC1155, tokenContract, params.tokenId, quantity, msg.sender)) {
        revert InvalidTokenApproval(tokenContract, params.tokenId, quantity, msg.sender);
      }
    } else {
      // Check approved currency for offer inc royalty
      uint256 total = quantity * params.pricePerToken;
      (, uint256 royaltyAmount) = getRoyaltyInfo(tokenContract, params.tokenId, total);
      total += royaltyAmount;
      if (!_hasApprovedCurrency(params.currency, total, msg.sender)) {
        revert InvalidCurrencyApproval(params.currency, total, msg.sender);
      }
      // Check quantity. Covered by _hasApprovedTokens for listings
      if ((params.isERC1155 && quantity == 0) || (!params.isERC1155 && quantity != 1)) {
        revert InvalidQuantity();
      }
    }

    Request memory request = Request({
      isListing: params.isListing,
      isERC1155: params.isERC1155,
      creator: msg.sender,
      tokenContract: tokenContract,
      tokenId: params.tokenId,
      quantity: quantity,
      currency: params.currency,
      pricePerToken: params.pricePerToken,
      expiry: params.expiry
    });

    requestId = uint256(_nextRequestId);
    _nextRequestId++;
    _requests[requestId] = request;

    emit RequestCreated(
      requestId,
      msg.sender,
      tokenContract,
      request.tokenId,
      request.isListing,
      quantity,
      request.currency,
      request.pricePerToken,
      request.expiry
      );

    return requestId;
  }

  /**
   * Accepts a request.
   * @param requestId The ID of the request.
   * @param quantity The quantity of tokens to accept.
   * @param recipient The recipient of the accepted tokens.
   * @param additionalFees The additional fees to pay.
   * @param additionalFeeRecipients The addresses to send the additional fees to.
   */
  function acceptRequest(
    uint256 requestId,
    uint256 quantity,
    address recipient,
    uint256[] calldata additionalFees,
    address[] calldata additionalFeeRecipients
  )
    external
    nonReentrant
  {
    _acceptRequest(requestId, quantity, recipient, additionalFees, additionalFeeRecipients);
  }

  /**
   * Accepts requests.
   * @param requestIds The IDs of the requests.
   * @param quantities The quantities of tokens to accept.
   * @param recipients The recipients of the accepted tokens.
   * @param additionalFees The additional fees to pay.
   * @param additionalFeeRecipients The addresses to send the additional fees to.
   * @dev Additional fees are applied to each request.
   */
  function acceptRequestBatch(
    uint256[] calldata requestIds,
    uint256[] calldata quantities,
    address[] calldata recipients,
    uint256[] calldata additionalFees,
    address[] calldata additionalFeeRecipients
  )
    external
    nonReentrant
  {
    uint256 len = requestIds.length;
    if (len != quantities.length || len != recipients.length) {
      revert InvalidBatchRequest();
    }

    for (uint256 i; i < len; i++) {
      _acceptRequest(requestIds[i], quantities[i], recipients[i], additionalFees, additionalFeeRecipients);
    }
  }

  /**
   * Performs acceptance of a request.
   * @param requestId The ID of the request.
   * @param quantity The quantity of tokens to accept.
   * @param recipient The recipient of the accepted tokens.
   * @param additionalFees The additional fees to pay.
   * @param additionalFeeRecipients The addresses to send the additional fees to.
   */
  function _acceptRequest(
    uint256 requestId,
    uint256 quantity,
    address recipient,
    uint256[] calldata additionalFees,
    address[] calldata additionalFeeRecipients
  )
    internal
  {
    Request memory request = _requests[requestId];
    if (request.creator == address(0)) {
      // Request cancelled, completed or never existed
      revert InvalidRequestId(requestId);
    }
    if (quantity == 0 || quantity > request.quantity) {
      revert InvalidQuantity();
    }
    if (_isExpired(request)) {
      revert InvalidExpiry();
    }
    if (additionalFees.length != additionalFeeRecipients.length) {
      revert InvalidAdditionalFees();
    }

    // Update request state
    if (request.quantity == quantity) {
      // Refund some gas
      delete _requests[requestId];
    } else {
      _requests[requestId].quantity -= quantity;
    }
    address tokenContract = request.tokenContract;

    // Calculate payables
    uint256 remainingCost = request.pricePerToken * quantity;
    (address royaltyRecipient, uint256 royaltyAmount) = getRoyaltyInfo(tokenContract, request.tokenId, remainingCost);

    address currencySender;
    address currencyRecipient;
    address tokenSender;
    address tokenRecipient;
    if (request.isListing) {
      currencySender = msg.sender;
      currencyRecipient = request.creator;
      tokenSender = request.creator;
      tokenRecipient = recipient;
    } else {
      currencySender = request.creator;
      currencyRecipient = recipient;
      tokenSender = msg.sender;
      tokenRecipient = request.creator;
    }

    if (royaltyAmount > 0) {
      if (request.isListing) {
        // Royalties are paid by the maker. This reduces the cost for listings.
        // Underflow prevents fees > cost
        remainingCost -= royaltyAmount;
      } else if (royaltyAmount > remainingCost) {
        // Royalty cannot exceed cost
        revert InvalidRoyalty();
      }
      // Transfer royalties
      TransferHelper.safeTransferFrom(request.currency, currencySender, royaltyRecipient, royaltyAmount);
    }

    // Transfer additional fees
    uint256 totalFees;
    for (uint256 i; i < additionalFees.length; i++) {
      uint256 fee = additionalFees[i];
      address feeRecipient = additionalFeeRecipients[i];
      if (feeRecipient == address(0) || fee == 0) {
        revert InvalidAdditionalFees();
      }
      totalFees += fee;
      TransferHelper.safeTransferFrom(request.currency, currencySender, feeRecipient, fee);
    }
    if (!request.isListing) {
      // Fees are paid by the taker. This reduces the cost for offers.
      // Underflow prevents fees > cost
      remainingCost -= totalFees;
    } else if (totalFees > remainingCost) {
      // Fees cannot exceed cost - royalties
      revert InvalidAdditionalFees();
    }

    // Transfer currency
    TransferHelper.safeTransferFrom(request.currency, currencySender, currencyRecipient, remainingCost);

    // Transfer token
    if (request.isERC1155) {
      IERC1155(tokenContract).safeTransferFrom(tokenSender, tokenRecipient, request.tokenId, quantity, "");
    } else {
      IERC721(tokenContract).safeTransferFrom(tokenSender, tokenRecipient, request.tokenId);
    }

    emit RequestAccepted(requestId, msg.sender, tokenContract, recipient, quantity, _requests[requestId].quantity);
  }

  /**
   * Cancels a request.
   * @param requestId The ID of the request.
   */
  function cancelRequest(uint256 requestId) external nonReentrant {
    _cancelRequest(requestId);
  }

  /**
   * Cancels requests.
   * @param requestIds The IDs of the requests.
   */
  function cancelRequestBatch(uint256[] calldata requestIds) external nonReentrant {
    for (uint256 i; i < requestIds.length; i++) {
      _cancelRequest(requestIds[i]);
    }
  }

  /**
   * Performs cancellation of a request.
   * @param requestId The ID of the request.
   */
  function _cancelRequest(uint256 requestId) internal {
    Request storage request = _requests[requestId];
    if (request.creator != msg.sender) {
      revert InvalidRequestId(requestId);
    }
    address tokenContract = request.tokenContract;

    // Refund some gas
    delete _requests[requestId];

    emit RequestCancelled(requestId, tokenContract);
  }

  /**
   * Gets a request.
   * @param requestId The ID of the request.
   * @return request The request.
   */
  function getRequest(uint256 requestId) external view returns (Request memory request) {
    return _requests[requestId];
  }

  /**
   * Gets requests.
   * @param requestIds The IDs of the requests.
   * @return requests The requests.
   */
  function getRequestBatch(uint256[] calldata requestIds) external view returns (Request[] memory requests) {
    uint256 len = requestIds.length;
    requests = new Request[](len);
    for (uint256 i; i < len; i++) {
      requests[i] = _requests[requestIds[i]];
    }
  }

  /**
   * Checks if a request is valid.
   * @param requestId The ID of the request.
   * @param quantity The amount of tokens to exchange. 0 is assumed to be the request's available quantity.
   * @return valid The validity of the request.
   * @return request The request.
   * @notice A request is valid if it is active, has not expired and give amount of tokens (currency for offers, tokens for listings) are transferrable.
   */
  function isRequestValid(uint256 requestId, uint256 quantity) public view returns (bool valid, Request memory request) {
    request = _requests[requestId];
    if (quantity == 0) {
      // 0 is assumed to be max quantity
      quantity = request.quantity;
    }
    valid = request.creator != address(0) && !_isExpired(request) && quantity <= request.quantity;
    if (valid) {
      if (request.isListing) {
        valid = _hasApprovedTokens(request.isERC1155, request.tokenContract, request.tokenId, quantity, request.creator);
      } else {
        // Add royalty
        uint256 cost = request.pricePerToken * quantity;
        (, uint256 royaltyAmount) = getRoyaltyInfo(request.tokenContract, request.tokenId, cost);
        valid = _hasApprovedCurrency(request.currency, cost + royaltyAmount, request.creator);
      }
    }
    return (valid, request);
  }

  /**
   * Checks if requests are valid.
   * @param requestIds The IDs of the requests.
   * @param quantities The amount of tokens to exchange per request. 0 is assumed to be the request's available quantity.
   * @return valid The validities of the requests.
   * @return requests The requests.
   * @notice A request is valid if it is active, has not expired and give amount of tokens (currency for offers, tokens for listings) are transferrable.
   */
  function isRequestValidBatch(uint256[] calldata requestIds, uint256[] calldata quantities)
    external
    view
    returns (bool[] memory valid, Request[] memory requests)
  {
    uint256 len = requestIds.length;
    if (len != quantities.length) {
      revert InvalidBatchRequest();
    }
    valid = new bool[](len);
    requests = new Request[](len);
    for (uint256 i; i < len; i++) {
      (valid[i], requests[i]) = isRequestValid(requestIds[i], quantities[i]);
    }
  }

  /**
   * Checks if a request has expired.
   * @param request The request to check.
   * @return isExpired True if the request has expired.
   */
  function _isExpired(Request memory request) internal view returns (bool isExpired) {
    // solhint-disable-next-line not-rely-on-time
    return request.expiry <= block.timestamp;
  }

  /**
   * Will set the royalties fees and recipient for contracts that don't support ERC-2981.
   * @param tokenContract The contract the custom royalties apply to.
   * @param recipient Address to send the royalties to.
   * @param fee Fee percentage with a 10000 basis (e.g. 0.3% is 30 and 1% is 100 and 100% is 10000).
   * @dev Can only be called by the owner.
   * @notice This can be called even when the contract supports ERC-2891, but will be ignored if it does.
   */
  function setRoyaltyInfo(address tokenContract, address recipient, uint96 fee) public onlyOwner {
    if (fee > 10000) {
      revert InvalidRoyalty();
    }
    customRoyalties[tokenContract] = CustomRoyalty(recipient, fee);
    emit CustomRoyaltyChanged(tokenContract, recipient, fee);
  }

  /**
   * Returns the royalty details for the given token and cost.
   * @param tokenContract Address of the token being traded.
   * @param tokenId The ID of the token.
   * @param cost Amount of currency sent/received for the trade.
   * @return recipient Address to send royalties to.
   * @return royalty Amount of currency to be paid as royalties.
   */
  function getRoyaltyInfo(address tokenContract, uint256 tokenId, uint256 cost)
    public
    view
    returns (address recipient, uint256 royalty)
  {
    try IERC2981(address(tokenContract)).royaltyInfo(tokenId, cost) returns (address _r, uint256 _c) {
      return (_r, _c);
    } catch {} // solhint-disable-line no-empty-blocks

    // Fail over to custom royalty
    CustomRoyalty memory customRoyalty = customRoyalties[tokenContract];
    return (customRoyalty.recipient, customRoyalty.fee * cost / 10000);
  }

  /**
   * Checks if the amount of currency is approved for transfer exceeds the given amount.
   * @param currency The address of the currency.
   * @param amount The amount of currency.
   * @param who The address of the owner of the currency.
   * @return isValid True if the amount of currency is sufficient and approved for transfer.
   */
  function _hasApprovedCurrency(address currency, uint256 amount, address who) internal view returns (bool isValid) {
    return IERC20(currency).balanceOf(who) >= amount && IERC20(currency).allowance(who, address(this)) >= amount;
  }

  /**
   * Checks if a token contract is ERC1155 or ERC721 and if the token is owned and approved for transfer.
   * @param isERC1155 True if the token is an ERC1155 token, false if it is an ERC721 token.
   * @param tokenContract The address of the token contract.
   * @param tokenId The ID of the token.
   * @param quantity The quantity of tokens to list.
   * @param who The address of the owner of the token.
   * @return isValid True if the token is owned and approved for transfer.
   * @dev Returns false if the token contract is not ERC1155 or ERC721.
   */
  function _hasApprovedTokens(bool isERC1155, address tokenContract, uint256 tokenId, uint256 quantity, address who)
    internal
    view
    returns (bool isValid)
  {
    address market = address(this);

    if (isERC1155) {
      // ERC1155
      return quantity > 0 && IERC1155(tokenContract).balanceOf(who, tokenId) >= quantity
        && IERC1155(tokenContract).isApprovedForAll(who, market);
    }

    // ERC721
    address tokenOwner;
    address operator;

    try IERC721(tokenContract).ownerOf(tokenId) returns (address _tokenOwner) {
      tokenOwner = _tokenOwner;

      try IERC721(tokenContract).getApproved(tokenId) returns (address _operator) {
        operator = _operator;
      } catch {} // solhint-disable-line no-empty-blocks
    } catch {} // solhint-disable-line no-empty-blocks

    return quantity == 1 && who == tokenOwner
      && (operator == market || IERC721(tokenContract).isApprovedForAll(who, market));
  }

  /**
   * Checks if a contract implements an interface.
   * @param contractAddress The address of the contract.
   * @param interfaceId The interface ID.
   * @dev Reverts if the contract does not implement the interface.
   */
  function _requireInterface(address contractAddress, bytes4 interfaceId) internal view {
    if (contractAddress.code.length != 0) {
      try IERC165(contractAddress).supportsInterface(interfaceId) returns (bool supported) {
        if (supported) {
          // Success
          return;
        }
      } catch {}
    }
    // Fail over
    revert UnsupportedContractInterface(contractAddress, interfaceId);
  }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.19;

interface IERC721 {
  event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
  event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
  event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

  function balanceOf(address _owner) external view returns (uint256 balance);
  function ownerOf(uint256 _tokenId) external view returns (address owner);
  function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
  function transferFrom(address _from, address _to, uint256 _tokenId) external;
  function approve(address _to, uint256 _tokenId) external;
  function getApproved(uint256 _tokenId) external view returns (address operator);
  function setApprovalForAll(address _operator, bool _approved) external;
  function isApprovedForAll(address _owner, address _operator) external view returns (bool);
  function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata _data) external;
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.19;

import {IERC165} from "@0xsequence/erc-1155/contracts/interfaces/IERC165.sol";

/**
 * @dev Interface for the NFT Royalty Standard
 */
interface IERC2981 is IERC165 {
  /**
   * @notice Called with the sale price to determine how much royalty
   * is owed and to whom.
   * @param _tokenId - the NFT asset queried for royalty information
   * @param _salePrice - the sale price of the NFT asset specified by _tokenId
   * @return receipient - address of who should be sent the royalty payment
   * @return royaltyAmount - the royalty payment amount for _salePrice
   */
  function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
    external
    view
    returns (address receipient, uint256 royaltyAmount);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.19;

interface ISequenceMarketStorage {
  /**
   * Request parameters.
   * @param isListing True if the request is a listing, false if it is an offer.
   * @param isERC1155 True if the token is an ERC1155 token, false if it is an ERC721 token.
   * @param tokenContract The address of the token contract.
   * @param tokenId The ID of the token.
   * @param quantity The quantity of tokens.
   * @param expiry The expiry of the request.
   * @param currency The address of the currency.
   * @param pricePerToken The price per token, including royalty fees.
   */
  struct RequestParams {
    bool isListing; // True if the request is a listing, false if it is an offer.
    bool isERC1155; // True if the token is an ERC1155 token, false if it is an ERC721 token.
    address tokenContract;
    uint256 tokenId;
    uint256 quantity;
    uint96 expiry;
    address currency;
    uint256 pricePerToken;
  }

  /**
   * Request storage.
   * @param creator The address of the request creator.
   * @param isListing True if the request is a listing, false if it is an offer.
   * @param isERC1155 True if the token is an ERC1155 token, false if it is an ERC721 token.
   * @param tokenContract The address of the token contract.
   * @param tokenId The ID of the token.
   * @param quantity The quantity of tokens.
   * @param expiry The expiry of the request.
   * @param currency The address of the currency.
   * @param pricePerToken The price per token, including royalty fees.
   */
  struct Request {
    address creator;
    bool isListing;
    bool isERC1155;
    address tokenContract;
    uint256 tokenId;
    uint256 quantity;
    uint96 expiry;
    address currency;
    uint256 pricePerToken;
  }

  /**
   * Custom royalty parameters.
   * @param recipient Address to send the fees to.
   * @param fee Fee percentage with a 10000 basis (e.g. 0.3% is 30 and 1% is 100 and 100% is 10000).
   * @dev Used to store custom royalty settings for contracts do not support ERC2981.
   */
  struct CustomRoyalty {
    address recipient;
    uint96 fee;
  }
}

interface ISequenceMarketFunctions is ISequenceMarketStorage {
  /**
   * Creates a request.
   * @param request The request's details.
   * @return requestId The ID of the request.
   * @notice A listing is when the maker is selling tokens for currency.
   * @notice An offer is when the maker is buying tokens with currency.
   */
  function createRequest(RequestParams calldata request) external returns (uint256 requestId);

  /**
   * Creates requests.
   * @param requests The requests' details.
   * @return requestIds The IDs of the requests.
   */
  function createRequestBatch(RequestParams[] calldata requests) external returns (uint256[] memory requestIds);

  /**
   * Accepts a request.
   * @param requestId The ID of the request.
   * @param quantity The quantity of tokens to accept.
   * @param recipient The recipient of the accepted tokens.
   * @param additionalFees The additional fees to pay.
   * @param additionalFeeRecipients The addresses to send the additional fees to.
   */
  function acceptRequest(
    uint256 requestId,
    uint256 quantity,
    address recipient,
    uint256[] calldata additionalFees,
    address[] calldata additionalFeeRecipients
  )
    external;

  /**
   * Accepts requests.
   * @param requestIds The IDs of the requests.
   * @param quantities The quantities of tokens to accept.
   * @param recipients The recipients of the accepted tokens.
   * @param additionalFees The additional fees to pay.
   * @param additionalFeeRecipients The addresses to send the additional fees to.
   * @dev Additional fees are applied to each request.
   */
  function acceptRequestBatch(
    uint256[] calldata requestIds,
    uint256[] calldata quantities,
    address[] calldata recipients,
    uint256[] calldata additionalFees,
    address[] calldata additionalFeeRecipients
  )
    external;

  /**
   * Cancels a request.
   * @param requestId The ID of the request.
   */
  function cancelRequest(uint256 requestId) external;

  /**
   * Cancels requests.
   * @param requestIds The IDs of the requests.
   */
  function cancelRequestBatch(uint256[] calldata requestIds) external;

  /**
   * Gets a request.
   * @param requestId The ID of the request.
   * @return request The request.
   */
  function getRequest(uint256 requestId) external view returns (Request memory request);

  /**
   * Gets requests.
   * @param requestIds The IDs of the requests.
   * @return requests The requests.
   */
  function getRequestBatch(uint256[] calldata requestIds) external view returns (Request[] memory requests);

  /**
   * Checks if a request is valid.
   * @param requestId The ID of the request.
   * @param quantity The amount of tokens to exchange. 0 is assumed to be the request's available quantity.
   * @return valid The validity of the request.
   * @return request The request.
   * @notice A request is valid if it is active, has not expired and give amount of tokens (currency for offers, tokens for listings) are transferrable.
   */
  function isRequestValid(uint256 requestId, uint256 quantity) external view returns (bool valid, Request memory request);

  /**
   * Checks if requests are valid.
   * @param requestIds The IDs of the requests.
   * @param quantities The amount of tokens to exchange per request. 0 is assumed to be the request's available quantity.
   * @return valid The validities of the requests.
   * @return requests The requests.
   * @notice A request is valid if it is active, has not expired and give amount of tokens (currency for offers, tokens for listings) are transferrable.
   */
  function isRequestValidBatch(uint256[] calldata requestIds, uint256[] calldata quantities)
    external
    view
    returns (bool[] memory valid, Request[] memory requests);

  /**
   * Returns the royalty details for the given token and cost.
   * @param tokenContract Address of the token being traded.
   * @param tokenId The ID of the token.
   * @param cost Amount of currency sent/received for the trade.
   * @return recipient Address to send royalties to.
   * @return royalty Amount of currency to be paid as royalties.
   */
  function getRoyaltyInfo(address tokenContract, uint256 tokenId, uint256 cost)
    external
    view
    returns (address recipient, uint256 royalty);
}

interface ISequenceMarketSignals {
  //
  // Events
  //

  /// Emitted when a request is created.
  event RequestCreated(
    uint256 indexed requestId,
    address indexed creator,
    address indexed tokenContract,
    uint256 tokenId,
    bool isListing,
    uint256 quantity,
    address currency,
    uint256 pricePerToken,
    uint256 expiry
  );

  /// Emitted when a request is accepted.
  event RequestAccepted(
    uint256 indexed requestId,
    address indexed buyer,
    address indexed tokenContract,
    address recipient,
    uint256 quantity,
    uint256 quantityRemaining
  );

  /// Emitted when a request is cancelled.
  event RequestCancelled(uint256 indexed requestId, address indexed tokenContract);

  /// Emitted when custom royalty settings are changed.
  event CustomRoyaltyChanged(address indexed tokenContract, address recipient, uint96 fee);

  //
  // Errors
  //

  /// Thrown when the contract address does not support the required interface.
  error UnsupportedContractInterface(address contractAddress, bytes4 interfaceId);

  /// Thrown when the token approval is invalid.
  error InvalidTokenApproval(address tokenContract, uint256 tokenId, uint256 quantity, address owner);

  /// Thrown when the currency address is invalid.
  error InvalidCurrency();

  /// Thrown when the currency approval is invalid.
  error InvalidCurrencyApproval(address currency, uint256 quantity, address owner);

  /// Thrown when request id is invalid.
  error InvalidRequestId(uint256 requestId);

  /// Thrown when the parameters of a batch accept request are invalid.
  error InvalidBatchRequest();

  /// Thrown when quantity is invalid.
  error InvalidQuantity();

  /// Thrown when price is invalid.
  error InvalidPrice();

  /// Thrown when royalty is invalid.
  error InvalidRoyalty();

  /// Thrown when expiry is invalid.
  error InvalidExpiry();

  /// Thrown when the additional fees are invalid.
  error InvalidAdditionalFees();
}

// solhint-disable-next-line no-empty-blocks
interface ISequenceMarket is ISequenceMarketFunctions, ISequenceMarketSignals {}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (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;
    }

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

// 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: GPL-3.0-or-later

pragma solidity >=0.6.0;

// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::safeApprove: approve failed'
        );
    }

    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::safeTransfer: transfer failed'
        );
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::transferFrom: transferFrom failed'
        );
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'TransferHelper::safeTransferETH: ETH transfer failed');
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (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() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

/**
 * @title ERC20 interface
 * @dev see https://eips.ethereum.org/EIPS/eip-20
 */
interface IERC20 {
  function transfer(address to, uint256 value) external returns (bool);
  function approve(address spender, uint256 value) external returns (bool);
  function transferFrom(address from, address to, uint256 value) external returns (bool);
  function totalSupply() external view returns (uint256);
  function balanceOf(address who) external view returns (uint256);
  function allowance(address owner, address spender) external view returns (uint256);
  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;


/**
 * @title ERC165
 * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
 */
interface IERC165 {

    /**
     * @notice Query if a contract implements an interface
     * @dev Interface identification is specified in ERC-165. This function
     * uses less than 30,000 gas
     * @param _interfaceId The interface identifier, as specified in ERC-165
     */
    function supportsInterface(bytes4 _interfaceId)
    external
    view
    returns (bool);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;
import './IERC165.sol';


interface IERC1155 is IERC165 {

  /****************************************|
  |                 Events                 |
  |_______________________________________*/

  /**
   * @dev Either TransferSingle or TransferBatch MUST emit when tokens are transferred, including zero amount transfers as well as minting or burning
   *   Operator MUST be msg.sender
   *   When minting/creating tokens, the `_from` field MUST be set to `0x0`
   *   When burning/destroying tokens, the `_to` field MUST be set to `0x0`
   *   The total amount transferred from address 0x0 minus the total amount transferred to 0x0 may be used by clients and exchanges to be added to the "circulating supply" for a given token ID
   *   To broadcast the existence of a token ID with no initial balance, the contract SHOULD emit the TransferSingle event from `0x0` to `0x0`, with the token creator as `_operator`, and a `_amount` of 0
   */
  event TransferSingle(address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _amount);

  /**
   * @dev Either TransferSingle or TransferBatch MUST emit when tokens are transferred, including zero amount transfers as well as minting or burning
   *   Operator MUST be msg.sender
   *   When minting/creating tokens, the `_from` field MUST be set to `0x0`
   *   When burning/destroying tokens, the `_to` field MUST be set to `0x0`
   *   The total amount transferred from address 0x0 minus the total amount transferred to 0x0 may be used by clients and exchanges to be added to the "circulating supply" for a given token ID
   *   To broadcast the existence of multiple token IDs with no initial balance, this SHOULD emit the TransferBatch event from `0x0` to `0x0`, with the token creator as `_operator`, and a `_amount` of 0
   */
  event TransferBatch(address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _amounts);

  /**
   * @dev MUST emit when an approval is updated
   */
  event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);


  /****************************************|
  |                Functions               |
  |_______________________________________*/

  /**
    * @notice Transfers amount of an _id from the _from address to the _to address specified
    * @dev MUST emit TransferSingle event on success
    * Caller must be approved to manage the _from account's tokens (see isApprovedForAll)
    * MUST throw if `_to` is the zero address
    * MUST throw if balance of sender for token `_id` is lower than the `_amount` sent
    * MUST throw on any other error
    * When transfer is complete, this function MUST check if `_to` is a smart contract (code size > 0). If so, it MUST call `onERC1155Received` on `_to` and revert if the return amount is not `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
    * @param _from    Source address
    * @param _to      Target address
    * @param _id      ID of the token type
    * @param _amount  Transfered amount
    * @param _data    Additional data with no specified format, sent in call to `_to`
    */
  function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _amount, bytes calldata _data) external;

  /**
    * @notice Send multiple types of Tokens from the _from address to the _to address (with safety call)
    * @dev MUST emit TransferBatch event on success
    * Caller must be approved to manage the _from account's tokens (see isApprovedForAll)
    * MUST throw if `_to` is the zero address
    * MUST throw if length of `_ids` is not the same as length of `_amounts`
    * MUST throw if any of the balance of sender for token `_ids` is lower than the respective `_amounts` sent
    * MUST throw on any other error
    * When transfer is complete, this function MUST check if `_to` is a smart contract (code size > 0). If so, it MUST call `onERC1155BatchReceived` on `_to` and revert if the return amount is not `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
    * Transfers and events MUST occur in the array order they were submitted (_ids[0] before _ids[1], etc)
    * @param _from     Source addresses
    * @param _to       Target addresses
    * @param _ids      IDs of each token type
    * @param _amounts  Transfer amounts per token type
    * @param _data     Additional data with no specified format, sent in call to `_to`
  */
  function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _amounts, bytes calldata _data) external;

  /**
   * @notice Get the balance of an account's Tokens
   * @param _owner  The address of the token holder
   * @param _id     ID of the Token
   * @return        The _owner's balance of the Token type requested
   */
  function balanceOf(address _owner, uint256 _id) external view returns (uint256);

  /**
   * @notice Get the balance of multiple account/token pairs
   * @param _owners The addresses of the token holders
   * @param _ids    ID of the Tokens
   * @return        The _owner's balance of the Token types requested (i.e. balance for each (owner, id) pair)
   */
  function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view returns (uint256[] memory);

  /**
   * @notice Enable or disable approval for a third party ("operator") to manage all of caller's tokens
   * @dev MUST emit the ApprovalForAll event on success
   * @param _operator  Address to add to the set of authorized operators
   * @param _approved  True if the operator is approved, false to revoke approval
   */
  function setApprovalForAll(address _operator, bool _approved) external;

  /**
   * @notice Queries the approval status of an operator for a given owner
   * @param _owner     The owner of the Tokens
   * @param _operator  Address of authorized operator
   * @return isOperator True if the operator is approved, false if not
   */
  function isApprovedForAll(address _owner, address _operator) external view returns (bool isOperator);
}