Contract Address Details

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

import "@sbinft/contracts/upgradeable/access/AdminUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/interfaces/IERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/metatx/ERC2771ContextUpgradeable.sol";
import {EIP712Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import "contracts/sbinft/market/v1/interface/IPlatformRegistry.sol";
import "contracts/sbinft/market/v1/interface/ITransferProxy.sol";
import "contracts/sbinft/market/v1/interface/IRoyaltyRegistry.sol";
import "contracts/sbinft/market/v3/interface/IExchangeV3.sol";

/**
 * @dev SBINFT Exchange 2.0
 * @author SBINFT Co., Ltd.
 */
contract ExchangeV3 is
  Initializable,
  IExchangeV3,
  EIP712Upgradeable,
  ERC2771ContextUpgradeable,
  AdminUpgradeable,
  ERC165Upgradeable,
  ReentrancyGuardUpgradeable,
  PausableUpgradeable,
  UUPSUpgradeable
{
  using ECDSAUpgradeable for bytes32;

  // Fired when PlatformRegistry is changed
  event PlatformRegistryUpdated(IPlatformRegistry indexed platformRegistry);
  // PlatformRegistry holds platform related info
  IPlatformRegistry public platformRegistry;

  // Fired when TransferProxy is changed
  event TransferProxyUpdated(ITransferProxy indexed transferProxy);
  // Holds access rights for on-chain asset transfer.
  // Must be pre approved for the respective asset
  ITransferProxy public transferProxy;

  // Fired when RoyaltyRegistry is changed
  event RoyaltyRegistryUpdated(IRoyaltyRegistry indexed royaltyRegistry);
  // RoyaltyRegistry holds Royalty info
  IRoyaltyRegistry public royaltyRegistry;

  // Map of SaleOrderHash => soldCount
  // Instead of soldCount being uint256 it can be bool but using uint256 inorder to support ERC1155 later
  mapping(bytes32 => uint256) internal _saleProgress;

  // Tip related
  struct ERC20Tip {
    address tipper;
    uint256 amount;
  }
  mapping(address => ERC20Tip[]) internal _erc20TipDeposite;

  // Just a temp variable to be used as local function variable
  // as mapping declaration is not supported inside function
  mapping(address => uint256) internal _tempPayoutAmount;
  address[] internal _tempPayoutAddress;

  /// @custom:oz-upgrades-unsafe-allow constructor
  constructor(
    address trustedForwarder
  ) ERC2771ContextUpgradeable(trustedForwarder) {
    _disableInitializers();
  }

  /**
   * @dev See {UUPSUpgradeable._authorizeUpgrade()}
   *
   * Requirements:
   * - onlyAdmin can call
   */
  function _authorizeUpgrade(
    address _newImplementation
  ) internal virtual override onlyAdmin {}

  /**
   * @dev See {IERC165Upgradeable-supportsInterface}.
   *
   * @param _interfaceId bytes4
   */
  function supportsInterface(
    bytes4 _interfaceId
  )
    public
    view
    virtual
    override(ERC165Upgradeable, IERC165Upgradeable)
    returns (bool)
  {
    return
      _interfaceId == type(IExchangeV3).interfaceId ||
      super.supportsInterface(_interfaceId);
  }

  /**
   * See {ERC2771ContextUpgradeable._msgSender()}
   */
  function _msgSender()
    internal
    view
    virtual
    override(ContextUpgradeable, ERC2771ContextUpgradeable)
    returns (address sender)
  {
    return ERC2771ContextUpgradeable._msgSender();
  }

  /**
   * See {ERC2771ContextUpgradeable._msgData()}
   */
  function _msgData()
    internal
    view
    virtual
    override(ContextUpgradeable, ERC2771ContextUpgradeable)
    returns (bytes calldata)
  {
    return ERC2771ContextUpgradeable._msgData();
  }

  /**
   * @dev See {PausableUpgradeable._pause()}
   *
   * Requirements:
   * - onlyAdmin can call
   */
  function pause() external virtual onlyAdmin {
    PausableUpgradeable._pause();
  }

  /**
   * @dev See {PausableUpgradeable._unpause()}
   *
   * Requirements:
   * - onlyAdmin can call
   */
  function unpause() external virtual onlyAdmin {
    PausableUpgradeable._unpause();
  }

  /**
   * @dev Update to new PlatformRegistry
   *
   * @param _newPlatformRegistry new PlatformRegistry
   *
   * Requirements:
   * - _newPlatformRegistry must be a contract and must support IPlatformRegistry
   *
   * Emits a {PlatformRegistryUpdated} event
   */
  function updatePlatformRegistry(
    IPlatformRegistry _newPlatformRegistry
  ) public virtual onlyAdmin {
    // EM: IPlatformRegistry interface not supported
    require(
      IPlatformRegistry(_newPlatformRegistry).supportsInterface(
        type(IPlatformRegistry).interfaceId
      ),
      "E_INS"
    );

    platformRegistry = _newPlatformRegistry;

    emit PlatformRegistryUpdated(_newPlatformRegistry);
  }

  /**
   * @dev Update to new TransferProxy
   *
   * @param _newTransferProxy new TransferProxy
   *
   * Requirements:
   * - _newTransferProxy must be a contract and must support ITransferProxy
   *
   * Emits a {TransferProxyUpdated} event
   */
  function updateTransferProxy(
    ITransferProxy _newTransferProxy
  ) public virtual onlyAdmin {
    // EM: ITransferProxy interface not supported
    require(
      ITransferProxy(_newTransferProxy).supportsInterface(
        type(ITransferProxy).interfaceId
      ),
      "E_INS"
    );

    transferProxy = _newTransferProxy;

    emit TransferProxyUpdated(_newTransferProxy);
  }

  /**
   * @dev Update to new RoyaltyRegistry
   *
   * @param _newRoyaltyRegistry new RoyaltyRegistry
   *
   * Requirements:
   * - _newRoyaltyRegistry must be a contract and must support IRoyaltyRegistry
   *
   * Emits a {RoyaltyManagerUpdated} event
   */
  function updateRoyaltyRegistry(
    IRoyaltyRegistry _newRoyaltyRegistry
  ) public virtual onlyAdmin {
    // EM: IRoyaltyRegistry interface not supported
    require(
      IRoyaltyRegistry(_newRoyaltyRegistry).supportsInterface(
        type(IRoyaltyRegistry).interfaceId
      ),
      "E_INS"
    );

    royaltyRegistry = _newRoyaltyRegistry;

    emit RoyaltyRegistryUpdated(_newRoyaltyRegistry);
  }

  /**
   * @dev Gets sold count of an order
   *
   * @param _saleKey Sale key
   * @return sold count of an order
   */
  function getSoldCountByKey(
    bytes32 _saleKey
  ) public view virtual returns (uint256) {
    return _saleProgress[_saleKey];
  }

  /**
   * @dev Gets sold count of an order
   *
   * @param _nonce Sale nonce
   * @param _token token address
   * @param _tokenId token ID
   * @return sold count of an order
   */
  function getSoldCountByNonce(
    uint256 _nonce,
    address _token,
    uint256 _tokenId
  ) public view virtual returns (uint256) {
    return _saleProgress[keccak256(abi.encode(_nonce, _token, _tokenId))];
  }

  /**
   * @dev Updates order state as sold
   *
   * @param _saleKey Sale Key
   * @param _soldValueCount sold value count
   */
  function _setSoldByKey(
    bytes32 _saleKey,
    uint256 _soldValueCount
  ) internal virtual {
    _saleProgress[_saleKey] += _soldValueCount;
  }

  /**
   * @dev Updates order state as sold
   *
   * @param _nonce Sale nonce
   * @param _token token address
   * @param _tokenId token ID
   * @param _soldValueCount sold value count
   */
  function _setSoldByNonce(
    uint256 _nonce,
    address _token,
    uint256 _tokenId,
    uint256 _soldValueCount
  ) internal virtual {
    _saleProgress[
      keccak256(abi.encode(_nonce, _token, _tokenId))
    ] += _soldValueCount;
  }

  /**
   * @dev Validates royalty parameters
   *
   * @param _royaltyReceivers address[]
   * @param _royaltyDistributionRate uint16[]
   * @param _secondaryOnwardsRoyaltyPercentage uint16
   */
  function _validateRoyaltyInfo(
    address[] memory _royaltyReceivers,
    uint16[] memory _royaltyDistributionRate,
    uint16 _secondaryOnwardsRoyaltyPercentage
  ) private pure {
    // EM: Invalid royalty data
    require(
      _royaltyReceivers.length == _royaltyDistributionRate.length,
      "E_VRI_IRD"
    );

    uint16 totalPercentage = 0;
    for (uint256 idx = 0; idx < _royaltyReceivers.length; idx++) {
      totalPercentage += _royaltyDistributionRate[idx];
      // EM: zero address must not be included in receivers
      require(_royaltyReceivers[idx] != address(0), "E_VRI_IRA");
    }

    // EM: receiversPercentage total in not 100%
    require(totalPercentage == OrderDomainV3.FEE_DENOMINATOR, "E_VRI_RPN100");

    // EM: secondaryOnwardsRoyaltyPercentage greater than 100%
    require(
      _secondaryOnwardsRoyaltyPercentage <= OrderDomainV3.FEE_DENOMINATOR,
      "E_VRI_SOPG100"
    );
  }

  /**
   * @dev Check validity of arguments and Verify signatures for calling exchange
   *
   * @param _saleOrder OrderDomainV3.SaleOrder
   * @param _salerSign saler signature
   * @param _buyOrder OrderDomainV3.BuyOrder
   * @param _platformSign platform signature
   * @param _hashMsgSaleOrder Hash of Sale Order
   */
  function _checkParameterAndVerifySignaturesForExchange(
    OrderDomainV3.SaleOrder calldata _saleOrder,
    bytes calldata _salerSign,
    OrderDomainV3.BuyOrder calldata _buyOrder,
    bytes calldata _platformSign,
    bytes32 _hashMsgSaleOrder
  ) internal virtual {
    uint8 ver = _saleOrder.version;
    // Part 1: Check parameters
    {
      // Make sure SaleOrder and BuyOrder version is same
      // EM: Version mismatch
      require(ver == _buyOrder.version, "E_CPFE_VMM");

      // EM: Sale Order Asset length is not valid
      require(_saleOrder.assetList.length == 1, "E_CPFE_ISOAL");

      OrderDomainV3.Asset memory asset = _saleOrder.assetList[0];

      // EM: SaleOrder asset invalid token
      require(asset.token != address(0), "E_CPFE_SAIT");

      // EM: SaleOrder asset invalid tokenId
      require(asset.tokenId != 0, "E_CPFE_SAITI");

      // Make sure asset is not already sold out
      if (_buyOrder.firstAssetBuyValue == 0) {
        // EM: not enough asset remaining for sale
        // when _buyOrder.firstAssetBuyValue == 0, it means bundle sale
        require(getSoldCountByKey(_hashMsgSaleOrder) != 1, "E_CPFE_SOLD");
      } else {
        // Make sure asset is not already sold out
        // EM: not enough asset remaining for sale
        uint256 soldCount = getSoldCountByNonce(
          _saleOrder.nonce,
          asset.token,
          asset.tokenId
        );
        require(
          _buyOrder.firstAssetBuyValue <= (asset.value - soldCount),
          "E_CPFE_SOLD"
        );
      }

      // Make sure order is not expired
      // EM: Expired Order
      require(_buyOrder.validUntil >= block.timestamp, "E_CPFE_EO");

      // Platform fee rate should be greater than PlatformFeeRateLowerLimit
      // EM: SaleOrder pfSaleFeeRate Lower than low limit
      require(
        _saleOrder.pfSaleFeeRate >=
          platformRegistry.getPlatformFeeRateLowerLimit(),
        "E_CPFE_SPFLTLL"
      );
      if (ver >= 1) {
        require(
          _saleOrder.pfSaleFeeRateSecondary >=
            platformRegistry.getPlatformFeeRateLowerLimit(),
          "E_CPFE_SPFLTLL"
        );
      }

      if (
        _buyOrder.paymentDetails.paymentMode == OrderDomainV3.ERC20_PAYMENT_MODE
      ) {
        // Whitelist check
        // EM: BuyOrder paymentToken not whitelisted
        require(
          platformRegistry.isWhitelistedERC20(
            _buyOrder.paymentDetails.paymentToken
          ),
          "E_CPFE_BPTNW"
        );
      }

      // OrderDomainV3.SaleOrder

      // OrderDomainV3.Asset
      // EM: SaleOrder asset invalid originKind
      require(
        OrderDomainV3._isValidOriginKind(asset.originKind),
        "E_CPFE_SAIO"
      );

      // Make sure using newer signature for new version
      // EM: Version not correct
      if (asset.value > 0) {
        require(ver >= 1, "E_CPFE_VNC");
      }

      // Validate RoyaltyInfo
      if (asset.royaltyReceivers.length > 0) {
        _validateRoyaltyInfo(
          asset.royaltyReceivers,
          asset.royaltyDistributionRate,
          asset.secondaryOnwardsRoyaltyPercentage
        );
      }

      // EM: SaleOrder invalid currentOwner
      require(_saleOrder.currentOwner != address(0), "E_CPFE_SICO");

      // EM: SaleOrder invalid paymentReceiver
      require(_saleOrder.paymentReceiver != address(0), "E_CPFE_SIPR");

      // EM: SaleOrder invalid start
      require(
        _saleOrder.start > 0 && _saleOrder.start <= block.timestamp,
        "E_CPFE_SIS"
      );

      // EM: SaleOrder invalid end
      require(
        _saleOrder.end == 0 || _saleOrder.end > block.timestamp,
        "E_CPFE_SIE"
      );

      // EM: SaleOrder invalid nonce
      require(_saleOrder.nonce != 0, "E_CPFE_SIN");

      // OrderDomainV3.BuyOrder
      // EM: SaleOrder and BuyOrder nonce does't match
      require(_saleOrder.nonce == _buyOrder.saleNonce, "E_CPFE_SBN");

      // EM: BuyOrder invalid buyer
      require(_buyOrder.buyer != address(0), "E_CPFE_BIB");

      // EM: BuyOrder invalid payer
      require(_buyOrder.payer != address(0), "E_CPFE_BIP");

      // EM: BuyOrder invalid paymentMode
      require(
        OrderDomainV3._isValidPaymentMode(_buyOrder.paymentDetails.paymentMode),
        "E_CPFE_BIPM"
      );

      // EM: BuyOrder invalid price
      require(_buyOrder.paymentDetails.price != 0, "E_CPFE_BOIP");

      // Mixed cases
      // EM: currentOwner and buyer can't be same
      require(_saleOrder.currentOwner != _buyOrder.buyer, "E_CPFE_CAABS");

      // Check for matching payment mode for Sale and Buy
      bool matchFound = false;
      for (
        uint256 idx = 0;
        idx < _saleOrder.acceptedPaymentMode.length;
        idx++
      ) {
        // EM: SaleOrder acceptedPaymentMode invalid paymentMode
        require(
          OrderDomainV3._isValidPaymentMode(
            _saleOrder.acceptedPaymentMode[idx].paymentMode
          ),
          "E_CPFE_SAPMPM"
        );

        // EM: SaleOrder acceptedPaymentMode invalid price
        require(
          _saleOrder.acceptedPaymentMode[idx].price != 0,
          "E_CPFE_SAPMIP"
        );

        if (
          _saleOrder.acceptedPaymentMode[idx].paymentMode ==
          _buyOrder.paymentDetails.paymentMode
        ) {
          matchFound = true;
          break;
        }
      }
      // EM: payment mode did't match
      require(matchFound, "E_CPFE_PMNM");
    }

    // Part 2: Verify signatures
    {
      // Prepares ERC712 message hash of Saler signature
      address recoverdAddress = _domainSeparatorV4()
        .toTypedDataHash(_hashMsgSaleOrder)
        .recover(_salerSign);
      // EM: invalid saler signer
      require(recoverdAddress == _saleOrder.currentOwner, "E_CPFE_ISS");

      // Prepares ERC712 message hash of platform signature
      bytes32 hashMsgBuyOrder = OrderDomainV3._hashBuyOrder(_buyOrder);
      recoverdAddress = _domainSeparatorV4()
        .toTypedDataHash(hashMsgBuyOrder)
        .recover(_platformSign);
      // EM: invalid platform signer
      require(platformRegistry.isPlatformSigner(recoverdAddress), "E_CPFE_IPS");
    }
  }

  /**
   * @dev Simulate the PartnerFeeTransfer(Not actual transfer)
   *
   * @param _asset OrderDomainV3.Asset
   * @param _pricePerAsset uint256 price of the asset
   */
  function _simulateRoyaltyTransfer(
    OrderDomainV3.Asset memory _asset,
    uint256 _pricePerAsset,
    uint8 _version
  ) internal virtual returns (uint256) {
    uint256 totalRoyaltyToSend = 0;

    address[] memory royaltyReceivers;
    uint256[] memory royaltyReceiversCut;
    uint8 royaltyType;
    (royaltyReceivers, royaltyReceiversCut, royaltyType) = royaltyRegistry
      .royaltyInfo(
        _asset.token,
        _asset.tokenId,
        _pricePerAsset,
        _asset.isSecondarySale
      );

    if (
      _version >= 2 &&
      royaltyReceivers.length == 0 &&
      _asset.royaltyReceivers.length > 0
    ) {
      // No RoyaltyRegistry info is set, use Royalty from parameter
      royaltyReceivers = _asset.royaltyReceivers;

      // Find the amount that needs to be split for royalty
      uint256 splitTotalPrice = _pricePerAsset;
      if (_asset.isSecondarySale == 1) {
        // Secondary Sale onwards royalty is distributed based on royaltyPercentage
        splitTotalPrice =
          (_pricePerAsset * _asset.secondaryOnwardsRoyaltyPercentage) /
          OrderDomainV3.FEE_DENOMINATOR;
      }

      // Find/Calculate royaltyReceiversCut
      royaltyReceiversCut = new uint256[](royaltyReceivers.length);
      for (uint256 idx = 0; idx < royaltyReceivers.length; idx++) {
        royaltyReceiversCut[idx] =
          (splitTotalPrice * _asset.royaltyDistributionRate[idx]) /
          OrderDomainV3.FEE_DENOMINATOR;
      }
    }

    for (uint256 idx = 0; idx < royaltyReceivers.length; idx++) {
      uint256 royaltyReceiverCut = royaltyReceiversCut[idx];

      _registerPayout(royaltyReceivers[idx], royaltyReceiverCut);

      totalRoyaltyToSend += royaltyReceiverCut;
    }

    return totalRoyaltyToSend;
  }

  /**
   * @dev Transfer NFT
   *
   * @param _currentOwner address
   * @param _asset OrderDomainV3.Asset memory
   * @param _buyOrder OrderDomainV3.BuyOrder
   */
  function _transferNFT(
    // OrderDomainV3.SaleOrder calldata _saleOrder,
    address _currentOwner,
    OrderDomainV3.Asset memory _asset,
    OrderDomainV3.BuyOrder calldata _buyOrder
  ) internal virtual {
    // OrderDomainV3.Asset memory asset = _saleOrder.assetList[0];
    if (IERC721(_asset.token).supportsInterface(type(IERC721).interfaceId)) {
      // ERC721の場合
      transferProxy.erc721safeTransferFrom(
        IERC721(_asset.token),
        _currentOwner,
        _buyOrder.buyer,
        _asset.tokenId
      );
    } else if (
      IERC1155(_asset.token).supportsInterface(type(IERC1155).interfaceId)
    ) {
      uint256 value = _asset.value;
      if (_buyOrder.firstAssetBuyValue > 0) {
        // For Single ERC1155
        value = _buyOrder.firstAssetBuyValue;
      }

      // ERC1155の場合
      transferProxy.erc1155safeTransferFrom(
        IERC1155(_asset.token),
        _currentOwner,
        _buyOrder.buyer,
        _asset.tokenId,
        value,
        bytes("0x")
      );
    } else {
      // EM: Unsupported asset type
      revert("E_UAT");
    }
  }

  /**
   * @dev Payout to all receivers using _tempPayoutAddress and _tempPayoutAmount
   * when execting exchange
   *
   * @param _paymentMode bytes4 Payment.paymentMode
   * @param _paymentToken address
   * @param _payer address
   */
  function _payout(
    bytes4 _paymentMode,
    address _paymentToken,
    address _payer
  ) internal virtual {
    for (uint256 idx = 0; idx < _tempPayoutAddress.length; idx++) {
      address payable reciever = payable(_tempPayoutAddress[idx]);
      uint256 amount = _tempPayoutAmount[reciever];

      if (_paymentMode == OrderDomainV3.NATIVE_PAYMENT_MODE) {
        // Sending ETH
        reciever.transfer(amount);
      } else if (_paymentMode == OrderDomainV3.ERC20_PAYMENT_MODE) {
        // Sending ERC20
        transferProxy.erc20safeTransferFrom(
          IERC20(_paymentToken),
          _payer,
          reciever,
          amount
        );
      }
    }
  }

  /**
   * @dev Register payment locally, to be used in _payout
   *
   * @param _reciever address
   * @param _amount uint256
   */
  function _registerPayout(
    address _reciever,
    uint256 _amount
  ) internal virtual {
    if (_amount > 0) {
      if (_tempPayoutAmount[_reciever] == 0) {
        _tempPayoutAddress.push(_reciever);
      }
      _tempPayoutAmount[_reciever] += _amount;
    }
  }

  /**
   * @dev Clears previous payout data
   * It is used for collective payment to pay one address only once
   */
  function _resetPayoutTemp() internal virtual {
    for (uint256 idx = 0; idx < _tempPayoutAddress.length; idx++) {
      delete _tempPayoutAmount[_tempPayoutAddress[idx]];
    }
    delete _tempPayoutAddress;
  }

  /**
   * @dev See {IExchange.exchange()}
   *
   * @param _saleOrder OrderDomainV3.SaleOrder
   * @param _salerSign saler signature
   * @param _buyOrder OrderDomainV3.BuyOrder
   * @param _platformSign platform signature
   *
   * Requirements:
   * - whenNotPaused
   * - nonReentrant
   *
   * Emits a {Sale} event
   */
  function exchange(
    OrderDomainV3.SaleOrder calldata _saleOrder,
    bytes calldata _salerSign,
    OrderDomainV3.BuyOrder calldata _buyOrder,
    bytes calldata _platformSign
  ) external payable virtual override whenNotPaused nonReentrant {
    uint8 ver = _saleOrder.version;
    // Step1 : Parameters and signatures checks
    bytes32 hashMsgSaleOrder = OrderDomainV3._hashSaleOrder(_saleOrder);
    _checkParameterAndVerifySignaturesForExchange(
      _saleOrder,
      _salerSign,
      _buyOrder,
      _platformSign,
      hashMsgSaleOrder
    );
    OrderDomainV3.Asset memory asset = _saleOrder.assetList[0];

    // Step2 : Payout (if OnchainPaymentMode) : Platform Fee + Partner Fee(If partner) + Royalty + Saler(Secondary onwards)
    // OnchainPaymentMode == NATIVE_PAYMENT_MODE || ERC20_PAYMENT_MODE
    if (
      OrderDomainV3._isOnchainPaymentMode(_buyOrder.paymentDetails.paymentMode)
    ) {
      // Payout map is used for collective payment by sending only once for an address
      // So reset it before using it
      _resetPayoutTemp();

      // Sale Price = Platform Fee + Partner Fee(If partner) + Royalty + Saler(Secondary onwards)
      // Find the total sale price by matching payment mode of SaleOrder and BuyOrder
      uint256 totalSalePrice = OrderDomainV3._findTotalSalePrice(
        _saleOrder,
        _buyOrder
      );

      if (_buyOrder.firstAssetBuyValue > 0) {
        // Single Sale for ERC1155
        totalSalePrice =
          (totalSalePrice * _buyOrder.firstAssetBuyValue) /
          _saleOrder.assetList[0].value;
      }

      // Make sure Native Token/ERC20 recieved is enough for sale
      // NOTE: if got more Native Token/ERC20 then needed, it will be stored in this contract(considered as TIP)
      if (
        _buyOrder.paymentDetails.paymentMode ==
        OrderDomainV3.NATIVE_PAYMENT_MODE
      ) {
        // Native Token case
        // EM: not enough Native Token received for sale
        require(msg.value >= totalSalePrice, "E_E_NENT");
        // NOTE: TIP will be added to the balance of this contract
      } else if (
        _buyOrder.paymentDetails.paymentMode == OrderDomainV3.ERC20_PAYMENT_MODE
      ) {
        // ERC20 case
        // NOTE: Make sure appropriate amount of ERC20 is approved to TransferProxy
        address paymentToken = _buyOrder.paymentDetails.paymentToken;
        // EM: not enough ERC20 approved for sale
        uint256 allowanceCount = IERC20(paymentToken).allowance(
          _buyOrder.payer,
          address(transferProxy)
        );
        require(allowanceCount >= totalSalePrice, "E_E_NEERC20");

        // Register TIP
        uint256 tip = allowanceCount - totalSalePrice;
        if (tip > 0) {
          ERC20Tip memory erc20Tip = ERC20Tip(_buyOrder.payer, tip);
          _erc20TipDeposite[paymentToken].push(erc20Tip);
        }
      }

      address paymentReceiver = _saleOrder.paymentReceiver;

      // [Platform Fee for Asset]
      uint16 pfSaleFeeRate = _saleOrder.pfSaleFeeRate;
      // NOTE: from version 1 onward, need to set Secondary Sale fee rate at [SaleOrder.pfSaleFeeRateSecondary]
      if (ver >= 1 && OrderDomainV3._isSecondarySale(asset.isSecondarySale)) {
        // Secondary onwards sale case
        pfSaleFeeRate = _saleOrder.pfSaleFeeRateSecondary;
      }
      // Simulate sending platform fee
      uint256 pfFeeForAsset = (totalSalePrice * pfSaleFeeRate) /
        OrderDomainV3.FEE_DENOMINATOR;
      _registerPayout(platformRegistry.getPlatformFeeReceiver(), pfFeeForAsset);

      // [Partner Fee for Asset]
      uint256 partnerFeeForAsset = 0;
      if (
        OrderDomainV3._isPartnerOrigin(asset.originKind) &&
        asset.partnerFeeRate > 0
      ) {
        address payable partnerFeeReceiver = asset.partnerFeeReceiver;
        if (partnerFeeReceiver == address(0)) {
          // If _asset.partnerFeeReceiver is not set, try to get from platformRegistry
          partnerFeeReceiver = platformRegistry.getPartnerFeeReceiver(
            asset.token
          );
        }

        // Make sure partner fee recever is set
        // EM: partner fee recever is not set
        require(partnerFeeReceiver != address(0), "E_E_PFRNS");

        partnerFeeForAsset =
          (totalSalePrice * asset.partnerFeeRate) /
          OrderDomainV3.FEE_DENOMINATOR;
        _registerPayout(partnerFeeReceiver, partnerFeeForAsset);
      }

      // [Royalties for Asset]
      uint256 royaltySplitPriceForAsset = 0;
      if (OrderDomainV3._isSecondarySale(asset.isSecondarySale)) {
        // Secondary onwards sale case
        royaltySplitPriceForAsset = totalSalePrice;
      } else {
        // Primary sale case
        royaltySplitPriceForAsset =
          totalSalePrice -
          pfFeeForAsset -
          partnerFeeForAsset;
      }
      // Simulate sending royalty cut
      uint256 royaltyFeeForAsset = _simulateRoyaltyTransfer(
        asset,
        royaltySplitPriceForAsset,
        ver
      );

      // [Saler Cut for Asset]
      _registerPayout(
        paymentReceiver,
        totalSalePrice - pfFeeForAsset - partnerFeeForAsset - royaltyFeeForAsset
      );

      // Payout
      _payout(
        _buyOrder.paymentDetails.paymentMode,
        _buyOrder.paymentDetails.paymentToken,
        _buyOrder.payer
      );
      _resetPayoutTemp();
    }

    // Step3 : Transfer NFT
    _transferNFT(_saleOrder.currentOwner, asset, _buyOrder);

    // Step4 : Update sale order state and emit event
    if (_buyOrder.firstAssetBuyValue > 0) {
      _setSoldByNonce(
        _saleOrder.nonce,
        asset.token,
        asset.tokenId,
        _buyOrder.firstAssetBuyValue
      );

      emit SaleSingle(
        _saleOrder.nonce,
        asset.token,
        asset.tokenId,
        _buyOrder.firstAssetBuyValue
      );
    } else {
      // Mark whole order as sold, when bundle sale
      _setSoldByKey(hashMsgSaleOrder, 1);

      emit SaleSingle(
        _saleOrder.nonce,
        asset.token,
        asset.tokenId,
        asset.value
      );
    }
  }

  /**
   * @dev Withdraw Tip
   *
   * @param _receiver address payable
   * @param _erc20Token address. When Native, address is zero.
   */
  function withdrawTip(
    address payable _receiver,
    address _erc20Token
  ) public virtual onlyAdmin {
    // EM: Invalid withdraw address
    require(_receiver != address(0), "E_WT_IRA");

    if (_erc20Token == address(0)) {
      // Native tip withdraw
      _receiver.transfer(address(this).balance);
    } else {
      // ERC20 tip withdrawal
      ERC20Tip[] storage erc20TipList = _erc20TipDeposite[_erc20Token];

      for (uint256 idx = 0; idx < erc20TipList.length; idx++) {
        ERC20Tip storage erc20Tip = erc20TipList[idx];
        // Sending ERC20
        transferProxy.erc20safeTransferFrom(
          IERC20(_erc20Token),
          erc20Tip.tipper,
          _receiver,
          erc20Tip.amount
        );
      }

      // Clear tip info after transfer
      delete _erc20TipDeposite[_erc20Token];
    }
  }

  /**
   * @dev Returns the version of this contract
   */
  function version() public pure virtual override returns (uint8) {
    return 2;
  }
}
        

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC165.sol)

pragma solidity ^0.8.0;

import "../utils/introspection/IERC165Upgradeable.sol";
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;

import "../utils/introspection/IERC165Upgradeable.sol";

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981Upgradeable is IERC165Upgradeable {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822ProxiableUpgradeable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}
          

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

pragma solidity ^0.8.9;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Context variant with ERC2771 support.
 */
abstract contract ERC2771ContextUpgradeable is Initializable, ContextUpgradeable {
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
    address private immutable _trustedForwarder;

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor(address trustedForwarder) {
        _trustedForwarder = trustedForwarder;
    }

    function isTrustedForwarder(address forwarder) public view virtual returns (bool) {
        return forwarder == _trustedForwarder;
    }

    function _msgSender() internal view virtual override returns (address sender) {
        if (isTrustedForwarder(msg.sender)) {
            // The assembly code is more direct than the Solidity version using `abi.decode`.
            /// @solidity memory-safe-assembly
            assembly {
                sender := shr(96, calldataload(sub(calldatasize(), 20)))
            }
        } else {
            return super._msgSender();
        }
    }

    function _msgData() internal view virtual override returns (bytes calldata) {
        if (isTrustedForwarder(msg.sender)) {
            return msg.data[:msg.data.length - 20];
        } else {
            return super._msgData();
        }
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;

import "../beacon/IBeaconUpgradeable.sol";
import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/StorageSlotUpgradeable.sol";
import "../utils/Initializable.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 *
 * @custom:oz-upgrades-unsafe-allow delegatecall
 */
abstract contract ERC1967UpgradeUpgradeable is Initializable {
    function __ERC1967Upgrade_init() internal onlyInitializing {
    }

    function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
    }
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            _functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallUUPS(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        // Upgrades from old implementations will perform a rollback test. This test requires the new
        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
        // this special case will break upgrade paths from old UUPS implementation to new ones.
        if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
            } catch {
                revert("ERC1967Upgrade: new implementation is not UUPS");
            }
            _upgradeToAndCall(newImplementation, data, forceCall);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Emitted when the beacon is upgraded.
     */
    event BeaconUpgraded(address indexed beacon);

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(
        address newBeacon,
        bytes memory data,
        bool forceCall
    ) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
        }
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {
        require(AddressUpgradeable.isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeaconUpgradeable {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
     * initialization step. This is essential to configure modules that are added through upgrades and that require
     * initialization.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized < type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)

pragma solidity ^0.8.0;

import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../ERC1967/ERC1967UpgradeUpgradeable.sol";
import "./Initializable.sol";

/**
 * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
 * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
 *
 * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
 * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
 * `UUPSUpgradeable` with a custom implementation of upgrades.
 *
 * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
 *
 * _Available since v4.1._
 */
abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
    function __UUPSUpgradeable_init() internal onlyInitializing {
    }

    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
    }
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
    address private immutable __self = address(this);

    /**
     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
     * fail.
     */
    modifier onlyProxy() {
        require(address(this) != __self, "Function must be called through delegatecall");
        require(_getImplementation() == __self, "Function must be called through active proxy");
        _;
    }

    /**
     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
     * callable on the implementing contract but not through proxies.
     */
    modifier notDelegated() {
        require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
        _;
    }

    /**
     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
     * implementation. It is used to validate that the this implementation remains valid after an upgrade.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
     */
    function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
        return _IMPLEMENTATION_SLOT;
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     */
    function upgradeTo(address newImplementation) external virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
     * encoded in `data`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, data, true);
    }

    /**
     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
     * {upgradeTo} and {upgradeToAndCall}.
     *
     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
     *
     * ```solidity
     * function _authorizeUpgrade(address) internal override onlyOwner {}
     * ```
     */
    function _authorizeUpgrade(address newImplementation) internal virtual;

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}
          

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

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.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 PausableUpgradeable is Initializable, ContextUpgradeable {
    /**
     * @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.
     */
    function __Pausable_init() internal onlyInitializing {
        __Pausable_init_unchained();
    }

    function __Pausable_init_unchained() internal onlyInitializing {
        _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());
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";

/**
 * @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 ReentrancyGuardUpgradeable is Initializable {
    // 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;

    function __ReentrancyGuard_init() internal onlyInitializing {
        __ReentrancyGuard_init_unchained();
    }

    function __ReentrancyGuard_init_unchained() internal onlyInitializing {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}
          

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";

/**
 * @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 ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}
          

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

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlotUpgradeable {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }
}
          

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

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library StringsUpgradeable {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.3) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../StringsUpgradeable.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSAUpgradeable {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;

import "./ECDSAUpgradeable.sol";
import "../../proxy/utils/Initializable.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 *
 * @custom:storage-size 52
 */
abstract contract EIP712Upgradeable is Initializable {
    /* solhint-disable var-name-mixedcase */
    bytes32 private _HASHED_NAME;
    bytes32 private _HASHED_VERSION;
    bytes32 private constant _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
        __EIP712_init_unchained(name, version);
    }

    function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev The hash of the name parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712NameHash() internal virtual view returns (bytes32) {
        return _HASHED_NAME;
    }

    /**
     * @dev The hash of the version parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712VersionHash() internal virtual view returns (bytes32) {
        return _HASHED_VERSION;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
    function __ERC165_init() internal onlyInitializing {
    }

    function __ERC165_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165Upgradeable).interfaceId;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165Upgradeable {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
          

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

import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";

/**
 * @notice deprecated use AdminUpgradeableV2
 * @title AdminUpgradeable Contract to manage access
 *
 * @author SBINFT Co., Ltd.
 */
abstract contract AdminUpgradeable is ContextUpgradeable {
  event AdminAdded(address);
  event AdminRemoved(address);

  /**
   * @dev 管理者のマッピング。管理者でないならばfalseを返す。
   */
  mapping(address => bool) private _admin;

  function __Admin_init() internal onlyInitializing {
    __Context_init();
    // 初期化時にデプロイ者を管理者に追加する。
    _addAdmin(_msgSender());
  }

  /**
   * @dev 管理者を複数追加
   */
  function addAdmin(address[] calldata newAdmin) public virtual onlyAdmin {
    for (uint256 idx = 0; idx < newAdmin.length; idx++) {
      _addAdmin(newAdmin[idx]);
    }
  }

  /**
   * @dev 管理者を一人追加
   */
  function addAdmin(address newAdmin) public virtual onlyAdmin {
    _addAdmin(newAdmin);
  }

  /**
   * @dev 管理者を一人追加
   * 無制限 Internal function
   */
  function _addAdmin(address newAdmin) internal virtual {
    require(
      newAdmin != address(0),
      "Admin:addAdmin newAdmin is the zero address"
    );

    _admin[newAdmin] = true;
    emit AdminAdded(newAdmin);
  }

  /**
   * @dev 管理者を一人削除
   */
  function removeAdmin(address admin) public virtual onlyAdmin {
    require(
      _admin[admin],
      "Admin:removeAdmin trying to remove non existing Admin"
    );

    _removeAdmin(admin);
  }

  /**
   * @dev 管理者を一人削除
   * 無制限 Internal function
   */
  function _removeAdmin(address admin) internal virtual {
    delete _admin[admin];
    emit AdminRemoved(admin);
  }

  /**
   * @dev
   * Adminかどうかのチェック
   */
  function isAdmin(address checkAdmin) public view virtual returns (bool) {
    return _admin[checkAdmin];
  }

  /**
   * @dev Throws if called by any account other than Admin.
   */
  modifier onlyAdmin() {
    require(_admin[_msgSender()], "Admin:onlyAdmin caller is not an Admin");
    _;
  }
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

import "@openzeppelin/contracts-upgradeable/interfaces/IERC165Upgradeable.sol";

/**
 * @title SBINFT Platform Registry
 */
interface IPlatformRegistry is IERC165Upgradeable {
  /**
   * @dev Update to new PlatformFeeRateLowerLimit
   *
   * @param _new new PlatformFeeRateLowerLimit
   */
  function updatePlatformFeeLowerLimit(uint16 _new) external;

  /**
   * @dev Update to new PlatformFeeReceiver
   *
   * @param _new new PlatformFeeReceiver
   */
  function updatePlatformFeeReceiver(address payable _new) external;

  /**
   * @dev Update to new PartnerFeeReceiver for partner's collection
   *
   * @param collection partner's collection
   * @param partnerFeeReceiver new partner's FeeReceiver
   * @param sign bytes calldata signature of platform signer
   */
  function updatePartnerFeeReceiver(
    address collection,
    address payable partnerFeeReceiver,
    bytes calldata sign
  ) external;

  /**
   * @dev Checks if partner fee receiver
   *
   * @param _collection address of token
   * @param _partnerFeeReceiver address of partner FeeReceiver
   *
   * Requirements:
   * - _collection must be a non zero address
   * - _partnerFeeReceiver must be a non zero address
   */
  function isPartnerFeeReceiver(
    address _collection,
    address _partnerFeeReceiver
  ) external view returns (bool);

  /**
   * @dev Checks state of a Whitelisted token
   *
   * @param _token address of token
   */
  function isWhitelistedERC20(address _token) external view returns (bool);

  /**
   * @dev Adds list of token to Whitelisted, if zero address then will be ignored
   *
   * @param _addTokenList array of address of token to add
   */
  function addToERC20Whitelist(address[] calldata _addTokenList) external;

  /**
   * @dev Removes list of token from Whitelisted
   *
   * @param _tokenList array of address of token to remove
   */
  function removeFromERC20Whitelist(address[] calldata _tokenList) external;

  /**
   * @dev Checks state of a Whitelisted token
   *
   * @param _signer address of token
   */
  function isPlatformSigner(address _signer) external view returns (bool);

  /**
   * @dev Adds list of token to Whitelisted, if zero address then will be ignored
   *
   * @param _platformSignerList array of platfomr signer address  to add
   */
  function addPlatformSigner(address[] calldata _platformSignerList) external;

  /**
   * @dev Removes list of platform signers address
   *
   * @param _list array of platfomr signer address to remove
   */
  function removePlatformSigner(address[] calldata _list) external;

  /**
   * @dev Returns PlatformFeeReceiver
   */
  function getPlatformFeeReceiver() external returns (address payable);

  /**
   * @dev Returns PartnerFeeReceiver
   *
   * @param _token address of partner token
   */
  function getPartnerFeeReceiver(
    address _token
  ) external returns (address payable);

  /**
   * @dev Returns PlatformFeeReceiver
   *
   */
  function getPlatformFeeRateLowerLimit() external returns (uint16);

  /**
   * @dev Update to new PartnerPfFeeReceiver for partner's platformSigner
   *
   * @param _externalPlatformToken address of external Platform Token
   * @param _partnerPfFeeReceiver address new partner's platformer FeeReceiver
   *
   * Requirements:
   * - _platformSigner must be a non zero address
   * - _partnerPfFeeReceiver must be a non zero address
   *
   * Emits a {ExternalPfFeeReceiverUpdated} event
   */
  function updateExternalPlatformFeeReceiver(
    address _externalPlatformToken,
    address payable _partnerPfFeeReceiver
  ) external;

  /**
   * @dev Returns ExternalPlatformFeeReceiver
   *
   * @param _token address of external platform token
   */
  function getExternalPlatformFeeReceiver(
    address _token
  ) external returns (address payable);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.17;

import "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IRoyaltyRegistry is IERC2981Upgradeable {
  /**
   * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
   * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
   */
  function royaltyInfo(
    address _token,
    uint256 _tokenId,
    uint256 _salePrice,
    uint8 _isSecondarySale
  )
    external
    returns (
      address[] memory receivers,
      uint256[] memory royaltyFees,
      uint8 royaltyType
    );

  /**
   * @dev Returns the division factor for calculating precentage
   */
  function feeDenominator() external returns (uint16);
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts-upgradeable/interfaces/IERC165Upgradeable.sol";

/**
 * @title  SBINFT market non-native asset transfer protocol
 */
interface ITransferProxy is IERC165Upgradeable {
  /**
   * @notice Safe transfer ERC20 token
   * @dev only registered operators could call this function(i.e. Exchange)
   *
   * @param _token IERC20 token address
   * @param _from address from
   * @param _to address to
   * @param _value uint256 value
   */
  function erc20safeTransferFrom(
    IERC20 _token,
    address _from,
    address _to,
    uint256 _value
  ) external;

  /**
   * @notice Safe transfer ERC721 token
   * @dev only registered operators could call this function(i.e. Exchange)
   *
   * @param _token IERC721 token address
   * @param _from address current owner address
   * @param _to address new to be owner address
   * @param _tokenId uint256 token id to transfer
   */
  function erc721safeTransferFrom(
    IERC721 _token,
    address _from,
    address _to,
    uint256 _tokenId
  ) external;

  /**
   * @notice Safe transfer ERC1155 token
   * @dev only registered operators could call this function(i.e. Exchange)
   *
   * @param _token IERC1155 token address
   * @param _from address current owner address
   * @param _to address new to be owner address
   * @param _tokenId uint256 token id to transfer
   * @param _value uint256 count of token to transfer
   * @param _data bytes extra data if needed
   */
  function erc1155safeTransferFrom(
    IERC1155 _token,
    address _from,
    address _to,
    uint256 _tokenId,
    uint256 _value,
    bytes calldata _data
  ) external;
}
          

// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.19;

import "@openzeppelin/contracts-upgradeable/interfaces/IERC165Upgradeable.sol";

import "contracts/sbinft/market/v3/library/OrderDomainV3.sol";

/**
 * @title SBINFT Exchange protocol interface
 * @author SBINFT Co., Ltd.
 */
interface IExchangeV3 is IERC165Upgradeable {
  // Emits whenever there is a exchange/sale
  event SaleSingle(
    uint256 indexed nonce,
    address indexed token,
    uint256 indexed tokenId,
    uint256 value
  );

  /**
   * @dev Try to exchange bundle asset in process of Sale
   *
   * @param _saleOrder OrderDomainV3.SaleOrder
   * @param _salerSign saler signature
   * @param _buyOrder OrderDomainV3.BuyOrder
   * @param _platformSign platform signature
   */
  function exchange(
    OrderDomainV3.SaleOrder calldata _saleOrder,
    bytes calldata _salerSign,
    OrderDomainV3.BuyOrder calldata _buyOrder,
    bytes calldata _platformSign
  ) external payable;

  /**
   * @dev Returns the version of this contract
   */
  function version() external pure returns (uint8);
}
          

// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.19;

/**
 * @dev Model data related with Order
 * @author SBINFT Co., Ltd.
 */
library OrderDomainV3 {
  // ORIGIN_KIND
  bytes4 private constant NANAKUSA_ORIGIN_KIND = bytes4(keccak256("NANAKUSA"));
  bytes4 private constant PARTNER_ORIGIN_KIND = bytes4(keccak256("PARTNER"));

  // PAYMENT_MODE
  bytes4 public constant NATIVE_PAYMENT_MODE = bytes4(keccak256("NATIVE"));
  bytes4 public constant ERC20_PAYMENT_MODE = bytes4(keccak256("ERC20"));
  bytes4 private constant CREDIT_CARD_PAYMENT_MODE =
    bytes4(keccak256("CREDIT_CARD"));
  bytes4 private constant OTHER_BLOCKCHAIN_PAYMENT_MODE =
    bytes4(keccak256("OTHER_BLOCKCHAIN"));

  /**
   * @dev Sale Asset Info
   */
  struct Asset {
    bytes4 originKind;
    address token;
    uint256 tokenId;
    uint256 value; // [v2] Only For ERC1155, For ERC721 always 0
    uint16 partnerFeeRate; // only set when originKind = PARTNER_ORIGIN_KIND
    address payable partnerFeeReceiver; //[v2] only set when originKind = PARTNER_ORIGIN_KIND or can be set into PlatformRegistry
    uint8 isSecondarySale; // 1 = true, 0 = false
    address[] royaltyReceivers; // [v3]
    uint16[] royaltyDistributionRate; // [v3]
    uint16 secondaryOnwardsRoyaltyPercentage; // [v3]
  }

  struct Payment {
    bytes4 paymentMode; // Like NATIVE_PAYMENT_MODE || ERC20_PAYMENT_MODE || ...
    address paymentToken; // Token contract address
    uint256 price;
  }

  struct SaleOrder {
    Asset[] assetList; // Array but only zero [0] index will be used(as bundle listing is depreciated)
    address currentOwner;
    address paymentReceiver; // Onchain payment receiver, can be same as currentOwner
    Payment[] acceptedPaymentMode;
    uint16 pfSaleFeeRate;
    uint16 pfSaleFeeRateSecondary; // [v2]
    uint256 start; // Always non zero
    uint256 end; // Can be zero when there is no end time
    uint256 nonce;
    uint8 version; // [v2] 0 = version1, 1 = version2, 2 = version3 ...
  }

  struct BuyOrder {
    uint256 saleNonce;
    address payable buyer;
    address payable payer; // If no payer means buyer is the payer
    uint256 firstAssetBuyValue; // [v2] For bundle sale and ERC721 always 0, Only for single ERC1155 sale need some value
    Payment paymentDetails;
    uint256 validUntil; // UNIX timestamp to determine the of validity of buyOrder
    uint8 version; // [v2] 0 = version1, 1 = version2 ...
  }

  // ---- EIP712 ----
  // [v1]
  bytes32 private constant ASSET_TYPEHASH =
    keccak256(
      "Asset(bytes4 originKind,address token,uint256 tokenId,uint16 partnerFeeRate,uint8 isSecondarySale)"
    );

  bytes32 private constant PAYMENT_TYPEHASH =
    keccak256("Payment(bytes4 paymentMode,address paymentToken,uint256 price)");

  bytes32 private constant SALE_ORDER_TYPEHASH =
    keccak256(
      "SaleOrder(Asset[] assetList,address currentOwner,address paymentReceiver,Payment[] acceptedPaymentMode,uint16 pfSaleFeeRate,uint256 start,uint256 end,uint256 nonce)Asset(bytes4 originKind,address token,uint256 tokenId,uint16 partnerFeeRate,uint8 isSecondarySale)Payment(bytes4 paymentMode,address paymentToken,uint256 price)"
    );

  bytes32 private constant BUY_ORDER_TYPEHASH =
    keccak256(
      "BuyOrder(uint256 saleNonce,address buyer,address payer,Payment paymentDetails,uint256 validUntil)Payment(bytes4 paymentMode,address paymentToken,uint256 price)"
    );

  // [v2]
  bytes32 private constant ASSET_TYPEHASH_V2 =
    keccak256(
      "Asset(bytes4 originKind,address token,uint256 tokenId,uint256 value,uint16 partnerFeeRate,address partnerFeeReceiver,uint8 isSecondarySale)"
    );

  bytes32 private constant SALE_ORDER_TYPEHASH_V2 =
    keccak256(
      "SaleOrder(Asset[] assetList,address currentOwner,address paymentReceiver,Payment[] acceptedPaymentMode,uint16 pfSaleFeeRate,uint16 pfSaleFeeRateSecondary,uint256 start,uint256 end,uint256 nonce,uint8 version)Asset(bytes4 originKind,address token,uint256 tokenId,uint256 value,uint16 partnerFeeRate,address partnerFeeReceiver,uint8 isSecondarySale)Payment(bytes4 paymentMode,address paymentToken,uint256 price)"
    );

  bytes32 private constant BUY_ORDER_TYPEHASH_V2 =
    keccak256(
      "BuyOrder(uint256 saleNonce,address buyer,address payer,uint256 firstAssetBuyValue,Payment paymentDetails,uint256 validUntil,uint8 version)Payment(bytes4 paymentMode,address paymentToken,uint256 price)"
    );

  // [v3]
  /**
   * @dev Defaults to 10000 so fees are expressed in basis points, but may be customized by an override.
   * 10000 = 100%
   */
  uint16 internal constant FEE_DENOMINATOR = 10000;

  bytes32 private constant ASSET_TYPEHASH_V3 =
    keccak256(
      "Asset(bytes4 originKind,address token,uint256 tokenId,uint256 value,uint16 partnerFeeRate,address partnerFeeReceiver,uint8 isSecondarySale,address[] royaltyReceivers,uint16[] royaltyDistributionRate,uint16 secondaryOnwardsRoyaltyPercentage)"
    );

  bytes32 private constant SALE_ORDER_TYPEHASH_V3 =
    keccak256(
      "SaleOrder(Asset[] assetList,address currentOwner,address paymentReceiver,Payment[] acceptedPaymentMode,uint16 pfSaleFeeRate,uint16 pfSaleFeeRateSecondary,uint256 start,uint256 end,uint256 nonce,uint8 version)Asset(bytes4 originKind,address token,uint256 tokenId,uint256 value,uint16 partnerFeeRate,address partnerFeeReceiver,uint8 isSecondarySale,address[] royaltyReceivers,uint16[] royaltyDistributionRate,uint16 secondaryOnwardsRoyaltyPercentage)Payment(bytes4 paymentMode,address paymentToken,uint256 price)"
    );

  /**
   * @dev Prepares keccak256 hash for Asset
   *
   * @param _asset OrderDomain.Asset
   * @param _version uint8
   */
  function _hashAsset(
    Asset calldata _asset,
    uint8 _version
  ) internal pure returns (bytes32) {
    if (_version == 0) {
      // [v1]
      return
        keccak256(
          abi.encode(
            ASSET_TYPEHASH,
            _asset.originKind,
            _asset.token,
            _asset.tokenId,
            _asset.partnerFeeRate,
            _asset.isSecondarySale
          )
        );
    } else if (_version == 1) {
      // [v2]
      return
        keccak256(
          abi.encode(
            ASSET_TYPEHASH_V2,
            _asset.originKind,
            _asset.token,
            _asset.tokenId,
            _asset.value,
            _asset.partnerFeeRate,
            _asset.partnerFeeReceiver,
            _asset.isSecondarySale
          )
        );
    } else if (_version == 2) {
      // [v3]
      return
        keccak256(
          abi.encode(
            ASSET_TYPEHASH_V3,
            _asset.originKind,
            _asset.token,
            _asset.tokenId,
            _asset.value,
            _asset.partnerFeeRate,
            _asset.partnerFeeReceiver,
            _asset.isSecondarySale,
            keccak256(abi.encodePacked(_asset.royaltyReceivers)),
            keccak256(abi.encodePacked(_asset.royaltyDistributionRate)),
            _asset.secondaryOnwardsRoyaltyPercentage
          )
        );
    } else {
      revert("E_OD3_IV");
    }
  }

  /**
   * @dev Prepares keccak256 hash for Asset list
   *
   * @param _assetList OrderDomain.Asset[]
   * @param _version uint8
   */
  function _hashAsset(
    Asset[] calldata _assetList,
    uint8 _version
  ) internal pure returns (bytes32) {
    bytes32[] memory keccakData = new bytes32[](_assetList.length);

    for (uint256 idx = 0; idx < _assetList.length; idx++) {
      keccakData[idx] = _hashAsset(_assetList[idx], _version);
    }

    return keccak256(abi.encodePacked(keccakData));
  }

  /**
   * @dev Prepares keccak256 hash for Payment
   *
   * @param _payment OrderDomain.Payment
   */
  function _hashPayment(
    Payment calldata _payment
  ) internal pure returns (bytes32) {
    return
      keccak256(
        abi.encode(
          PAYMENT_TYPEHASH,
          _payment.paymentMode,
          _payment.paymentToken,
          _payment.price
        )
      );
  }

  /**
   * @dev Prepares keccak256 hash for Payment list
   *
   * @param _paymentList OrderDomain.Payment[]
   */
  function _hashPayment(
    Payment[] calldata _paymentList
  ) internal pure returns (bytes32) {
    bytes32[] memory keccakData = new bytes32[](_paymentList.length);

    for (uint256 idx = 0; idx < _paymentList.length; idx++) {
      keccakData[idx] = _hashPayment(_paymentList[idx]);
    }

    return keccak256(abi.encodePacked(keccakData));
  }

  /**
   * @dev Prepares keccak256 hash for SaleOrder
   *
   * @param _saleOrder OrderDomain.SaleOrder
   */
  function _hashSaleOrder(
    SaleOrder calldata _saleOrder
  ) internal pure returns (bytes32) {
    if (_saleOrder.version == 0) {
      // [v1]
      return
        keccak256(
          abi.encode(
            SALE_ORDER_TYPEHASH,
            _hashAsset(_saleOrder.assetList, _saleOrder.version),
            _saleOrder.currentOwner,
            _saleOrder.paymentReceiver,
            _hashPayment(_saleOrder.acceptedPaymentMode),
            _saleOrder.pfSaleFeeRate,
            _saleOrder.start,
            _saleOrder.end,
            _saleOrder.nonce
          )
        );
    } else if (_saleOrder.version == 1) {
      // [v2]
      return
        keccak256(
          abi.encode(
            SALE_ORDER_TYPEHASH_V2,
            _hashAsset(_saleOrder.assetList, _saleOrder.version),
            _saleOrder.currentOwner,
            _saleOrder.paymentReceiver,
            _hashPayment(_saleOrder.acceptedPaymentMode),
            _saleOrder.pfSaleFeeRate,
            _saleOrder.pfSaleFeeRateSecondary,
            _saleOrder.start,
            _saleOrder.end,
            _saleOrder.nonce,
            _saleOrder.version
          )
        );
    } else if (_saleOrder.version == 2) {
      // [v3]
      return
        keccak256(
          abi.encode(
            SALE_ORDER_TYPEHASH_V3,
            _hashAsset(_saleOrder.assetList, _saleOrder.version),
            _saleOrder.currentOwner,
            _saleOrder.paymentReceiver,
            _hashPayment(_saleOrder.acceptedPaymentMode),
            _saleOrder.pfSaleFeeRate,
            _saleOrder.pfSaleFeeRateSecondary,
            _saleOrder.start,
            _saleOrder.end,
            _saleOrder.nonce,
            _saleOrder.version
          )
        );
    } else {
      revert("E_OD3_IV");
    }
  }

  /**
   * @dev Prepares keccak256 hash for BuyOrder
   *
   * @param _buyOrder OrderDomain.BuyOrder
   */
  function _hashBuyOrder(
    BuyOrder calldata _buyOrder
  ) internal pure returns (bytes32) {
    if (_buyOrder.version == 0) {
      // [v1]
      return
        keccak256(
          abi.encode(
            BUY_ORDER_TYPEHASH,
            _buyOrder.saleNonce,
            _buyOrder.buyer,
            _buyOrder.payer,
            _hashPayment(_buyOrder.paymentDetails),
            _buyOrder.validUntil
          )
        );
    } else if (_buyOrder.version == 1 || _buyOrder.version == 2) {
      // [v2] or [v3]
      return
        keccak256(
          abi.encode(
            BUY_ORDER_TYPEHASH_V2,
            _buyOrder.saleNonce,
            _buyOrder.buyer,
            _buyOrder.payer,
            _buyOrder.firstAssetBuyValue,
            _hashPayment(_buyOrder.paymentDetails),
            _buyOrder.validUntil,
            _buyOrder.version
          )
        );
    } else {
      revert("E_OD3_IV");
    }
  }

  // ---- EIP712 ----

  /**
   * @dev Checks if it's a Secondary Sale
   *
   * @param _secondarySale uint8
   */
  function _isSecondarySale(uint8 _secondarySale) internal pure returns (bool) {
    return (_secondarySale == 1);
  }

  /**
   * @dev Checks if it's a valid origin kind
   *
   * @param _originKind bytes4
   */
  function _isValidOriginKind(bytes4 _originKind) internal pure returns (bool) {
    return (_originKind == NANAKUSA_ORIGIN_KIND ||
      _originKind == PARTNER_ORIGIN_KIND);
  }

  /**
   * @dev Checks if it's a valid payment mode
   *
   * @param _paymentMode bytes4
   */
  function _isValidPaymentMode(
    bytes4 _paymentMode
  ) internal pure returns (bool) {
    return (_paymentMode == NATIVE_PAYMENT_MODE ||
      _paymentMode == ERC20_PAYMENT_MODE ||
      _paymentMode == CREDIT_CARD_PAYMENT_MODE ||
      _paymentMode == OTHER_BLOCKCHAIN_PAYMENT_MODE);
  }

  /**
   * @dev Checks if payment mode is onchain
   *
   * @param _paymentMode bytes4
   */
  function _isOnchainPaymentMode(
    bytes4 _paymentMode
  ) internal pure returns (bool) {
    return (_paymentMode == NATIVE_PAYMENT_MODE ||
      _paymentMode == ERC20_PAYMENT_MODE);
  }

  /**
   * @dev Checks if origin kind is partner
   *
   * @param _originKind bytes4
   */
  function _isPartnerOrigin(bytes4 _originKind) internal pure returns (bool) {
    return (_originKind == PARTNER_ORIGIN_KIND);
  }

  /**
   * @dev Find the total sale price by matching payment mode of SaleOrder and BuyOrder
   *
   * @param _saleOrder SaleOrder
   * @param _buyOrder BuyOrder
   */
  function _findTotalSalePrice(
    SaleOrder calldata _saleOrder,
    BuyOrder calldata _buyOrder
  ) internal pure returns (uint256) {
    uint256 totalSalePrice = 0;

    // Find total sale price
    for (uint256 idx = 0; idx < _saleOrder.acceptedPaymentMode.length; idx++) {
      if (
        _saleOrder.acceptedPaymentMode[idx].paymentMode ==
        _buyOrder.paymentDetails.paymentMode
      ) {
        totalSalePrice = _saleOrder.acceptedPaymentMode[idx].price;
        break;
      }
    }

    return totalSalePrice;
  }
}