Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {INftfiHub} from "../interfaces/INftfiHub.sol";
import {LoanData} from "../loans/direct/loanTypes/LoanData.sol";
import {RefinancingAdapterRegistry} from "./refinancingAdapters/RefinancingAdapterRegistry.sol";
import {IRefinancingAdapter} from "./refinancingAdapters/IRefinancingAdapter.sol";
import {DirectLoanFixedOffer, ContractKeys} from "../loans/direct/loanTypes/DirectLoanFixedOffer.sol";
import {DirectLoanFixedCollectionOffer} from "../loans/direct/loanTypes/DirectLoanFixedCollectionOffer.sol";
import {DirectLoanCoordinator, IDirectLoanCoordinator} from "../loans/direct/DirectLoanCoordinator.sol";
import {Flashloan} from "./flashloan/Flashloan.sol";
import {NftReceiver} from "../utils/NftReceiver.sol";
import {INftWrapper} from "../interfaces/INftWrapper.sol";
import {IPermittedNFTs} from "../interfaces/IPermittedNFTs.sol";
import {SwapFlashloanWETH} from "./SwapFlashloanWETH.sol";

import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * @title  Refinancing
 * @author NFTfi
 * @notice
 */

/**
 * @title Refinancing
 *
 * @dev This smart contract is designed to manage the process of loan refinancing.
 * It allows borrowers to replace their current loans with new ones that have more favorable terms.
 * Each loan is identified by a unique identifier and associated with a refinanceable contract,
 * enabling tracking and management of loan refinancing details.
 *
 * @author NFTfi
 */
contract Refinancing is
    RefinancingAdapterRegistry,
    Flashloan,
    SwapFlashloanWETH,
    NftReceiver,
    Pausable,
    ReentrancyGuard
{
    using SafeERC20 for IERC20;

    // solhint-disable-next-line immutable-vars-naming
    INftfiHub public immutable hub;
    address public targetLoanFixedOfferContract;
    address public targetLoanCollectionOfferContract;

    enum TargetLoanType {
        LOAN_OFFER,
        COLLECTION_OFFER,
        COLLECTION_RANGE_OFFER
    }

    /**
     * @notice Struct to hold data necessary for a refinancing operation.
     *
     * @param loanIdentifier Numeric identifier of the loan to be refinanced.
     * @param refinanceableContract Address of the contract that supports the refinancing.
     */
    struct RefinancingData {
        uint256 loanIdentifier;
        address refinanceableContract;
    }

    uint32 private latestRefinancedLoanId;

    event Refinanced(address oldLoanContract, uint256 indexed oldLoanId, uint32 indexed newLoanId);

    error callerNotFlashloanContract();
    error flashloanInitiatorNotThisContract();
    error callerNotBorrowerOfOldLoan();
    error collateralNotOwned();
    error denominationMismatch();
    error unsupportedCollateral();
    error wrongTargetLoanType();

    /**
     * @notice Sets the admin of the contract.
     * Initializes `contractTypes` with a batch of loan types. Sets `NftfiHub`.
     * Initializes RefinancingAdapterRegistry and Flashloan contracts
     *
     * @param  _nftfiHub - Address of the NftfiHub contract
     * @param _targetLoanFixedOfferContract - Address of the target loan contract
     * @param _targetLoanCollectionOfferContract - Address of the target loan contract
     * @param _admin - Initial admin of this contract.
     * @param _definedRefinanceableTypes - Array of defined refinancing types
     * @param _refinancingAdapters - Array of addresses of the refinancing adapters
     * @param _refinanceableTypes - Array of refinancing types
     * @param _refinanceableContracts - Array of addresses of the refinancing contracts
     * @param _soloMargin - Address of the solo margin contract for flashloans
     * @param _flashloanFee - Fee for using a flashloan
     */
    constructor(
        address _nftfiHub,
        address _targetLoanFixedOfferContract,
        address _targetLoanCollectionOfferContract,
        address _admin,
        string[] memory _definedRefinanceableTypes,
        address[] memory _refinancingAdapters,
        string[] memory _refinanceableTypes,
        address[] memory _refinanceableContracts,
        address _soloMargin,
        uint256 _flashloanFee,
        SwapConstructorParams memory _swapContructorParams
    )
        RefinancingAdapterRegistry(
            _admin,
            _definedRefinanceableTypes,
            _refinancingAdapters,
            _refinanceableTypes,
            _refinanceableContracts
        )
        Flashloan(_soloMargin, _flashloanFee)
        SwapFlashloanWETH(_swapContructorParams)
    {
        hub = INftfiHub(_nftfiHub);
        targetLoanFixedOfferContract = _targetLoanFixedOfferContract;
        targetLoanCollectionOfferContract = _targetLoanCollectionOfferContract;
    }

    /**
     * @notice Function that's called back when flashloan is executed.
     * Decodes the data returned by the flashloan, then calls the internal
     * `_refinanceFlashloanCallback` function.
     * DyDx flashloan interface expects this function to exist
     *
     * this function is only the entry point of the operations happening in the callback,
     * it also serves to decode the callback data,
     * the main logic is implemented in _refinanceFlashloanCallback()
     *
     * @param _data - Byte array of data returned by the flashloan
     */
    function callFunction(address sender, AccountInfo memory, bytes memory _data) external override {
        if (address(soloMargin) != msg.sender) revert callerNotFlashloanContract();
        if (sender != address(this)) revert flashloanInitiatorNotThisContract();

        (
            address borrower,
            address payOffToken,
            uint256 payOffAmount,
            bool swapping,
            TargetLoanType targetLoanType,
            RefinancingData memory refinancingData,
            LoanData.Offer memory offer,
            LoanData.CollectionIdRange memory idRange,
            LoanData.Signature memory lenderSignature,
            LoanData.BorrowerSettings memory borrowerSettings
        ) = abi.decode(
                _data,
                (
                    address,
                    address,
                    uint256,
                    bool,
                    TargetLoanType,
                    RefinancingData,
                    LoanData.Offer,
                    LoanData.CollectionIdRange,
                    LoanData.Signature,
                    LoanData.BorrowerSettings
                )
            );

        _refinanceFlashloanCallback(
            borrower,
            payOffToken,
            payOffAmount,
            swapping,
            targetLoanType,
            refinancingData,
            offer,
            idRange,
            lenderSignature,
            borrowerSettings
        );
    }

    /**
     * @notice External function for refinancing a regular (non-collaction offer) loan,
     * sets targetType, and calls the internal _refinance(...) function
     *
     * @param _refinancingData - Data related to the refinancing loan
     * @param _offer - The loan offer details
     * @param _lenderSignature - Signature of the lender
     * @param _borrowerSettings - Settings related to the borrower
     */
    function refinanceLoan(
        RefinancingData memory _refinancingData,
        LoanData.Offer memory _offer,
        LoanData.Signature memory _lenderSignature,
        LoanData.BorrowerSettings memory _borrowerSettings
    ) external {
        TargetLoanType targetLoanType = TargetLoanType.LOAN_OFFER;
        LoanData.CollectionIdRange memory idRange;
        _refinance(targetLoanType, _refinancingData, _offer, idRange, _lenderSignature, _borrowerSettings);
    }

    /**
     * @notice External function for refinancing a collaction offer loan,
     * sets targetType, and calls the internal _refinance(...) function
     *
     * @param _refinancingData - Data related to the refinancing loan
     * @param _offer - The loan offer details
     * @param _lenderSignature - Signature of the lender
     * @param _borrowerSettings - Settings related to the borrower
     */
    function refinanceCollectionOfferLoan(
        RefinancingData memory _refinancingData,
        LoanData.Offer memory _offer,
        LoanData.Signature memory _lenderSignature,
        LoanData.BorrowerSettings memory _borrowerSettings
    ) external {
        TargetLoanType targetLoanType = TargetLoanType.COLLECTION_OFFER;
        LoanData.CollectionIdRange memory idRange;
        _refinance(targetLoanType, _refinancingData, _offer, idRange, _lenderSignature, _borrowerSettings);
    }

    /**
     * @notice External function for refinancing a collaction offer loan with id ranges,
     * sets targetType, and calls the internal _refinance(...) function
     *
     * @param _refinancingData - Data related to the refinancing loan
     * @param _offer - The loan offer details
     * @param _idRange - id range of collateral
     * @param _lenderSignature - Signature of the lender
     * @param _borrowerSettings - Settings related to the borrower
     */
    function refinanceCollectionRangeOfferLoan(
        RefinancingData memory _refinancingData,
        LoanData.Offer memory _offer,
        LoanData.CollectionIdRange memory _idRange,
        LoanData.Signature memory _lenderSignature,
        LoanData.BorrowerSettings memory _borrowerSettings
    ) external {
        TargetLoanType targetLoanType = TargetLoanType.COLLECTION_RANGE_OFFER;
        _refinance(targetLoanType, _refinancingData, _offer, _idRange, _lenderSignature, _borrowerSettings);
    }

    /**
     * @notice Internal function for initiating the loan refinance process.
     * Initiated by the borrower of the old refinancable if applicable and the new loan
     * From the standpoint of the lender this whole process can just be a regular loan,
     * the only caveat is that the collateral is locked in some refinancable protocol (loan, market).
     * If the old refinancable is a loan, borrower role transfer has to be approved
     * (eg erc-721 approve for obligation receipt) to this contract beforehand.
     * Checks the terms of the refinancing offer, verifies the borrower of the old loan,
     * pays off the old loan, creates a new loan offer and mints an Obligation Receipt Token.
     *
     * @param _targetLoanType - type of the refinancing target (enum)
     * @param _refinancingData - Data related to the refinancing loan
     * @param _offer - The loan offer details
     * @param _idRange - id range of collateral (only used if ranged type target loan)
     * @param _lenderSignature - Signature of the lender
     * @param _borrowerSettings - Settings related to the borrower
     */
    function _refinance(
        TargetLoanType _targetLoanType,
        RefinancingData memory _refinancingData,
        LoanData.Offer memory _offer,
        LoanData.CollectionIdRange memory _idRange,
        LoanData.Signature memory _lenderSignature,
        LoanData.BorrowerSettings memory _borrowerSettings
    ) internal whenNotPaused nonReentrant {
        address borrower;
        address payOffToken;
        uint256 flashloanAmount;
        bool swapping;

        {
            address refinancingAdapter = getRefinancingAdapter(_refinancingData.refinanceableContract);

            borrower = _getBorrowerAddress(
                refinancingAdapter,
                _refinancingData.refinanceableContract,
                _refinancingData.loanIdentifier
            );

            if (borrower != address(0)) {
                if (borrower != msg.sender) revert callerNotBorrowerOfOldLoan();
            } else {
                // in case of non loan refinancables, like opensea we dont need to check
                borrower = msg.sender;
            }

            uint256 payOffAmount;

            (payOffToken, payOffAmount) = _getPayoffDetails(
                refinancingAdapter,
                _refinancingData.refinanceableContract,
                _refinancingData.loanIdentifier
            );

            if (payOffToken != _offer.loanERC20Denomination) revert denominationMismatch();

            // take over old loan
            _transferBorrowerRole(
                refinancingAdapter,
                _refinancingData.refinanceableContract,
                _refinancingData.loanIdentifier
            );

            // if we have to swap tokens, to get a flashloan (no flashloan fot wstETH)
            (swapping, flashloanAmount) = _checkIfSwapNeededAndGetFlashloanParamters(payOffToken, payOffAmount);
        }

        {
            // take out flashloan
            // this will call back to callFunction()
            // inside callback:
            //   - pay off old loan
            //   - check collateral
            //   - start new loan
            _flashLoan(
                borrower,
                payOffToken,
                flashloanAmount,
                swapping,
                _targetLoanType,
                _refinancingData,
                _offer,
                _idRange,
                _lenderSignature,
                _borrowerSettings
            );
            // pay off flashloan (happens impicitly with a tranferFrom)
        }
        {
            uint256 refinancingSurplus = IERC20(payOffToken).balanceOf(address(this));
            if (refinancingSurplus > 0) {
                IERC20(payOffToken).safeTransfer(borrower, refinancingSurplus);
            }
        }

        emit Refinanced(
            _refinancingData.refinanceableContract,
            _refinancingData.loanIdentifier,
            latestRefinancedLoanId
        );

        _mintAndSendNewLoanObligationReceipt(borrower, _targetLoanType);
    }

    /**
     * @dev Callback function that executes the core logic of refinancing after obtaining a flashloan.
     * This includes paying off the old loan, validating ownership of the collateral,
     * and creating a new loan. The function handles token swaps if necessary and ensures
     * the flashloan is paid off with the appropriate fees.
     *
     * @param _borrower Address of the borrower initiating the refinance.
     * @param _payOffToken Address of the token used to pay off the old loan.
     * @param _flashloanAmount Amount of the flashloan taken out for refinancing.
     * @param _swapping Indicates whether token swapping is needed during the refinancing process.
     * @param _refinancingData Struct containing data relevant to the refinancing operation.
     * @param _offer Details of the new loan offer being initiated.
     * @param _lenderSignature Signature of the lender of the new loan.
     * @param _borrowerSettings Settings related to the borrower for the new loan.
     */
    function _refinanceFlashloanCallback(
        address _borrower,
        address _payOffToken,
        uint256 _flashloanAmount,
        bool _swapping,
        TargetLoanType _targetLoanType,
        RefinancingData memory _refinancingData,
        LoanData.Offer memory _offer,
        LoanData.CollectionIdRange memory _idRange,
        LoanData.Signature memory _lenderSignature,
        LoanData.BorrowerSettings memory _borrowerSettings
    ) internal {
        address refinancingAdapter = getRefinancingAdapter(_refinancingData.refinanceableContract);

        // query collateral
        (address collateralContract, uint256 collateralId) = _getCollateral(
            refinancingAdapter,
            _refinancingData.refinanceableContract,
            _refinancingData.loanIdentifier
        );

        {
            (address payBackToken, uint256 payBackAmount) = _getPayoffDetails(
                refinancingAdapter,
                _refinancingData.refinanceableContract,
                _refinancingData.loanIdentifier
            );

            if (_swapping) {
                _swapFromWeth(_payOffToken, payBackAmount);
            }

            // pay off old loan
            _payOffRefinancable(
                refinancingAdapter,
                _refinancingData.refinanceableContract,
                _refinancingData.loanIdentifier,
                payBackToken,
                payBackAmount
            );
        }

        // check collateral
        if (!_isNFTOwner(collateralContract, collateralId, address(this))) revert collateralNotOwned();

        // check if we are in deficit and get it from the borrower in that case
        _checkAndTransferDeficit(_borrower, _payOffToken, _flashloanAmount, _offer, _swapping);

        //approve nft to target loan to create the new loan
        _approveNFT(_getTargetLoanContract(_targetLoanType), collateralContract, collateralId);

        // start new loan
        latestRefinancedLoanId = _chooseAndStartLoan(
            _targetLoanType,
            _offer,
            _idRange,
            _lenderSignature,
            _borrowerSettings
        );

        if (_swapping) {
            _swapToWeth(_payOffToken, _flashloanAmount + flashloanFee);
            // we have to re-approve to soloMargin
            IERC20(wethAddress).approve(address(soloMargin), _flashloanAmount + flashloanFee);
        }
    }

    /**
     * @notice gets contract address of the target loan based on the _targetLoanType
     *
     * @param _targetLoanType - type of the refinancing target (enum)
     */
    function _getTargetLoanContract(TargetLoanType _targetLoanType) internal view returns (address) {
        if (_targetLoanType == TargetLoanType.LOAN_OFFER) {
            return targetLoanFixedOfferContract;
        } else if (_targetLoanType == TargetLoanType.COLLECTION_OFFER) {
            return targetLoanCollectionOfferContract;
        } else if (_targetLoanType == TargetLoanType.COLLECTION_RANGE_OFFER) {
            return targetLoanCollectionOfferContract;
        } else {
            revert wrongTargetLoanType();
        }
    }

    /**
     * @notice gets contract address of the target loan based on the _targetLoanType and starts the loan
     *
     * @param _targetLoanType - type of the refinancing target (enum)
     * @param _offer - The loan offer details
     * @param _idRange - id range of collateral (only used if ranged type target loan)
     * @param _lenderSignature - Signature of the lender
     * @param _borrowerSettings - Settings related to the borrower
     */
    function _chooseAndStartLoan(
        TargetLoanType _targetLoanType,
        LoanData.Offer memory _offer,
        LoanData.CollectionIdRange memory _idRange,
        LoanData.Signature memory _lenderSignature,
        LoanData.BorrowerSettings memory _borrowerSettings
    ) internal returns (uint32 loanId) {
        if (_targetLoanType == TargetLoanType.LOAN_OFFER) {
            loanId = _startLoan(_offer, _lenderSignature, _borrowerSettings);
        } else if (_targetLoanType == TargetLoanType.COLLECTION_OFFER) {
            loanId = _startCollectionOfferLoan(_offer, _lenderSignature, _borrowerSettings);
        } else if (_targetLoanType == TargetLoanType.COLLECTION_RANGE_OFFER) {
            loanId = _startCollectionRangeOfferLoan(_offer, _idRange, _lenderSignature, _borrowerSettings);
        } else {
            revert wrongTargetLoanType();
        }
    }

    /**
     * @notice initiates a regular (non-collaction offer) loan
     *
     * @param _offer - The loan offer details
     * @param _lenderSignature - Signature of the lender
     * @param _borrowerSettings - Settings related to the borrower
     */
    function _startLoan(
        LoanData.Offer memory _offer,
        LoanData.Signature memory _lenderSignature,
        LoanData.BorrowerSettings memory _borrowerSettings
    ) internal returns (uint32 loanId) {
        loanId = DirectLoanFixedOffer(targetLoanFixedOfferContract).acceptOffer(
            _offer,
            _lenderSignature,
            _borrowerSettings
        );
    }

    /**
     * @notice initiates a collaction offer loan
     *
     * @param _offer - The loan offer details
     * @param _lenderSignature - Signature of the lender
     * @param _borrowerSettings - Settings related to the borrower
     */
    function _startCollectionOfferLoan(
        LoanData.Offer memory _offer,
        LoanData.Signature memory _lenderSignature,
        LoanData.BorrowerSettings memory _borrowerSettings
    ) internal returns (uint32 loanId) {
        DirectLoanFixedCollectionOffer directLoanCollectionOffer = DirectLoanFixedCollectionOffer(
            targetLoanCollectionOfferContract
        );
        directLoanCollectionOffer.acceptCollectionOffer(_offer, _lenderSignature, _borrowerSettings);
        loanId = DirectLoanCoordinator(
            directLoanCollectionOffer.hub().getContract(directLoanCollectionOffer.LOAN_COORDINATOR())
        ).totalNumLoans();
    }

    /**
     * @notice initiates a collaction offer loan with ranges
     *
     * @param _offer - The loan offer details
     * @param _idRange - id range of collateral (only used if ranged type target loan)
     * @param _lenderSignature - Signature of the lender
     * @param _borrowerSettings - Settings related to the borrower
     */
    function _startCollectionRangeOfferLoan(
        LoanData.Offer memory _offer,
        LoanData.CollectionIdRange memory _idRange,
        LoanData.Signature memory _lenderSignature,
        LoanData.BorrowerSettings memory _borrowerSettings
    ) internal returns (uint32 loanId) {
        DirectLoanFixedCollectionOffer directLoanCollectionOffer = DirectLoanFixedCollectionOffer(
            targetLoanCollectionOfferContract
        );
        directLoanCollectionOffer.acceptCollectionOfferWithIdRange(
            _offer,
            _idRange,
            _lenderSignature,
            _borrowerSettings
        );
        loanId = DirectLoanCoordinator(
            directLoanCollectionOffer.hub().getContract(directLoanCollectionOffer.LOAN_COORDINATOR())
        ).totalNumLoans();
    }

    /**
     * @notice Checks if the flashloan payoff amount in the loan token is greater than the loan principal amount
     *         and transfers the deficit from the borrower to the contract.
     * @dev Used in the process of refinancing loans to handle the difference between the flashloan amount
     *      and the actual loan payoff amount.
     * @param _borrower Address of the borrower who needs to cover the deficit if any.
     * @param _payOffToken Address of the token that is used to pay off the loan.
     * @param _flashloanAmount The amount of tokens taken as a flashloan that needs to be covered.
     * @param _offer The loan offer data containing the principal amount of the loan.
     * @param _swapping A boolean indicating whether a swap operation is required.
     */
    function _checkAndTransferDeficit(
        address _borrower,
        address _payOffToken,
        uint256 _flashloanAmount,
        LoanData.Offer memory _offer,
        bool _swapping
    ) internal {
        uint256 flashloanPayoffAmountInLoanToken = _calculateFlashloanPayoffAmountInLoanToken(
            _payOffToken,
            _flashloanAmount,
            _swapping
        );
        if (flashloanPayoffAmountInLoanToken > _offer.loanPrincipalAmount) {
            uint256 refinancingDeficit = (flashloanPayoffAmountInLoanToken) - _offer.loanPrincipalAmount;
            IERC20(_payOffToken).safeTransferFrom(_borrower, address(this), refinancingDeficit);
        }
    }

    /**
     * @notice Calculates the flashloan payoff amount in the loan token.
     * @dev Considers whether a token swap is necessary due to differing token types for repayment.
     * @param _payOffToken Address of the token that is used to pay off the loan.
     * @param _flashloanAmount The amount of the loan taken as a flashloan.
     * @param _swapping A boolean indicating whether a token swap is needed.
     * @return flashloanPayoffAmountInLoanToken The calculated amount that must be paid off in the loan token.
     */
    function _calculateFlashloanPayoffAmountInLoanToken(
        address _payOffToken,
        uint256 _flashloanAmount,
        bool _swapping
    ) internal returns (uint256 flashloanPayoffAmountInLoanToken) {
        if (_swapping) {
            flashloanPayoffAmountInLoanToken = getTokenAmountNeeded(_payOffToken, _flashloanAmount + flashloanFee);
        } else {
            flashloanPayoffAmountInLoanToken = _flashloanAmount + flashloanFee;
        }
    }

    /**
     * @notice Determines if a token swap is needed for the flashloan repayment and calculates the flashloan amount.
     * @dev If the payoff token is not flashloanable, a swap to WETH is needed.
     * @param _payOffToken Address of the token to be used for paying off the loan.
     * @param _payOffAmount The amount needed to pay off the loan.
     * @return swapping Boolean indicating if a token swap is required.
     * @return flashloanAmount The amount required for the flashloan, considering any needed swap.
     */
    function _checkIfSwapNeededAndGetFlashloanParamters(
        address _payOffToken,
        uint256 _payOffAmount
    ) internal returns (bool swapping, uint256 flashloanAmount) {
        if (!tokenFlashloanble[_payOffToken]) {
            swapping = true;
            flashloanAmount = getWethAmountNeeded(_payOffToken, _payOffAmount); //swap fees included
        } else {
            swapping = false;
            flashloanAmount = _payOffAmount;
        }
    }

    /**
     * @notice Mints a new loan obligation receipt NFT and sends it to the borrower.
     * @dev The NFT represents the borrower's obligation after a loan has been refinanced.
     * @param _borrower Address of the borrower to whom the obligation receipt NFT will be sent.
     */
    function _mintAndSendNewLoanObligationReceipt(address _borrower, TargetLoanType _targetLoanType) internal {
        DirectLoanFixedOffer(_getTargetLoanContract(_targetLoanType)).mintObligationReceipt(latestRefinancedLoanId);
        DirectLoanFixedOffer directLoanFixedOffer = DirectLoanFixedOffer(_getTargetLoanContract(_targetLoanType));
        IDirectLoanCoordinator coordinator = IDirectLoanCoordinator(
            directLoanFixedOffer.hub().getContract(directLoanFixedOffer.LOAN_COORDINATOR())
        );
        uint64 smartNftId = coordinator.getLoanData(latestRefinancedLoanId).smartNftId;
        IERC721 obligationReceiptToken = IERC721(coordinator.obligationReceiptToken());
        obligationReceiptToken.safeTransferFrom(address(this), _borrower, smartNftId);
    }

    /**
     * @notice Transfers the role of borrower to a new borrower.
     * (only applicable to loan type refinancables, not markets)
     * This is a call to the adapter, which handles several types of refinancables trough an adapter
     *
     * @param _refinancingAdapter - Address of the refinancing adapter contract
     * @param _refinanceableContract - Address of the refinanceable contract
     * @param _loanIdentifier - Identifier of the loan
     */
    function _transferBorrowerRole(
        address _refinancingAdapter,
        address _refinanceableContract,
        uint256 _loanIdentifier
    ) private {
        Address.functionDelegateCall(
            _refinancingAdapter,
            abi.encodeWithSelector(
                IRefinancingAdapter(_refinancingAdapter).transferBorrowerRole.selector,
                _refinanceableContract,
                _loanIdentifier
            ),
            "transferBorrowerRole error"
        );
    }

    /**
     * @notice Pays back the refinancable
     * This is a call to the adapter, which handles several types of refinancables trough an adapter
     *
     * @param _refinancingAdapter - Address of the refinancing adapter contract
     * @param _refinanceableContract - Address of the refinanceable contract
     * @param _loanIdentifier - Identifier of the loan
     * @param _payBackToken - Address of the token used for paying back
     * @param _payBackAmount - The amount required to pay back the loan
     */
    function _payOffRefinancable(
        address _refinancingAdapter,
        address _refinanceableContract,
        uint256 _loanIdentifier,
        address _payBackToken,
        uint256 _payBackAmount
    ) private {
        Address.functionDelegateCall(
            _refinancingAdapter,
            abi.encodeWithSelector(
                IRefinancingAdapter(_refinancingAdapter).payOffRefinancable.selector,
                _refinanceableContract,
                _loanIdentifier,
                _payBackToken,
                _payBackAmount
            ),
            "payBackloan error"
        );
    }

    /**
     * @notice Retrieves the borrower's address of a specific refinancable.
     * (only applicable to loan type refinancables, not markets)
     * This is a call to the adapter, which handles several types of refinancables trough an adapter
     *
     * @param _refinancingAdapter - Address of the refinancing adapter contract
     * @param _refinanceableContract - Address of the refinanceable contract
     * @param _loanIdentifier - Identifier of the loan
     * @return Address of the borrower
     */
    function _getBorrowerAddress(
        address _refinancingAdapter,
        address _refinanceableContract,
        uint256 _loanIdentifier
    ) private returns (address) {
        bytes memory returnData = Address.functionDelegateCall(
            _refinancingAdapter,
            abi.encodeWithSelector(
                IRefinancingAdapter(_refinancingAdapter).getBorrowerAddress.selector,
                _refinanceableContract,
                _loanIdentifier
            ),
            "getBorrowerAddress error"
        );

        return abi.decode(returnData, (address));
    }

    /**
     * @notice Retrieves the collateral details of a specific refinancable.
     * This is a call to the adapter, which handles several types of refinancables trough an adapter
     *
     * @param _refinancingAdapter - Address of the refinancing adapter contract
     * @param _refinanceableContract - Address of the refinanceable contract
     * @param _loanIdentifier - Identifier of the loan
     * @return Address of the collateral contract, Identifier of the collateral
     */
    function _getCollateral(
        address _refinancingAdapter,
        address _refinanceableContract,
        uint256 _loanIdentifier
    ) private returns (address, uint256) {
        bytes memory returnData = Address.functionDelegateCall(
            _refinancingAdapter,
            abi.encodeWithSelector(
                IRefinancingAdapter(_refinancingAdapter).getCollateral.selector,
                _refinanceableContract,
                _loanIdentifier
            ),
            "getCollateral error"
        );

        return abi.decode(returnData, (address, uint256));
    }

    /**
     * @notice Retrieves the details related to the payoff of a specific refinancable, the payment token and amount
     * This is a call to the adapter, which handles several types of refinancables trough an adapter
     *
     * @param _refinancingAdapter - Address of the refinancing adapter contract
     * @param _refinanceableContract - Address of the refinanceable contract
     * @param _loanIdentifier - Identifier of the loan
     * @return Address of the payoff token, Amount required to pay off the loan
     */
    function _getPayoffDetails(
        address _refinancingAdapter,
        address _refinanceableContract,
        uint256 _loanIdentifier
    ) private returns (address, uint256) {
        bytes memory returnData = Address.functionDelegateCall(
            _refinancingAdapter,
            abi.encodeWithSelector(
                IRefinancingAdapter(_refinancingAdapter).getPayoffDetails.selector,
                _refinanceableContract,
                _loanIdentifier
            ),
            "getPayoffDetails error"
        );

        return abi.decode(returnData, (address, uint256));
    }

    /**
     * @dev Checks if a specified address is the owner of an NFT trough the NFT adaptor.
     *
     * @param _nftCollateralContract - The contract address of the NFT.
     * @param _nftCollateralId - The token ID of the NFT.
     * @param _owner - The address to check ownership against.
     *
     * @return bool - Returns true if the specified address is the owner of the NFT.
     */
    function _isNFTOwner(
        address _nftCollateralContract,
        uint256 _nftCollateralId,
        address _owner
    ) internal returns (bool) {
        address nftCollateralWrapper = _getWrapper(_nftCollateralContract);

        bytes memory result = Address.functionDelegateCall(
            nftCollateralWrapper,
            abi.encodeWithSelector(
                INftWrapper(nftCollateralWrapper).isOwner.selector,
                _owner,
                _nftCollateralContract,
                _nftCollateralId
            ),
            "NFT ownership check not successful"
        );

        return abi.decode(result, (bool));
    }

    /**
     * @dev Approves an NFT to be used by another address trough the NFT adaptor.
     *
     * @param _to - The address to approve to transfer or manage the NFT.
     * @param _nftCollateralContract - The contract address of the NFT.
     * @param _nftCollateralId - The token ID of the NFT.
     *
     * @return bool - Returns true if the approval was successful.
     */
    function _approveNFT(
        address _to,
        address _nftCollateralContract,
        uint256 _nftCollateralId
    ) internal returns (bool) {
        address nftCollateralWrapper = _getWrapper(_nftCollateralContract);

        bytes memory result = Address.functionDelegateCall(
            nftCollateralWrapper,
            abi.encodeWithSelector(
                INftWrapper(nftCollateralWrapper).approveNFT.selector,
                _to,
                _nftCollateralContract,
                _nftCollateralId
            ),
            "NFT not successfully approved"
        );

        return abi.decode(result, (bool));
    }

    /**
     * @dev Checks that the collateral is a supported contracts and returns what wrapper to use for the loan's NFT
     * collateral contract.
     *
     * @param _nftCollateralContract - The address of the the NFT collateral contract.
     *
     * @return Address of the NftWrapper to use for the loan's NFT collateral.
     */
    function _getWrapper(address _nftCollateralContract) internal view returns (address) {
        return IPermittedNFTs(hub.getContract(ContractKeys.PERMITTED_NFTS)).getNFTWrapper(_nftCollateralContract);
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - Only the owner can call this method.
     * - The contract must not be paused.
     */
    function pause() external onlyOwner {
        _pause();
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - Only the owner can call this method.
     * - The contract must be paused.
     */
    function unpause() external onlyOwner {
        _unpause();
    }

    /**
     * @dev Sets the fee for flash loans.
     * @param _flashloanFee The fee percentage for flash loans.
     */
    function setFlashloanFee(uint256 _flashloanFee) public onlyOwner {
        flashloanFee = _flashloanFee;
    }

    /**
     * @dev Sets the target loan contract address
     * @param _targetLoanFixedOfferContract The address of the target loan contract.
     */
    function setTargetLoanFixedOfferContract(address _targetLoanFixedOfferContract) public onlyOwner {
        targetLoanFixedOfferContract = _targetLoanFixedOfferContract;
    }

    /**
     * @dev Sets the target loan collection offer contract address
     * @param _targetLoanCollectionOfferContract The address of the target loan contract.
     */
    function settargetLoanCollectionOfferContract(address _targetLoanCollectionOfferContract) public onlyOwner {
        targetLoanCollectionOfferContract = _targetLoanCollectionOfferContract;
    }

    /**
     * @dev Sets the swap fee rates for multiple supported tokens in batch.
     * @param _supportedTokens An array of addresses of the supported tokens.
     * @param _swapFeeRates An array of corresponding swap fee rates for each supported token.
     */
    function setSupportedTokenSwapFeeRates(
        address[] memory _supportedTokens,
        uint24[] memory _swapFeeRates
    ) external onlyOwner {
        _setSupportedTokenFeeRates(_supportedTokens, _swapFeeRates);
    }

    /**
     * @dev Sets the swap fee rate for a single supported token.
     * @param _supportedToken The address of the supported token.
     * @param _swapFeeRate The swap fee rate for the specified supported token.
     */
    function setSupportedTokenSwapFeeRate(address _supportedToken, uint24 _swapFeeRate) external onlyOwner {
        _setSupportedTokenFeeRate(_supportedToken, _swapFeeRate);
    }

    /**
     * @dev Returns the coordinator address of the target loan(s), convenience function to make it
     * easier finding the loan contract based on a newLoanId from the event
     * @return coordinator address
     */
    function getTargetCoordinator() public view returns (address) {
        DirectLoanFixedOffer directLoanfixedOffer = DirectLoanFixedOffer(targetLoanFixedOfferContract);
        return directLoanfixedOffer.hub().getContract(directLoanfixedOffer.LOAN_COORDINATOR());
    }
}

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

pragma solidity ^0.8.0;

import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```solidity
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```solidity
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(account),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 *
 * _Available since v4.1._
 */
interface IERC1271 {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

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

pragma solidity ^0.8.0;

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

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

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

    bool private _paused;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

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

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

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

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not token owner or approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
        _safeTransfer(from, to, tokenId, data);
    }

    /**
     * @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.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _ownerOf(tokenId) != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId, 1);

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant
     * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such
     * that `ownerOf(tokenId)` is `a`.
     */
    // solhint-disable-next-line func-name-mixedcase
    function __unsafe_increaseBalance(address account, uint256 amount) internal {
        _balances[account] += amount;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/utils/ERC721Holder.sol)

pragma solidity ^0.8.0;

import "../IERC721Receiver.sol";

/**
 * @dev Implementation of the {IERC721Receiver} interface.
 *
 * Accepts all token transfers.
 * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}.
 */
contract ERC721Holder is IERC721Receiver {
    /**
     * @dev See {IERC721Receiver-onERC721Received}.
     *
     * Always returns `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(address, address, uint256, bytes memory) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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://consensys.net/diligence/blog/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.8.0/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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @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,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

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

pragma solidity ^0.8.0;

import "../Strings.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 ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    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");
        }
    }

    /**
     * @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 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 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @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", Strings.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 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

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

pragma solidity ^0.8.0;

import "./ECDSA.sol";
import "../../interfaces/IERC1271.sol";

/**
 * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
 * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
 * Argent and Gnosis Safe.
 *
 * _Available since v4.1._
 */
library SignatureChecker {
    /**
     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
     * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
        (address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(hash, signature);
        return
            (error == ECDSA.RecoverError.NoError && recovered == signer) ||
            isValidERC1271SignatureNow(signer, hash, signature);
    }

    /**
     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
     * against the signer smart contract using ERC1271.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidERC1271SignatureNow(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) internal view returns (bool) {
        (bool success, bytes memory result) = signer.staticcall(
            abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
        );
        return (success &&
            result.length >= 32 &&
            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
    }
}

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

pragma solidity ^0.8.0;

import "./IERC165.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 ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// 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
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

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

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _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) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @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] = _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);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Callback for IUniswapV3PoolActions#swap
/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
interface IUniswapV3SwapCallback {
    /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
    /// @dev In the implementation you must pay the pool tokens owed for the swap.
    /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
    /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
    /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
    /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
    /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

/// @title Quoter Interface
/// @notice Supports quoting the calculated amounts from exact input or exact output swaps
/// @dev These functions are not marked view because they rely on calling non-view functions and reverting
/// to compute the result. They are also not gas efficient and should not be called on-chain.
interface IQuoter {
    /// @notice Returns the amount out received for a given exact input swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee
    /// @param amountIn The amount of the first token to swap
    /// @return amountOut The amount of the last token that would be received
    function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut);

    /// @notice Returns the amount out received for a given exact input but for a swap of a single pool
    /// @param tokenIn The token being swapped in
    /// @param tokenOut The token being swapped out
    /// @param fee The fee of the token pool to consider for the pair
    /// @param amountIn The desired input amount
    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountOut The amount of `tokenOut` that would be received
    function quoteExactInputSingle(
        address tokenIn,
        address tokenOut,
        uint24 fee,
        uint256 amountIn,
        uint160 sqrtPriceLimitX96
    ) external returns (uint256 amountOut);

    /// @notice Returns the amount in required for a given exact output swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee. Path must be provided in reverse order
    /// @param amountOut The amount of the last token to receive
    /// @return amountIn The amount of first token required to be paid
    function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn);

    /// @notice Returns the amount in required to receive the given exact output amount but for a swap of a single pool
    /// @param tokenIn The token being swapped in
    /// @param tokenOut The token being swapped out
    /// @param fee The fee of the token pool to consider for the pair
    /// @param amountOut The desired output amount
    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountIn The amount required as the input for the swap in order to receive `amountOut`
    function quoteExactOutputSingle(
        address tokenIn,
        address tokenOut,
        uint24 fee,
        uint256 amountOut,
        uint160 sqrtPriceLimitX96
    ) external returns (uint256 amountIn);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import '@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol';

/// @title Router token swapping functionality
/// @notice Functions for swapping tokens via Uniswap V3
interface ISwapRouter is IUniswapV3SwapCallback {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);

    struct ExactInputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);

    struct ExactOutputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);

    struct ExactOutputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

/**
 * @title IDirectLoanCoordinator
 * @author NFTfi
 * @dev DirectLoanCoordinator interface.
 */
interface IDirectLoanCoordinator {
    enum StatusType {
        NOT_EXISTS,
        NEW,
        REPAID,
        LIQUIDATED
    }

    /**
     * @notice This struct contains data related to a loan
     *
     * @param smartNftId - The id of both the promissory note and obligation receipt.
     * @param status - The status in which the loan currently is.
     * @param loanContract - Address of the LoanType contract that created the loan.
     */
    struct Loan {
        address loanContract;
        uint64 smartNftId;
        StatusType status;
    }

    function registerLoan(address _lender, bytes32 _loanType) external returns (uint32);

    function resetSmartNfts(uint32 _loanId, address _borrower) external;

    function mintObligationReceipt(uint32 _loanId, address _borrower) external;

    function resolveLoan(uint32 _loanId, bool liquidated) external;

    function promissoryNoteToken() external view returns (address);

    function obligationReceiptToken() external view returns (address);

    function getLoanData(uint32 _loanId) external view returns (Loan memory);

    function isValidLoanId(uint32 _loanId, address _loanContract) external view returns (bool);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

/**
 * @title INftfiHub
 * @author NFTfi
 * @dev NftfiHub interface
 */
interface INftfiHub {
    function setContract(string calldata _contractKey, address _contractAddress) external;

    function getContract(bytes32 _contractKey) external view returns (address);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

/**
 * @title INftTypeRegistry
 * @author NFTfi
 * @dev Interface for NFT Wrappers.
 */
interface INftWrapper {
    function transferNFT(address from, address to, address nftContract, uint256 tokenId) external returns (bool);

    function approveNFT(address to, address nftContract, uint256 tokenId) external returns (bool);

    function isOwner(address owner, address nftContract, uint256 tokenId) external view returns (bool);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

interface IPermittedERC20s {
    function getERC20Permit(address _erc20) external view returns (bool);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

interface IPermittedNFTs {
    function setNFTPermit(address _nftContract, string memory _nftType) external;

    function getNFTPermit(address _nftContract) external view returns (bytes32);

    function getNFTWrapper(address _nftContract) external view returns (address);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

interface IPermittedPartners {
    function getPartnerPermit(address _partner) external view returns (uint16);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {Ownable} from "../utils/Ownable.sol";
import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * @title  BaseLoan
 * @author NFTfi
 * @dev Implements base functionalities common to all Loan types.
 * Mostly related to governance and security.
 */
abstract contract BaseLoan is Ownable, Pausable, ReentrancyGuard {
    /* *********** */
    /* CONSTRUCTOR */
    /* *********** */

    /**
     * @notice Sets the admin of the contract.
     *
     * @param _admin - Initial admin of this contract.
     */
    constructor(address _admin) Ownable(_admin) {
        // solhint-disable-previous-line no-empty-blocks
    }

    /* ********* */
    /* FUNCTIONS */
    /* ********* */

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - Only the owner can call this method.
     * - The contract must not be paused.
     */
    function pause() external onlyOwner {
        _pause();
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - Only the owner can call this method.
     * - The contract must be paused.
     */
    function unpause() external onlyOwner {
        _unpause();
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {SmartNft} from "../../smartNft/SmartNft.sol";
import {IDirectLoanCoordinator} from "../../interfaces/IDirectLoanCoordinator.sol";
import {INftfiHub} from "../../interfaces/INftfiHub.sol";
import {Ownable} from "../../utils/Ownable.sol";
import {ContractKeys} from "../../utils/ContractKeys.sol";

/**
 * @title  DirectLoanCoordinator
 * @author NFTfi
 * @notice This contract is in charge of coordinating the creation, disctubution and desctruction of the SmartNfts
 * related to a loan, the Promossory Note and Obligaiton Receipt.
 */
contract DirectLoanCoordinator is IDirectLoanCoordinator, Ownable {
    /* ******* */
    /* STORAGE */
    /* ******* */

    // solhint-disable-next-line immutable-vars-naming
    INftfiHub public immutable hub;

    /**
     * @dev For each loan type, records the address of the contract that implements the type
     */
    mapping(bytes32 => address) private typeContracts;
    /**
     * @dev reverse mapping of loanTypes - for each contract address, records the associated loan type
     */
    mapping(address => bytes32) private contractTypes;

    /**
     * @notice A continuously increasing counter that simultaneously allows every loan to have a unique ID and provides
     * a running count of how many loans have been started by this contract.
     */
    uint32 public totalNumLoans = 0;

    uint32 public smartNftIdCounter = 0;

    // The address that deployed this contract
    // solhint-disable-next-line immutable-vars-naming
    address private immutable _deployer;
    bool private _initialized = false;

    mapping(uint32 => Loan) private loans;

    address public override promissoryNoteToken;
    address public override obligationReceiptToken;

    /* ****** */
    /* EVENTS */
    /* ****** */

    event UpdateStatus(
        uint32 indexed loanId,
        uint64 indexed smartNftId,
        address indexed loanContract,
        StatusType newStatus
    );

    /**
     * @notice This event is fired whenever the admins register a loan type.
     *
     * @param loanType - Loan type represented by keccak256('loan type').
     * @param loanContract - Address of the loan type contract.
     */
    event TypeUpdated(bytes32 indexed loanType, address indexed loanContract);

    /**
     * @dev Function using this modifier can only be executed after this contract is initialized
     *
     */
    modifier onlyInitialized() {
        // solhint-disable-next-line custom-errors
        require(_initialized, "not initialized");

        _;
    }

    /* *********** */
    /* CONSTRUCTOR */
    /* *********** */

    /**
     * @notice Sets the admin of the contract.
     * Initializes `contractTypes` with a batch of loan types. Sets `NftfiHub`.
     *
     * @param  _nftfiHub - Address of the NftfiHub contract
     * @param _admin - Initial admin of this contract.
     * @param _loanTypes - Loan types represented by keccak256('loan type').
     * @param _loanContracts - The addresses of each wrapper contract that implements the loan type's behaviour.
     */
    constructor(
        address _nftfiHub,
        address _admin,
        string[] memory _loanTypes,
        address[] memory _loanContracts
    ) Ownable(_admin) {
        hub = INftfiHub(_nftfiHub);
        _deployer = msg.sender;
        _registerLoanTypes(_loanTypes, _loanContracts);
    }

    /**
     * @dev Sets `promissoryNoteToken` and `obligationReceiptToken`.
     * It can be executed once by the deployer.
     *
     * @param  _promissoryNoteToken - Promissory Note Token address
     * @param  _obligationReceiptToken - Obligaiton Recipt Token address
     */
    function initialize(address _promissoryNoteToken, address _obligationReceiptToken) external {
        // solhint-disable-next-line custom-errors
        require(msg.sender == _deployer, "only deployer");
        // solhint-disable-next-line custom-errors
        require(!_initialized, "already initialized");
        // solhint-disable-next-line custom-errors
        require(_promissoryNoteToken != address(0), "promissoryNoteToken is zero");
        // solhint-disable-next-line custom-errors
        require(_obligationReceiptToken != address(0), "obligationReceiptToken is zero");

        _initialized = true;
        promissoryNoteToken = _promissoryNoteToken;
        obligationReceiptToken = _obligationReceiptToken;
    }

    /**
     * @dev This is called by the LoanType beginning the new loan.
     * It initialize the new loan data, mints both PromissoryNote and ObligationReceipt SmartNft's and returns the
     * new loan id.
     *
     * @param _lender - Address of the lender
     * @param _loanType - The type of the loan
     */
    function registerLoan(address _lender, bytes32 _loanType) external override onlyInitialized returns (uint32) {
        address loanContract = msg.sender;

        // solhint-disable-next-line custom-errors
        require(getContractFromType(_loanType) == loanContract, "Caller must be registered for loan type");

        // (loanIds start at 1)
        totalNumLoans += 1;
        smartNftIdCounter += 1;

        uint64 smartNftId = uint64(uint256(keccak256(abi.encodePacked(address(this), smartNftIdCounter))));

        Loan memory newLoan = Loan({status: StatusType.NEW, loanContract: loanContract, smartNftId: smartNftId});

        // Issue an ERC721 promissory note to the lender that gives them the
        // right to either the principal-plus-interest or the collateral.
        SmartNft(promissoryNoteToken).mint(_lender, smartNftId, abi.encode(totalNumLoans));

        loans[totalNumLoans] = newLoan;

        emit UpdateStatus(totalNumLoans, smartNftId, loanContract, StatusType.NEW);

        return totalNumLoans;
    }

    function mintObligationReceipt(uint32 _loanId, address _borrower) external override onlyInitialized {
        address loanContract = msg.sender;

        // solhint-disable-next-line custom-errors
        require(getTypeFromContract(loanContract) != bytes32(0), "Caller must a be registered loan type");

        uint64 smartNftId = loans[_loanId].smartNftId;
        // solhint-disable-next-line custom-errors
        require(smartNftId != 0, "loan doesn't exist");
        // solhint-disable-next-line custom-errors
        require(SmartNft(promissoryNoteToken).exists(smartNftId), "Promissory note should exist");
        // solhint-disable-next-line custom-errors
        require(!SmartNft(obligationReceiptToken).exists(smartNftId), "Obligation r shouldn't exist");

        // Issue an ERC721 obligation receipt to the borrower that gives them the
        // right to pay back the loan and get the collateral back.
        SmartNft(obligationReceiptToken).mint(_borrower, smartNftId, abi.encode(_loanId));
    }

    function resetSmartNfts(uint32 _loanId, address _lender) external override onlyInitialized {
        address loanContract = msg.sender;
        // solhint-disable-next-line custom-errors
        require(getTypeFromContract(loanContract) != bytes32(0), "Caller must a be registered loan type");

        uint64 oldSmartNftId = loans[_loanId].smartNftId;
        // solhint-disable-next-line custom-errors
        require(oldSmartNftId != 0, "loan doesn't exist");
        // solhint-disable-next-line custom-errors
        require(SmartNft(promissoryNoteToken).exists(oldSmartNftId), "Promissory note should exist");

        SmartNft(promissoryNoteToken).burn(oldSmartNftId);

        // (loanIds start at 1)
        smartNftIdCounter += 1;
        uint64 newSmartNftId = uint64(uint256(keccak256(abi.encodePacked(address(this), smartNftIdCounter))));
        SmartNft(promissoryNoteToken).mint(_lender, newSmartNftId, abi.encode(_loanId));
        loans[_loanId].smartNftId = newSmartNftId;

        if (SmartNft(obligationReceiptToken).exists(oldSmartNftId)) {
            SmartNft(obligationReceiptToken).burn(oldSmartNftId);
        }
    }

    /**
     * @dev This is called by the LoanType who created the loan, when a loan is resolved whether by paying back or
     * liquidating the loan.
     * It sets the loan as `RESOLVED` and burns both PromossoryNote and ObligationReceipt SmartNft's.
     *
     * @param _loanId - Id of the loan
     */
    function resolveLoan(uint32 _loanId, bool _repaid) external override onlyInitialized {
        Loan storage loan = loans[_loanId];
        // solhint-disable-next-line custom-errors
        require(loan.status == StatusType.NEW, "Loan status must be New");
        // solhint-disable-next-line custom-errors
        require(loan.loanContract == msg.sender, "Not the same Contract that registered Loan");

        if (_repaid) {
            loan.status = StatusType.REPAID;
        } else {
            loan.status = StatusType.LIQUIDATED;
        }

        SmartNft(promissoryNoteToken).burn(loan.smartNftId);
        if (SmartNft(obligationReceiptToken).exists(loan.smartNftId)) {
            SmartNft(obligationReceiptToken).burn(loan.smartNftId);
        }

        emit UpdateStatus(_loanId, loan.smartNftId, msg.sender, loan.status);
    }

    /**
     * @dev Returns loan's data for a given id.
     *
     * @param _loanId - Id of the loan
     */
    function getLoanData(uint32 _loanId) external view override returns (Loan memory) {
        return loans[_loanId];
    }

    /**
     * @dev checks if the given id is valid for the given loan contract address
     * @param _loanId - Id of the loan
     * @param _loanContract - address og the loan contract
     */
    function isValidLoanId(uint32 _loanId, address _loanContract) external view override returns (bool validity) {
        validity = loans[_loanId].loanContract == _loanContract;
    }

    /**
     * @notice  Set or update the contract address that implements the given Loan Type.
     * Set address(0) for a loan type for un-register such type.
     *
     * @param _loanType - Loan type represented by 'loan type'.
     * @param _loanContract - The address of the wrapper contract that implements the loan type's behaviour.
     */
    function registerLoanType(string memory _loanType, address _loanContract) external onlyOwner {
        _registerLoanType(_loanType, _loanContract);
    }

    /**
     * @notice  Batch set or update the contract addresses that implement the given batch Loan Type.
     * Set address(0) for a loan type for un-register such type.
     *
     * @param _loanTypes - Loan types represented by 'loan type'.
     * @param _loanContracts - The addresses of each wrapper contract that implements the loan type's behaviour.
     */
    function registerLoanTypes(string[] memory _loanTypes, address[] memory _loanContracts) external onlyOwner {
        _registerLoanTypes(_loanTypes, _loanContracts);
    }

    /**
     * @notice This function can be called by anyone to get the contract address that implements the given loan type.
     *
     * @param  _loanType - The loan type, e.g. bytes32("DIRECT_LOAN_FIXED"), or bytes32("DIRECT_LOAN_PRO_RATED").
     */
    function getContractFromType(bytes32 _loanType) public view returns (address) {
        return typeContracts[_loanType];
    }

    /**
     * @notice This function can be called by anyone to get the loan type of the given contract address.
     *
     * @param  _loanContract - The loan contract
     */
    function getTypeFromContract(address _loanContract) public view returns (bytes32) {
        return contractTypes[_loanContract];
    }

    /**
     * @notice  Set or update the contract address that implements the given Loan Type.
     * Set address(0) for a loan type for un-register such type.
     *
     * @param _loanType - Loan type represented by 'loan type').
     * @param _loanContract - The address of the wrapper contract that implements the loan type's behaviour.
     */
    function _registerLoanType(string memory _loanType, address _loanContract) internal {
        // solhint-disable-next-line custom-errors
        require(bytes(_loanType).length != 0, "loanType is empty");
        bytes32 loanTypeKey = ContractKeys.getIdFromStringKey(_loanType);

        typeContracts[loanTypeKey] = _loanContract;
        contractTypes[_loanContract] = loanTypeKey;

        emit TypeUpdated(loanTypeKey, _loanContract);
    }

    /**
     * @notice  Batch set or update the contract addresses that implement the given batch Loan Type.
     * Set address(0) for a loan type for un-register such type.
     *
     * @param _loanTypes - Loan types represented by keccak256('loan type').
     * @param _loanContracts - The addresses of each wrapper contract that implements the loan type's behaviour.
     */
    function _registerLoanTypes(string[] memory _loanTypes, address[] memory _loanContracts) internal {
        // solhint-disable-next-line custom-errors
        require(_loanTypes.length == _loanContracts.length, "function information arity mismatch");

        for (uint256 i; i < _loanTypes.length; ++i) {
            _registerLoanType(_loanTypes[i], _loanContracts[i]);
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {IDirectLoanBase} from "./IDirectLoanBase.sol";
import {LoanData} from "./LoanData.sol";
import {LoanChecksAndCalculations} from "./LoanChecksAndCalculations.sol";
import {BaseLoan} from "../../BaseLoan.sol";
import {NftReceiver} from "../../../utils/NftReceiver.sol";
import {NFTfiSigningUtils} from "../../../utils/NFTfiSigningUtils.sol";
import {INftfiHub} from "../../../interfaces/INftfiHub.sol";
import {ContractKeys} from "../../../utils/ContractKeys.sol";
import {IDirectLoanCoordinator} from "../../../interfaces/IDirectLoanCoordinator.sol";
import {INftWrapper} from "../../../interfaces/INftWrapper.sol";
import {IPermittedERC20s} from "../../../interfaces/IPermittedERC20s.sol";
import {IPermittedNFTs} from "../../../interfaces/IPermittedNFTs.sol";

import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/**
 * @title  DirectLoanBase
 * @author NFTfi
 * @notice Main contract for NFTfi Direct Loans Type. This contract manages the ability to create NFT-backed
 * peer-to-peer loans.
 *
 * There are two ways to commence an NFT-backed loan:
 *
 * a. The borrower accepts a lender's offer by calling `acceptOffer`.
 *   1. the borrower calls nftContract.approveAll(NFTfi), approving the NFTfi contract to move their NFT's on their
 * be1alf.
 *   2. the lender calls erc20Contract.approve(NFTfi), allowing NFTfi to move the lender's ERC20 tokens on their
 * behalf.
 *   3. the lender signs an off-chain message, proposing its offer terms.
 *   4. the borrower calls `acceptOffer` to accept these terms and enter into the loan. The NFT is stored in
 * the contract, the borrower receives the loan principal in the specified ERC20 currency, the lender receives an
 * NFTfi promissory note (in ERC721 form) that represents the rights to either the principal-plus-interest, or the
 * underlying NFT collateral if the borrower does not pay back in time, and the borrower receives obligation receipt
 * (in ERC721 form) that gives them the right to pay back the loan and get the collateral back.
 *
 * The lender can freely transfer and trade this ERC721 promissory note as they wish, with the knowledge that
 * transferring the ERC721 promissory note tranfsers the rights to principal-plus-interest and/or collateral, and that
 * they will no longer have a claim on the loan. The ERC721 promissory note itself represents that claim.
 *
 * The borrower can freely transfer and trade this ERC721 obligaiton receipt as they wish, with the knowledge that
 * transferring the ERC721 obligaiton receipt tranfsers the rights right to pay back the loan and get the collateral
 * back.
 *
 * A loan may end in one of two ways:
 * - First, a borrower may call NFTfi.payBackLoan() and pay back the loan plus interest at any time, in which case they
 * receive their NFT back in the same transaction.
 * - Second, if the loan's duration has passed and the loan has not been paid back yet, a lender can call
 * NFTfi.liquidateOverdueLoan(), in which case they receive the underlying NFT collateral and forfeit the rights to the
 * principal-plus-interest, which the borrower now keeps.
 *
 *
 * If the loan was created as a ProRated type loan (pro-rata interest loan), then the user only pays the principal plus
 * pro-rata interest if repaid early.
 * However, if the loan was was created as a Fixed type loan (agreed to be a fixed-repayment loan), then the borrower
 * pays the maximumRepaymentAmount regardless of whether they repay early or not.
 *
 */
abstract contract DirectLoanBaseMinimal is IDirectLoanBase, IPermittedERC20s, BaseLoan, NftReceiver, LoanData {
    using SafeERC20 for IERC20;

    /* ******* */
    /* STORAGE */
    /* ******* */

    uint16 public constant HUNDRED_PERCENT = 10000;

    // solhint-disable-next-line immutable-vars-naming
    bytes32 public immutable override LOAN_COORDINATOR;

    /**
     * @notice The maximum duration of any loan started for this loan type, measured in seconds. This is both a
     * sanity-check for borrowers and an upper limit on how long admins will have to support v1 of this contract if they
     * eventually deprecate it, as well as a check to ensure that the loan duration never exceeds the space alotted for
     * it in the loan struct.
     */
    uint256 public override maximumLoanDuration = 53 weeks;

    /**
     * @notice The percentage of interest earned by lenders on this platform that is taken by the contract admin's as a
     * fee, measured in basis points (hundreths of a percent). The max allowed value is 10000.
     */
    uint16 public override adminFeeInBasisPoints = 500;

    /**
     * @notice A mapping from a loan's identifier to the loan's details, represted by the loan struct.
     */
    mapping(uint32 => LoanTerms) public override loanIdToLoan;
    mapping(uint32 => LoanExtras) public loanIdToLoanExtras;

    /**
     * @notice A mapping tracking whether a loan has either been repaid or liquidated. This prevents an attacker trying
     * to repay or liquidate the same loan twice.
     */
    mapping(uint32 => bool) public override loanRepaidOrLiquidated;

    /**
     * @dev keeps track of tokens being held as loan collateral, so we dont allow these
     * to be transferred with the aridrop draining functions
     * nft contract address => nft id => amount (in case of 1155)
     */
    mapping(address => mapping(uint256 => uint256)) private _escrowTokens;

    /**
     * @dev keeps track of payed back erc20 tokens being held in escrow of finished loans, so we dont allow these
     * to be transferred with the aridrop draining functions
     * token contract => amount
     */
    mapping(address => uint256) private _escrowErc20Tokens;

    /**
     * @dev keeps track of payed back erc20 tokens being held in escrow of finished loans for each lender
     * lender => token contract => amount
     */
    mapping(address => mapping(address => uint256)) private _payBackEscrow;

    /**
     * @notice A mapping that takes both a user's address and a loan nonce that was first used when signing an off-chain
     * order and checks whether that nonce has previously either been used for a loan, or has been pre-emptively
     * cancelled. The nonce referred to here is not the same as an Ethereum account's nonce. We are referring instead to
     * nonces that are used by both the lender and the borrower when they are first signing off-chain NFTfi orders.
     *
     * These nonces can be any uint256 value that the user has not previously used to sign an off-chain order. Each
     * nonce can be used at most once per user within NFTfi, regardless of whether they are the lender or the borrower
     * in that situation. This serves two purposes. First, it prevents replay attacks where an attacker would submit a
     * user's off-chain order more than once. Second, it allows a user to cancel an off-chain order by calling
     * NFTfi.cancelLoanCommitmentBeforeLoanHasBegun(), which marks the nonce as used and prevents any future loan from
     * using the user's off-chain order that contains that nonce.
     */
    mapping(address => mapping(uint256 => bool)) internal _nonceHasBeenUsedForUser;

    /**
     * @notice A mapping from an ERC20 currency address to whether that currency
     * is permitted to be used by this contract.
     */
    mapping(address => bool) private erc20Permits;

    // solhint-disable-next-line immutable-vars-naming
    INftfiHub public immutable hub;

    /* ****** */
    /* EVENTS */
    /* ****** */

    /**
     * @notice This event is fired whenever the admins change the percent of interest rates earned that they charge as a
     * fee. Note that newAdminFee can never exceed 10,000, since the fee is measured in basis points.
     *
     * @param  newAdminFee - The new admin fee measured in basis points. This is a percent of the interest paid upon a
     * loan's completion that go to the contract admins.
     */
    event AdminFeeUpdated(uint16 newAdminFee);

    /**
     * @notice This event is fired whenever the admins change the maximum duration of any loan started for this loan
     * type.
     *
     * @param  newMaximumLoanDuration - The new maximum duration.
     */
    event MaximumLoanDurationUpdated(uint256 newMaximumLoanDuration);

    /**
     * @notice This event is fired whenever a borrower begins a loan by calling NFTfi.beginLoan(), which can only occur
     * after both the lender and borrower have approved their ERC721 and ERC20 contracts to use NFTfi, and when they
     * both have signed off-chain messages that agree on the terms of the loan.
     *
     * @param  loanId - A unique identifier for this particular loan, sourced from the Loan Coordinator.
     * @param  borrower - The address of the borrower.
     * @param  lender - The address of the lender. The lender can change their address by transferring the NFTfi ERC721
     * token that they received when the loan began.
     */
    event LoanStarted(
        uint32 indexed loanId,
        address indexed borrower,
        address indexed lender,
        LoanTerms loanTerms,
        LoanExtras loanExtras
    );

    /**
     * @notice This event is fired whenever a borrower successfully repays their loan, paying
     * principal-plus-interest-minus-fee to the lender in loanERC20Denomination, paying fee to owner in
     * loanERC20Denomination, and receiving their NFT collateral back.
     *
     * @param  loanId - A unique identifier for this particular loan, sourced from the Loan Coordinator.
     * @param  borrower - The address of the borrower.
     * @param  lender - The address of the lender. The lender can change their address by transferring the NFTfi ERC721
     * token that they received when the loan began.
     * @param  loanPrincipalAmount - The original sum of money transferred from lender to borrower at the beginning of
     * the loan, measured in loanERC20Denomination's smallest units.
     * @param  nftCollateralId - The ID within the NFTCollateralContract for the NFT being used as collateral for this
     * loan. The NFT is stored within this contract during the duration of the loan.
     * @param  amountPaidToLender The amount of ERC20 that the borrower paid to the lender, measured in the smalled
     * units of loanERC20Denomination.
     * @param  adminFee The amount of interest paid to the contract admins, measured in the smalled units of
     * loanERC20Denomination and determined by adminFeeInBasisPoints. This amount never exceeds the amount of interest
     * earned.
     * @param  revenueShare The amount taken from admin fee amount shared with the partner.
     * @param  revenueSharePartner  - The address of the partner that will receive the revenue share.
     * @param  nftCollateralContract - The ERC721 contract of the NFT collateral
     * @param  loanERC20Denomination - The ERC20 contract of the currency being used as principal/interest for this
     * loan.
     */
    event LoanRepaid(
        uint32 indexed loanId,
        address indexed borrower,
        address indexed lender,
        uint256 loanPrincipalAmount,
        uint256 nftCollateralId,
        uint256 amountPaidToLender,
        uint256 adminFee,
        uint256 revenueShare,
        address revenueSharePartner,
        address nftCollateralContract,
        address loanERC20Denomination
    );

    /**
     * @notice This event is fired whenever a loan is repaid into escrow
     *
     * @param  loanId - A unique identifier for this particular loan, sourced from the Loan Coordinator.
     */
    event EscrowRepay(uint32 indexed loanId);

    /**
     * @notice This event is fired whenever a lender liquidates an outstanding loan that is owned to them that has
     * exceeded its duration. The lender receives the underlying NFT collateral, and the borrower no longer needs to
     * repay the loan principal-plus-interest.
     *
     * @param  loanId - A unique identifier for this particular loan, sourced from the Loan Coordinator.
     * @param  borrower - The address of the borrower.
     * @param  lender - The address of the lender. The lender can change their address by transferring the NFTfi ERC721
     * token that they received when the loan began.
     * @param  loanPrincipalAmount - The original sum of money transferred from lender to borrower at the beginning of
     * the loan, measured in loanERC20Denomination's smallest units.
     * @param  nftCollateralId - The ID within the NFTCollateralContract for the NFT being used as collateral for this
     * loan. The NFT is stored within this contract during the duration of the loan.
     * @param  loanMaturityDate - The unix time (measured in seconds) that the loan became due and was eligible for
     * liquidation.
     * @param  loanLiquidationDate - The unix time (measured in seconds) that liquidation occurred.
     * @param  nftCollateralContract - The ERC721 contract of the NFT collateral
     */
    event LoanLiquidated(
        uint32 indexed loanId,
        address indexed borrower,
        address indexed lender,
        uint256 loanPrincipalAmount,
        uint256 nftCollateralId,
        uint256 loanMaturityDate,
        uint256 loanLiquidationDate,
        address nftCollateralContract
    );

    /**
     * @notice This event is fired when some of the terms of a loan are being renegotiated.
     *
     * @param loanId - The unique identifier for the loan to be renegotiated
     * @param newLoanDuration - The new amount of time (measured in seconds) that can elapse before the lender can
     * liquidate the loan and seize the underlying collateral NFT.
     * @param newMaximumRepaymentAmount - The new maximum amount of money that the borrower would be required to
     * retrieve their collateral, measured in the smallest units of the ERC20 currency used for the loan. The
     * borrower will always have to pay this amount to retrieve their collateral, regardless of whether they repay
     * early.
     * @param renegotiationFee Agreed upon fee in loan denomination that borrower pays for the lender for the
     * renegotiation, has to be paid with an ERC20 transfer loanERC20Denomination token, uses transfer from,
     * frontend will have to propmt an erc20 approve for this from the borrower to the lender
     * @param renegotiationAdminFee renegotiationFee admin portion based on determined by adminFeeInBasisPoints
     */
    event LoanRenegotiated(
        uint32 indexed loanId,
        address indexed borrower,
        address indexed lender,
        uint32 newLoanDuration,
        uint256 newMaximumRepaymentAmount,
        uint256 renegotiationFee,
        uint256 renegotiationAdminFee
    );

    /**
     * @notice This event is fired whenever the admin sets a ERC20 permit.
     *
     * @param erc20Contract - Address of the ERC20 contract.
     * @param isPermitted - Signals ERC20 permit.
     */
    event ERC20Permit(address indexed erc20Contract, bool isPermitted);

    /* ************* */
    /* CUSTOM ERRORS */
    /* ************* */

    error LoanDurationOverflow();
    error BasisPointsTooHigh();
    error NoTokensOwned();
    error TokensInEscrow();
    error FunctionInformationArityMismatch();
    error TokenIsCollateral();
    error NFTNotOwned();
    error SenderNotBorrower();
    error NoNFTsOwned();
    error NoTokensInEscrow();
    error LoanAlreadyRepaidOrLiquidated();
    error LoanNotOverdueYet();
    error OnlyLenderCanLiquidate();
    error InvalidNonce();
    error RenegotiationSignatureInvalid();
    error ERC20ZeroAddress();
    error CurrencyDenominationNotPermitted();
    error NFTCollateralContractNotPermitted();
    error LoanDurationExceedsMaximum();
    error LoanDurationCannotBeZero();
    error AdminFeeChanged();

    /* *********** */
    /* CONSTRUCTOR */
    /* *********** */

    /**
     * @dev Sets `hub`
     *
     * @param _admin - Initial admin of this contract.
     * @param  _nftfiHub - NFTfiHub address
     * @param  _loanCoordinatorKey -
     * @param  _permittedErc20s -
     */
    constructor(
        address _admin,
        address _nftfiHub,
        bytes32 _loanCoordinatorKey,
        address[] memory _permittedErc20s
    ) BaseLoan(_admin) {
        hub = INftfiHub(_nftfiHub);
        LOAN_COORDINATOR = _loanCoordinatorKey;
        for (uint256 i; i < _permittedErc20s.length; ++i) {
            _setERC20Permit(_permittedErc20s[i], true);
        }
    }

    /* *************** */
    /* ADMIN FUNCTIONS */
    /* *************** */

    /**
     * @notice This function can be called by admins to change the maximumLoanDuration. Note that they can never change
     * maximumLoanDuration to be greater than UINT32_MAX, since that's the maximum space alotted for the duration in the
     * loan struct.
     *
     * @param _newMaximumLoanDuration - The new maximum loan duration, measured in seconds.
     */
    function updateMaximumLoanDuration(uint256 _newMaximumLoanDuration) external onlyOwner {
        if (_newMaximumLoanDuration > uint256(type(uint32).max)) {
            revert LoanDurationOverflow();
        }
        maximumLoanDuration = _newMaximumLoanDuration;
        emit MaximumLoanDurationUpdated(_newMaximumLoanDuration);
    }

    /**
     * @notice This function can be called by admins to change the percent of interest rates earned that they charge as
     * a fee. Note that newAdminFee can never exceed 10,000, since the fee is measured in basis points.
     *
     * @param _newAdminFeeInBasisPoints - The new admin fee measured in basis points. This is a percent of the interest
     * paid upon a loan's completion that go to the contract admins.
     */
    function updateAdminFee(uint16 _newAdminFeeInBasisPoints) external onlyOwner {
        if (_newAdminFeeInBasisPoints > HUNDRED_PERCENT) {
            revert BasisPointsTooHigh();
        }
        adminFeeInBasisPoints = _newAdminFeeInBasisPoints;
        emit AdminFeeUpdated(_newAdminFeeInBasisPoints);
    }

    /**
     * @notice used by the owner account to be able to drain ERC20 tokens received as airdrops
     * for the locked  collateral NFT-s
     * @param _tokenAddress - address of the token contract for the token to be sent out
     * @param _receiver - receiver of the token
     */
    function drainERC20Airdrop(address _tokenAddress, uint256 amount, address _receiver) external onlyOwner {
        IERC20 tokenContract = IERC20(_tokenAddress);
        uint256 balance = tokenContract.balanceOf(address(this));
        if (balance == 0) {
            revert NoTokensOwned();
        }
        if (balance - _escrowErc20Tokens[_tokenAddress] < amount) {
            revert TokensInEscrow();
        }
        tokenContract.safeTransfer(_receiver, amount);
    }

    /**
     * @notice This function can be called by admins to change the permitted status of an ERC20 currency. This includes
     * both adding an ERC20 currency to the permitted list and removing it.
     *
     * @param _erc20 - The address of the ERC20 currency whose permit list status changed.
     * @param _permit - The new status of whether the currency is permitted or not.
     */
    function setERC20Permit(address _erc20, bool _permit) external onlyOwner {
        _setERC20Permit(_erc20, _permit);
    }

    /**
     * @notice This function can be called by admins to change the permitted status of a batch of ERC20 currency. This
     * includes both adding an ERC20 currency to the permitted list and removing it.
     *
     * @param _erc20s - The addresses of the ERC20 currencies whose permit list status changed.
     * @param _permits - The new statuses of whether the currency is permitted or not.
     */
    function setERC20Permits(address[] memory _erc20s, bool[] memory _permits) external onlyOwner {
        if (_erc20s.length != _permits.length) {
            revert FunctionInformationArityMismatch();
        }
        for (uint256 i = 0; i < _erc20s.length; ++i) {
            _setERC20Permit(_erc20s[i], _permits[i]);
        }
    }

    /**
     * @notice used by the owner account to be able to drain ERC721 tokens received as airdrops
     * for the locked  collateral NFT-s
     * @param _tokenAddress - address of the token contract for the token to be sent out
     * @param _tokenId - id token to be sent out
     * @param _receiver - receiver of the token
     */
    function drainERC721Airdrop(address _tokenAddress, uint256 _tokenId, address _receiver) external onlyOwner {
        IERC721 tokenContract = IERC721(_tokenAddress);
        if (_escrowTokens[_tokenAddress][_tokenId] > 0) {
            revert TokenIsCollateral();
        }
        if (tokenContract.ownerOf(_tokenId) != address(this)) {
            revert NFTNotOwned();
        }
        tokenContract.safeTransferFrom(address(this), _receiver, _tokenId);
    }

    /**
     * @notice used by the owner account to be able to drain ERC1155 tokens received as airdrops
     * for the locked  collateral NFT-s
     * @param _tokenAddress - address of the token contract for the token to be sent out
     * @param _tokenId - id token to be sent out
     * @param _receiver - receiver of the token
     */
    function drainERC1155Airdrop(address _tokenAddress, uint256 _tokenId, address _receiver) external onlyOwner {
        IERC1155 tokenContract = IERC1155(_tokenAddress);
        uint256 amount = tokenContract.balanceOf(address(this), _tokenId);
        if (_escrowTokens[_tokenAddress][_tokenId] > 0) {
            revert TokenIsCollateral();
        }
        if (amount == 0) {
            revert NoNFTsOwned();
        }
        tokenContract.safeTransferFrom(address(this), _receiver, _tokenId, amount, "");
    }

    function mintObligationReceipt(uint32 _loanId) external nonReentrant {
        address borrower = loanIdToLoan[_loanId].borrower;
        if (msg.sender != borrower) {
            revert SenderNotBorrower();
        }
        IDirectLoanCoordinator loanCoordinator = IDirectLoanCoordinator(hub.getContract(LOAN_COORDINATOR));
        loanCoordinator.mintObligationReceipt(_loanId, borrower);

        delete loanIdToLoan[_loanId].borrower;
    }

    /**
     * @dev makes possible to change loan duration and max repayment amount, loan duration even can be extended if
     * loan was expired but not liquidated.
     *
     * @param _loanId - The unique identifier for the loan to be renegotiated
     * @param _newLoanDuration - The new amount of time (measured in seconds) that can elapse before the lender can
     * liquidate the loan and seize the underlying collateral NFT.
     * @param _newMaximumRepaymentAmount - The new maximum amount of money that the borrower would be required to
     * retrieve their collateral, measured in the smallest units of the ERC20 currency used for the loan. The
     * borrower will always have to pay this amount to retrieve their collateral, regardless of whether they repay
     * early.
     * @param _renegotiationFee Agreed upon fee in ether that borrower pays for the lender for the renegitiation
     * @param _lenderNonce - The nonce referred to here is not the same as an Ethereum account's nonce. We are
     * referring instead to nonces that are used by both the lender and the borrower when they are first signing
     * off-chain NFTfi orders. These nonces can be any uint256 value that the user has not previously used to sign an
     * off-chain order. Each nonce can be used at most once per user within NFTfi, regardless of whether they are the
     * lender or the borrower in that situation. This serves two purposes:
     * - First, it prevents replay attacks where an attacker would submit a user's off-chain order more than once.
     * - Second, it allows a user to cancel an off-chain order by calling NFTfi.cancelLoanCommitmentBeforeLoanHasBegun()
     * , which marks the nonce as used and prevents any future loan from using the user's off-chain order that contains
     * that nonce.
     * @param _expiry - The date when the renegotiation offer expires
     * @param _lenderSignature - The ECDSA signature of the lender, obtained off-chain ahead of time, signing the
     * following combination of parameters:
     * - _loanId
     * - _newLoanDuration
     * - _newMaximumRepaymentAmount
     * - _lender
     * - _expiry
     *  - address of this contract
     * - chainId
     */
    function renegotiateLoan(
        uint32 _loanId,
        uint32 _newLoanDuration,
        uint256 _newMaximumRepaymentAmount,
        uint256 _renegotiationFee,
        uint256 _lenderNonce,
        uint256 _expiry,
        bytes memory _lenderSignature
    ) external whenNotPaused nonReentrant {
        _renegotiateLoan(
            _loanId,
            _newLoanDuration,
            _newMaximumRepaymentAmount,
            _renegotiationFee,
            _lenderNonce,
            _expiry,
            _lenderSignature
        );
    }

    /**
     * @notice This function is called by a anyone to repay a loan. It can be called at any time after the loan has
     * begun and before loan expiry.. The caller will pay a pro-rata portion of their interest if the loan is paid off
     * early and the loan is pro-rated type, but the complete repayment amount if it is fixed type.
     * The the borrower (current owner of the obligation note) will get the collaterl NFT back.
     *
     * This function is purposefully not pausable in order to prevent an attack where the contract admin's pause the
     * contract and hold hostage the NFT's that are still within it.
     *
     * @param _loanId  A unique identifier for this particular loan, sourced from the Loan Coordinator.
     */
    function payBackLoan(uint32 _loanId) external nonReentrant {
        LoanChecksAndCalculations.payBackChecks(_loanId, hub);
        (
            address borrower,
            address lender,
            LoanTerms memory loan,
            IDirectLoanCoordinator loanCoordinator
        ) = _getPartiesAndData(_loanId);

        _payBackLoan(_loanId, borrower, lender, loan);

        bool repaid = true;
        _resolveLoan(_loanId, borrower, loan, loanCoordinator, repaid);
    }

    /**
     * @notice This function is called by a anyone to repay a loan. It can be called at any time after the loan has
     * begun and before loan expiry.. The caller will pay a pro-rata portion of their interest if the loan is paid off
     * early and the loan is pro-rated type, but the complete repayment amount if it is fixed type.
     * The the borrower (current owner of the obligation note) will get the collaterl NFT back.
     *
     * This function is purposefully not pausable in order to prevent an attack where the contract admin's pause the
     * contract and hold hostage the NFT's that are still within it.
     *
     * @param _loanId  A unique identifier for this particular loan, sourced from the Loan Coordinator.
     */
    function payBackLoanSafe(uint32 _loanId) external nonReentrant {
        LoanChecksAndCalculations.payBackChecks(_loanId, hub);
        (
            address borrower,
            address lender,
            LoanTerms memory loan,
            IDirectLoanCoordinator loanCoordinator
        ) = _getPartiesAndData(_loanId);

        _payBackLoanSafe(_loanId, borrower, lender, loan);

        bool repaid = true;
        _resolveLoan(_loanId, borrower, loan, loanCoordinator, repaid);
    }

    /**
     * @notice Used for lenders to get their payback from escrow,
     * in case the direct loan payback didn't work, because it caused a revert.
     *
     * @param _token  ERC20 token conract address
     */
    function getEscrowedPayBack(address _token) external nonReentrant {
        uint256 amount = _payBackEscrow[msg.sender][_token];
        if (amount == 0) {
            revert NoTokensInEscrow();
        }
        IERC20(_token).safeTransfer(msg.sender, amount);
        delete _payBackEscrow[msg.sender][_token];
        _escrowErc20Tokens[_token] -= amount;
    }

    /**
     * @notice This function is called by a lender once a loan has finished its duration and the borrower still has not
     * repaid. The lender can call this function to seize the underlying NFT collateral, although the lender gives up
     * all rights to the principal-plus-collateral by doing so.
     *
     * This function is purposefully not pausable in order to prevent an attack where the contract admin's pause
     * the contract and hold hostage the NFT's that are still within it.
     *
     * We intentionally allow anybody to call this function, although only the lender will end up receiving the seized
     * collateral. We are exploring the possbility of incentivizing users to call this function by using some of the
     * admin funds.
     *
     * @param _loanId  A unique identifier for this particular loan, sourced from the Loan Coordinator.
     */
    function liquidateOverdueLoan(uint32 _loanId) external nonReentrant {
        LoanChecksAndCalculations.checkLoanIdValidity(_loanId, hub);
        // Sanity check that payBackLoan() and liquidateOverdueLoan() have never been called on this loanId.
        // Depending on how the rest of the code turns out, this check may be unnecessary.
        if (loanRepaidOrLiquidated[_loanId]) {
            revert LoanAlreadyRepaidOrLiquidated();
        }

        (
            address borrower,
            address lender,
            LoanTerms memory loan,
            IDirectLoanCoordinator loanCoordinator
        ) = _getPartiesAndData(_loanId);

        // Ensure that the loan is indeed overdue, since we can only liquidate overdue loans.
        uint256 loanMaturityDate = uint256(loan.loanStartTime) + uint256(loan.loanDuration);
        if (block.timestamp <= loanMaturityDate) {
            revert LoanNotOverdueYet();
        }
        if (msg.sender != lender) {
            revert OnlyLenderCanLiquidate();
        }

        bool repaid = false;

        _resolveLoan(_loanId, lender, loan, loanCoordinator, repaid);

        // Emit an event with all relevant details from this transaction.
        emit LoanLiquidated(
            _loanId,
            borrower,
            lender,
            loan.loanPrincipalAmount,
            loan.nftCollateralId,
            loanMaturityDate,
            block.timestamp,
            loan.nftCollateralContract
        );
    }

    /**
     * @notice This function can be called by either a lender or a borrower to cancel all off-chain orders that they
     * have signed that contain this nonce. If the off-chain orders were created correctly, there should only be one
     * off-chain order that contains this nonce at all.
     *
     * The nonce referred to here is not the same as an Ethereum account's nonce. We are referring
     * instead to nonces that are used by both the lender and the borrower when they are first signing off-chain NFTfi
     * orders. These nonces can be any uint256 value that the user has not previously used to sign an off-chain order.
     * Each nonce can be used at most once per user within NFTfi, regardless of whether they are the lender or the
     * borrower in that situation. This serves two purposes. First, it prevents replay attacks where an attacker would
     * submit a user's off-chain order more than once. Second, it allows a user to cancel an off-chain order by calling
     * NFTfi.cancelLoanCommitmentBeforeLoanHasBegun(), which marks the nonce as used and prevents any future loan from
     * using the user's off-chain order that contains that nonce.
     *
     * @param  _nonce - User nonce
     */
    function cancelLoanCommitmentBeforeLoanHasBegun(uint256 _nonce) external {
        if (_nonceHasBeenUsedForUser[msg.sender][_nonce]) {
            revert InvalidNonce();
        }
        _nonceHasBeenUsedForUser[msg.sender][_nonce] = true;
    }

    /* ******************* */
    /* READ-ONLY FUNCTIONS */
    /* ******************* */

    /**
     * @notice This function can be used to view the current quantity of the ERC20 currency used in the specified loan
     * required by the borrower to repay their loan, measured in the smallest unit of the ERC20 currency.
     *
     * @param _loanId  A unique identifier for this particular loan, sourced from the Loan Coordinator.
     *
     * @return The amount of the specified ERC20 currency required to pay back this loan, measured in the smallest unit
     * of the specified ERC20 currency.
     */
    function getPayoffAmount(uint32 _loanId) external view virtual returns (uint256);

    /**
     * @notice This function can be used to view whether a particular nonce for a particular user has already been used,
     * either from a successful loan or a cancelled off-chain order.
     *
     * @param _user - The address of the user. This function works for both lenders and borrowers alike.
     * @param  _nonce - The nonce referred to here is not the same as an Ethereum account's nonce. We are referring
     * instead to nonces that are used by both the lender and the borrower when they are first signing off-chain
     * NFTfi orders. These nonces can be any uint256 value that the user has not previously used to sign an off-chain
     * order. Each nonce can be used at most once per user within NFTfi, regardless of whether they are the lender or
     * the borrower in that situation. This serves two purposes:
     * - First, it prevents replay attacks where an attacker would submit a user's off-chain order more than once.
     * - Second, it allows a user to cancel an off-chain order by calling NFTfi.cancelLoanCommitmentBeforeLoanHasBegun()
     * , which marks the nonce as used and prevents any future loan from using the user's off-chain order that contains
     * that nonce.
     *
     * @return A bool representing whether or not this nonce has been used for this user.
     */
    function getWhetherNonceHasBeenUsedForUser(address _user, uint256 _nonce) external view override returns (bool) {
        return _nonceHasBeenUsedForUser[_user][_nonce];
    }

    /**
     * @notice This function can be called by anyone to get the permit associated with the erc20 contract.
     *
     * @param _erc20 - The address of the erc20 contract.
     *
     * @return Returns whether the erc20 is permitted
     */
    function getERC20Permit(address _erc20) public view override returns (bool) {
        return erc20Permits[_erc20];
    }

    /* ****************** */
    /* INTERNAL FUNCTIONS */
    /* ****************** */

    /**
     * @dev makes possible to change loan duration and max repayment amount, loan duration even can be extended if
     * loan was expired but not liquidated. IMPORTANT: Frontend will have to propt the caller to do an ERC20 approve for
     * the fee amount from themselves (borrower/obligation reciept holder) to the lender (promissory note holder)
     *
     * @param _loanId - The unique identifier for the loan to be renegotiated
     * @param _newLoanDuration - The new amount of time (measured in seconds) that can elapse before the lender can
     * liquidate the loan and seize the underlying collateral NFT.
     * @param _newMaximumRepaymentAmount - The new maximum amount of money that the borrower would be required to
     * retrieve their collateral, measured in the smallest units of the ERC20 currency used for the loan. The
     * borrower will always have to pay this amount to retrieve their collateral, regardless of whether they repay
     * early.
     * @param _renegotiationFee Agreed upon fee in loan denomination that borrower pays for the lender and
     * the admin for the renegotiation, has to be paid with an ERC20 transfer loanERC20Denomination token,
     * uses transfer from, frontend will have to propmt an erc20 approve for this from the borrower to the lender,
     * admin fee is calculated by the loan's loanAdminFeeInBasisPoints value
     * @param _lenderNonce - The nonce referred to here is not the same as an Ethereum account's nonce. We are
     * referring instead to nonces that are used by both the lender and the borrower when they are first signing
     * off-chain NFTfi orders. These nonces can be any uint256 value that the user has not previously used to sign an
     * off-chain order. Each nonce can be used at most once per user within NFTfi, regardless of whether they are the
     * lender or the borrower in that situation. This serves two purposes:
     * - First, it prevents replay attacks where an attacker would submit a user's off-chain order more than once.
     * - Second, it allows a user to cancel an off-chain order by calling NFTfi.cancelLoanCommitmentBeforeLoanHasBegun()
     , which marks the nonce as used and prevents any future loan from using the user's off-chain order that contains
     * that nonce.
     * @param _expiry - The date when the renegotiation offer expires
     * @param _lenderSignature - The ECDSA signature of the lender, obtained off-chain ahead of time, signing the
     * following combination of parameters:
     * - _loanId
     * - _newLoanDuration
     * - _newMaximumRepaymentAmount
     * - _lender
     * - _expiry
     * - address of this contract
     * - chainId
     */
    function _renegotiateLoan(
        uint32 _loanId,
        uint32 _newLoanDuration,
        uint256 _newMaximumRepaymentAmount,
        uint256 _renegotiationFee,
        uint256 _lenderNonce,
        uint256 _expiry,
        bytes memory _lenderSignature
    ) internal {
        LoanTerms storage loan = loanIdToLoan[_loanId];

        (address borrower, address lender) = LoanChecksAndCalculations.renegotiationChecks(
            loan,
            _loanId,
            _newLoanDuration,
            _newMaximumRepaymentAmount,
            _lenderNonce,
            hub
        );

        _nonceHasBeenUsedForUser[lender][_lenderNonce] = true;

        if (
            !NFTfiSigningUtils.isValidLenderRenegotiationSignature(
                _loanId,
                _newLoanDuration,
                _newMaximumRepaymentAmount,
                _renegotiationFee,
                Signature({signer: lender, nonce: _lenderNonce, expiry: _expiry, signature: _lenderSignature})
            )
        ) {
            revert RenegotiationSignatureInvalid();
        }

        uint256 renegotiationAdminFee;
        /**
         * @notice Transfers fee to the lender immediately
         * @dev implements Checks-Effects-Interactions pattern by modifying state only after
         * the transfer happened successfully, we also add the nonReentrant modifier to
         * the pbulic versions
         */
        if (_renegotiationFee > 0) {
            renegotiationAdminFee = LoanChecksAndCalculations.computeAdminFee(
                _renegotiationFee,
                loan.loanAdminFeeInBasisPoints
            );
            // Transfer principal-plus-interest-minus-fees from the caller (always has to be borrower) to lender
            IERC20(loan.loanERC20Denomination).safeTransferFrom(
                borrower,
                lender,
                _renegotiationFee - renegotiationAdminFee
            );
            // Transfer fees from the caller (always has to be borrower) to admins
            IERC20(loan.loanERC20Denomination).safeTransferFrom(borrower, owner(), renegotiationAdminFee);
        }

        loan.loanDuration = _newLoanDuration;
        loan.maximumRepaymentAmount = _newMaximumRepaymentAmount;

        // we have to reinstate borrower record here, because obligation receipt gets deleted in reMint
        if (loan.borrower == address(0)) {
            loan.borrower = borrower;
        }
        IDirectLoanCoordinator(hub.getContract(LOAN_COORDINATOR)).resetSmartNfts(_loanId, lender);

        emit LoanRenegotiated(
            _loanId,
            borrower,
            lender,
            _newLoanDuration,
            _newMaximumRepaymentAmount,
            _renegotiationFee,
            renegotiationAdminFee
        );
    }

    /**
     * @dev Transfer collateral NFT from borrower to this contract and principal from lender to the borrower and
     * registers the new loan through the loan coordinator.
     *
     * @param _loanType - The type of loan it is being created
     * @param _loanTerms - Struct containing the loan's settings
     * @param _loanExtras - Struct containing some loan's extra settings, needed to avoid stack too deep
     * @param _lender - The address of the lender.
     * @param _referrer - The address of the referrer who found the lender matching the listing, Zero address to signal
     * that there is no referrer.
     */
    function _createLoan(
        bytes32 _loanType,
        LoanTerms memory _loanTerms,
        LoanExtras memory _loanExtras,
        address _borrower,
        address _lender,
        address _referrer
    ) internal returns (uint32) {
        // Transfer collateral from borrower to this contract to be held until
        // loan completion.
        _transferNFT(_loanTerms, _borrower, address(this));

        return _createLoanNoNftTransfer(_loanType, _loanTerms, _loanExtras, _borrower, _lender, _referrer);
    }

    /**
     * @dev Transfer principal from lender to the borrower and
     * registers the new loan through the loan coordinator.
     *
     * @param _loanType - The type of loan it is being created
     * @param _loanTerms - Struct containing the loan's settings
     * @param _loanExtras - Struct containing some loan's extra settings, needed to avoid stack too deep
     * @param _lender - The address of the lender.
     * @param _referrer - The address of the referrer who found the lender matching the listing, Zero address to signal
     * that there is no referrer.
     */
    function _createLoanNoNftTransfer(
        bytes32 _loanType,
        LoanTerms memory _loanTerms,
        LoanExtras memory _loanExtras,
        address _borrower,
        address _lender,
        address _referrer
    ) internal returns (uint32 loanId) {
        _escrowTokens[_loanTerms.nftCollateralContract][_loanTerms.nftCollateralId] += 1;

        uint256 referralfee = LoanChecksAndCalculations.computeReferralFee(
            _loanTerms.loanPrincipalAmount,
            _loanExtras.referralFeeInBasisPoints,
            _referrer
        );
        uint256 principalAmount = _loanTerms.loanPrincipalAmount - referralfee;
        if (referralfee > 0) {
            // Transfer the referral fee from lender to referrer.
            IERC20(_loanTerms.loanERC20Denomination).safeTransferFrom(_lender, _referrer, referralfee);
        }
        // Transfer principal from lender to borrower.
        IERC20(_loanTerms.loanERC20Denomination).safeTransferFrom(_lender, _borrower, principalAmount);

        // Issue an ERC721 promissory note to the lender that gives them the
        // right to either the principal-plus-interest or the collateral,
        // and an obligation note to the borrower that gives them the
        // right to pay back the loan and get the collateral back.
        IDirectLoanCoordinator loanCoordinator = IDirectLoanCoordinator(hub.getContract(LOAN_COORDINATOR));
        loanId = loanCoordinator.registerLoan(_lender, _loanType);

        // Add the loan to storage before moving collateral/principal to follow
        // the Checks-Effects-Interactions pattern.
        loanIdToLoan[loanId] = _loanTerms;
        loanIdToLoanExtras[loanId] = _loanExtras;

        return loanId;
    }

    /**
     * @dev Transfers several types of NFTs using a wrapper that knows how to handle each case.
     *
     * @param _loanTerms - Struct containing all the loan's parameters
     * @param _sender - Current owner of the NFT
     * @param _recipient - Recipient of the transfer
     */
    function _transferNFT(LoanTerms memory _loanTerms, address _sender, address _recipient) internal {
        Address.functionDelegateCall(
            _loanTerms.nftCollateralWrapper,
            abi.encodeWithSelector(
                INftWrapper(_loanTerms.nftCollateralWrapper).transferNFT.selector,
                _sender,
                _recipient,
                _loanTerms.nftCollateralContract,
                _loanTerms.nftCollateralId
            ),
            "NFT not successfully transferred"
        );
    }

    /**
     * @notice This function is called by a anyone to repay a loan. It can be called at any time after the loan has
     * begun and before loan expiry.. The caller will pay a pro-rata portion of their interest if the loan is paid off
     * early and the loan is pro-rated type, but the complete repayment amount if it is fixed type.
     * The the borrower (current owner of the obligation note) will get the collaterl NFT back.
     *
     * This function is purposefully not pausable in order to prevent an attack where the contract admin's pause the
     * contract and hold hostage the NFT's that are still within it.
     *
     * @param _loanId  A unique identifier for this particular loan, sourced from the Loan Coordinator.
     */
    function _payBackLoan(uint32 _loanId, address _borrower, address _lender, LoanTerms memory _loan) internal {
        // Fetch loan details from storage, but store them in memory for the sake of saving gas.
        LoanExtras memory loanExtras = loanIdToLoanExtras[_loanId];

        (uint256 adminFee, uint256 payoffAmount) = _payoffAndFee(_loan);

        // Transfer principal-plus-interest-minus-fees from the caller to lender
        IERC20(_loan.loanERC20Denomination).safeTransferFrom(msg.sender, _lender, payoffAmount);

        uint256 revenueShare = LoanChecksAndCalculations.computeRevenueShare(
            adminFee,
            loanExtras.revenueShareInBasisPoints
        );
        // PermittedPartners contract doesn't allow to set a revenueShareInBasisPoints for address zero so revenuShare
        // > 0 implies that revenueSharePartner ~= address(0), BUT revenueShare can be zero for a partener when the
        // adminFee is low
        if (revenueShare > 0 && loanExtras.revenueSharePartner != address(0)) {
            adminFee -= revenueShare;
            // Transfer revenue share from the caller to permitted partner
            IERC20(_loan.loanERC20Denomination).safeTransferFrom(
                msg.sender,
                loanExtras.revenueSharePartner,
                revenueShare
            );
        }

        // Transfer fees from the caller to admins
        IERC20(_loan.loanERC20Denomination).safeTransferFrom(msg.sender, owner(), adminFee);

        // Emit an event with all relevant details from this transaction.
        emit LoanRepaid(
            _loanId,
            _borrower,
            _lender,
            _loan.loanPrincipalAmount,
            _loan.nftCollateralId,
            payoffAmount,
            adminFee,
            revenueShare,
            loanExtras.revenueSharePartner, // this could be a non address zero even if revenueShare is 0
            _loan.nftCollateralContract,
            _loan.loanERC20Denomination
        );
    }

    /**
     * @notice This function is called by a anyone to repay a loan. It can be called at any time after the loan has
     * begun and before loan expiry.. The caller will pay a pro-rata portion of their interest if the loan is paid off
     * early and the loan is pro-rated type, but the complete repayment amount if it is fixed type.
     * The the borrower (current owner of the obligation note) will get the collaterl NFT back.
     *
     * This function is purposefully not pausable in order to prevent an attack where the contract admin's pause the
     * contract and hold hostage the NFT's that are still within it.
     *
     * @param _loanId  A unique identifier for this particular loan, sourced from the Loan Coordinator.
     */
    function _payBackLoanSafe(uint32 _loanId, address _borrower, address _lender, LoanTerms memory _loan) internal {
        // Fetch loan details from storage, but store them in memory for the sake of saving gas.
        LoanExtras memory loanExtras = loanIdToLoanExtras[_loanId];

        (uint256 adminFee, uint256 payoffAmount) = _payoffAndFee(_loan);

        // use try to detect the case of erc20 transfer failing for some reason (e.g. USDC blacklisted address)
        try IERC20(_loan.loanERC20Denomination).transferFrom(msg.sender, _lender, payoffAmount) {
            // solhint-disable-previous-line no-empty-blocks
        } catch {
            // if ERC20 transfer fails, we store the amount in escrow in this contract
            IERC20(_loan.loanERC20Denomination).safeTransferFrom(msg.sender, address(this), payoffAmount);
            _payBackEscrow[_lender][_loan.loanERC20Denomination] += payoffAmount;
            _escrowErc20Tokens[_loan.loanERC20Denomination] += payoffAmount;
            emit EscrowRepay(_loanId);
        }

        uint256 revenueShare = LoanChecksAndCalculations.computeRevenueShare(
            adminFee,
            loanExtras.revenueShareInBasisPoints
        );

        // PermittedPartners contract doesn't allow to set a revenueShareInBasisPoints for address zero so revenuShare
        // > 0 implies that revenueSharePartner ~= address(0), BUT revenueShare can be zero for a partener when the
        // adminFee is low
        if (revenueShare > 0 && loanExtras.revenueSharePartner != address(0)) {
            adminFee -= revenueShare;
            // Transfer revenue share from the caller to permitted partner
            // try is here so if for whatever reason (USCD blacklist specifically) this
            // transfer would fail the borrowerr still can pay back and get their nft back
            // revenue share can be later drained by us and distributed manually
            try
                IERC20(_loan.loanERC20Denomination).transferFrom(
                    msg.sender,
                    loanExtras.revenueSharePartner,
                    revenueShare
                )
            {
                // solhint-disable-previous-line no-empty-blocks
            } catch {
                IERC20(_loan.loanERC20Denomination).safeTransferFrom(msg.sender, address(this), revenueShare);
            }
        }

        // Transfer fees from the caller to admins
        // try is here so if for whatever reason (USCD blacklist specifically) this
        // transfer would fail the borrowerr still can pay back and get their nft back
        // admin fee can be later drained by us
        try IERC20(_loan.loanERC20Denomination).transferFrom(msg.sender, owner(), adminFee) {
            // solhint-disable-previous-line no-empty-blocks
        } catch {
            IERC20(_loan.loanERC20Denomination).safeTransferFrom(msg.sender, address(this), adminFee);
        }

        // Emit an event with all relevant details from this transaction.
        emit LoanRepaid(
            _loanId,
            _borrower,
            _lender,
            _loan.loanPrincipalAmount,
            _loan.nftCollateralId,
            payoffAmount,
            adminFee,
            revenueShare,
            loanExtras.revenueSharePartner, // this could be a non address zero even if revenueShare is 0
            _loan.nftCollateralContract,
            _loan.loanERC20Denomination
        );
    }

    /**
     * @notice A convenience function with shared functionality between `payBackLoan` and `liquidateOverdueLoan`.
     *
     * @param _loanId  A unique identifier for this particular loan, sourced from the Loan Coordinator.
     * @param _nftReceiver - The receiver of the collateral nft. The borrower when `payBackLoan` or the lender when
     * `liquidateOverdueLoan`.
     * @param _loanTerms - The main Loan Terms struct. This data is saved upon loan creation on loanIdToLoan.
     * @param _loanCoordinator - The loan coordinator used when creating the loan.
     */
    function _resolveLoan(
        uint32 _loanId,
        address _nftReceiver,
        LoanTerms memory _loanTerms,
        IDirectLoanCoordinator _loanCoordinator,
        bool _repaid
    ) internal {
        _resolveLoanNoNftTransfer(_loanId, _loanTerms, _loanCoordinator, _repaid);
        // Transfer collateral from this contract to the lender, since the lender is seizing collateral for an overdue
        // loan
        _transferNFT(_loanTerms, address(this), _nftReceiver);
    }

    /**
     * @notice Resolving the loan without trasferring the nft to provide a base for the bundle
     * break up of the bundled loans
     *
     * @param _loanId  A unique identifier for this particular loan, sourced from the Loan Coordinator.
     * @param _loanTerms - The main Loan Terms struct. This data is saved upon loan creation on loanIdToLoan.
     * @param _loanCoordinator - The loan coordinator used when creating the loan.
     */
    function _resolveLoanNoNftTransfer(
        uint32 _loanId,
        LoanTerms memory _loanTerms,
        IDirectLoanCoordinator _loanCoordinator,
        bool _repaid
    ) internal {
        // Mark loan as liquidated before doing any external transfers to follow the Checks-Effects-Interactions design
        // pattern
        loanRepaidOrLiquidated[_loanId] = true;

        _escrowTokens[_loanTerms.nftCollateralContract][_loanTerms.nftCollateralId] -= 1;

        // Destroy the lender's promissory note for this loan and borrower obligation receipt
        _loanCoordinator.resolveLoan(_loanId, _repaid);
    }

    /**
     * @notice This function can be called by admins to change the permitted status of an ERC20 currency. This includes
     * both adding an ERC20 currency to the permitted list and removing it.
     *
     * @param _erc20 - The address of the ERC20 currency whose permit list status changed.
     * @param _permit - The new status of whether the currency is permitted or not.
     */
    function _setERC20Permit(address _erc20, bool _permit) internal {
        if (_erc20 == address(0)) {
            revert ERC20ZeroAddress();
        }
        erc20Permits[_erc20] = _permit;

        emit ERC20Permit(_erc20, _permit);
    }

    /**
     * @dev Performs some validation checks over loan parameters
     *
     */
    function _loanSanityChecks(LoanData.Offer memory _offer, address _nftWrapper) internal view {
        if (!getERC20Permit(_offer.loanERC20Denomination)) {
            revert CurrencyDenominationNotPermitted();
        }
        if (_nftWrapper == address(0)) {
            revert NFTCollateralContractNotPermitted();
        }
        if (uint256(_offer.loanDuration) > maximumLoanDuration) {
            revert LoanDurationExceedsMaximum();
        }
        if (uint256(_offer.loanDuration) == 0) {
            revert LoanDurationCannotBeZero();
        }
        if (_offer.loanAdminFeeInBasisPoints != adminFeeInBasisPoints) {
            revert AdminFeeChanged();
        }
    }

    /**
     * @dev reads some variable values of a loan for payback functions, created to reduce code repetition
     */
    function _getPartiesAndData(
        uint32 _loanId
    )
        internal
        view
        returns (address borrower, address lender, LoanTerms memory loan, IDirectLoanCoordinator loanCoordinator)
    {
        loanCoordinator = IDirectLoanCoordinator(hub.getContract(LOAN_COORDINATOR));
        IDirectLoanCoordinator.Loan memory loanCoordinatorData = loanCoordinator.getLoanData(_loanId);
        uint256 smartNftId = loanCoordinatorData.smartNftId;
        // Fetch loan details from storage, but store them in memory for the sake of saving gas.
        loan = loanIdToLoan[_loanId];
        if (loan.borrower != address(0)) {
            borrower = loan.borrower;
        } else {
            // Fetch current owner of loan obligation note.
            borrower = IERC721(loanCoordinator.obligationReceiptToken()).ownerOf(smartNftId);
        }
        lender = IERC721(loanCoordinator.promissoryNoteToken()).ownerOf(smartNftId);
    }

    /**
     * @dev Creates a `LoanExtras` struct using data sent as the borrower's extra settings.
     * This is needed in order to avoid stack too deep issues.
     */
    function _setupLoanExtras(
        address _revenueSharePartner,
        uint16 _referralFeeInBasisPoints
    ) internal view returns (LoanExtras memory) {
        // Save loan details to a struct in memory first, to save on gas if any
        // of the below checks fail, and to avoid the "Stack Too Deep" error by
        // clumping the parameters together into one struct held in memory.
        return
            LoanExtras({
                revenueSharePartner: _revenueSharePartner,
                revenueShareInBasisPoints: LoanChecksAndCalculations.getRevenueSharePercent(_revenueSharePartner, hub),
                referralFeeInBasisPoints: _referralFeeInBasisPoints
            });
    }

    /**
     * @dev Calculates the payoff amount and admin fee
     */
    function _payoffAndFee(LoanTerms memory _loanTerms) internal view virtual returns (uint256, uint256);

    /**
     * @dev Checks that the collateral is a supported contracts and returns what wrapper to use for the loan's NFT
     * collateral contract.
     *
     * @param _nftCollateralContract - The address of the the NFT collateral contract.
     *
     * @return Address of the NftWrapper to use for the loan's NFT collateral.
     */
    function _getWrapper(address _nftCollateralContract) internal view returns (address) {
        return IPermittedNFTs(hub.getContract(ContractKeys.PERMITTED_NFTS)).getNFTWrapper(_nftCollateralContract);
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {DirectLoanFixedOffer, NFTfiSigningUtils} from "./DirectLoanFixedOffer.sol";
import {NFTfiCollectionOfferSigningUtils} from "../../../utils/NFTfiCollectionOfferSigningUtils.sol";

/**
 * @title  DirectLoanFixedCollectionOffer
 * @author NFTfi
 * @notice Main contract for NFTfi Direct Loans Fixed Collection Type.
 * This contract manages the ability to create reoccurring NFT-backed
 * peer-to-peer loans of type Fixed (agreed to be a fixed-repayment loan) where the borrower pays the
 * maximumRepaymentAmount regardless of whether they repay early or not.
 * In collection offer type loans the collateral can be any one item (id) of a given NFT collection (contract).
 *
 * To commence an NFT-backed loan:
 *
 * The borrower accepts a lender's offer by calling `acceptOffer`.
 *   1. the borrower calls nftContract.approveAll(NFTfi), approving the NFTfi contract to move their NFT's on their
 * be1alf.
 *   2. the lender calls erc20Contract.approve(NFTfi), allowing NFTfi to move the lender's ERC20 tokens on their
 * behalf.
 *   3. the lender signs a reusable off-chain message, proposing its collection offer terms.
 *   4. the borrower calls `acceptOffer` to accept these terms and enter into the loan. The NFT is stored in
 * the contract, the borrower receives the loan principal in the specified ERC20 currency, the lender receives an
 * NFTfi promissory note (in ERC721 form) that represents the rights to either the principal-plus-interest, or the
 * underlying NFT collateral if the borrower does not pay back in time, and the borrower receives obligation receipt
 * (in ERC721 form) that gives them the right to pay back the loan and get the collateral back.
 *  5. another borrower can also repeat step 4 until the original lender cancels or their
 * wallet runs out of funds with allowance to the contract
 *
 * The lender can freely transfer and trade this ERC721 promissory note as they wish, with the knowledge that
 * transferring the ERC721 promissory note tranfsers the rights to principal-plus-interest and/or collateral, and that
 * they will no longer have a claim on the loan. The ERC721 promissory note itself represents that claim.
 *
 * The borrower can freely transfer and trade this ERC721 obligaiton receipt as they wish, with the knowledge that
 * transferring the ERC721 obligaiton receipt tranfsers the rights right to pay back the loan and get the collateral
 * back.
 *
 *
 * A loan may end in one of two ways:
 * - First, a borrower may call NFTfi.payBackLoan() and pay back the loan plus interest at any time, in which case they
 * receive their NFT back in the same transaction.
 * - Second, if the loan's duration has passed and the loan has not been paid back yet, a lender can call
 * NFTfi.liquidateOverdueLoan(), in which case they receive the underlying NFT collateral and forfeit the rights to the
 * principal-plus-interest, which the borrower now keeps.
 */
contract DirectLoanFixedCollectionOffer is DirectLoanFixedOffer {
    /* ************* */
    /* CUSTOM ERRORS */
    /* ************* */

    error CollateralIdNotInRange();
    error MinIdGreaterThanMaxId();
    error OriginalAcceptOfferDisabled();

    /* *********** */
    /* CONSTRUCTOR */
    /* *********** */

    /**
     * @dev Sets `hub` and permitted erc20-s
     *
     * @param _admin - Initial admin of this contract.
     * @param  _nftfiHub - NFTfiHub address
     * @param  _permittedErc20s - list of permitted ERC20 token contract addresses
     */
    constructor(
        address _admin,
        address _nftfiHub,
        address[] memory _permittedErc20s
    ) DirectLoanFixedOffer(_admin, _nftfiHub, _permittedErc20s) {
        // solhint-disable-previous-line no-empty-blocks
    }

    /* ******************* */
    /* READ-ONLY FUNCTIONS */
    /* ******************* */

    /**
     * @notice This function returns a bytes32 value identifying the loan type for the coordinator
     */
    // all caps, because used to be a constant storage and the interface should be the same
    // solhint-disable-next-line func-name-mixedcase
    function LOAN_TYPE() public pure override returns (bytes32) {
        return bytes32("DIRECT_LOAN_FIXED_COLLECTION");
    }

    /**
     * @notice overriding to make it impossible to create a regular offer on this contract (only collection offers)
     */
    function acceptOffer(
        Offer memory,
        Signature memory,
        BorrowerSettings memory
    ) external override whenNotPaused nonReentrant returns (uint32) {
        revert OriginalAcceptOfferDisabled();
    }

    /**
     * @notice This function is called by the borrower when accepting a lender's collection offer to begin a loan.
     *
     * @param _offer - The offer made by the lender.
     * @param _signature - The components of the lender's signature.
     * stolen or otherwise unwanted items
     * @param _borrowerSettings - Some extra parameters that the borrower needs to set when accepting an offer.
     */
    function acceptCollectionOffer(
        Offer memory _offer,
        Signature memory _signature,
        BorrowerSettings memory _borrowerSettings
    ) external whenNotPaused nonReentrant {
        address nftWrapper = _getWrapper(_offer.nftCollateralContract);
        _loanSanityChecks(_offer, nftWrapper);
        _loanSanityChecksOffer(_offer);
        _acceptOffer(
            _setupLoanTerms(_offer, nftWrapper),
            _setupLoanExtras(_borrowerSettings.revenueSharePartner, _borrowerSettings.referralFeeInBasisPoints),
            _offer,
            _signature
        );
    }

    /**
     * @notice This function is called by the borrower when accepting a lender's
     * collection offer with a given id range to begin a loan
     *
     * @param _offer - The offer made by the lender.
     * @param _idRange - min and max (inclusive) Id ranges for collection offers on collections,
     * like ArtBlocks, where multiple collections are defined on one contract differentiated by id-ranges
     * @param _signature - The components of the lender's signature.
     * stolen or otherwise unwanted items
     * @param _borrowerSettings - Some extra parameters that the borrower needs to set when accepting an offer.
     */
    function acceptCollectionOfferWithIdRange(
        Offer memory _offer,
        CollectionIdRange memory _idRange,
        Signature memory _signature,
        BorrowerSettings memory _borrowerSettings
    ) external whenNotPaused nonReentrant {
        address nftWrapper = _getWrapper(_offer.nftCollateralContract);
        _loanSanityChecks(_offer, nftWrapper);
        _loanSanityChecksOffer(_offer);
        _idRangeSanityCheck(_idRange);
        _acceptOfferWithIdRange(
            _setupLoanTerms(_offer, nftWrapper),
            _setupLoanExtras(_borrowerSettings.revenueSharePartner, _borrowerSettings.referralFeeInBasisPoints),
            _offer,
            _idRange,
            _signature
        );
    }

    /* ****************** */
    /* INTERNAL FUNCTIONS */
    /* ****************** */

    /**
     * @notice This function is called by the borrower when accepting a lender's offer
     * to begin a loan with the public function acceptCollectionOffer.
     *
     * @param _loanTerms - The main Loan Terms struct. This data is saved upon loan creation on loanIdToLoan.
     * @param _loanExtras - The main Loan Terms struct. This data is saved upon loan creation on loanIdToLoanExtras.
     * @param _offer - The offer made by the lender.
     * @param _signature - The components of the lender's signature.
     * stolen or otherwise unwanted items
     */
    function _acceptOffer(
        LoanTerms memory _loanTerms,
        LoanExtras memory _loanExtras,
        Offer memory _offer,
        Signature memory _signature
    ) internal override returns (uint32) {
        // still checking the nonce for possible cancellations
        if (_nonceHasBeenUsedForUser[_signature.signer][_signature.nonce]) {
            revert InvalidNonce();
        }
        // Note that we are not invalidating the nonce as part of acceptOffer (as is the case for loan types in general)
        // since the nonce that the lender signed with remains valid for all loans for the collection offer

        Offer memory offerToCheck = _offer;

        offerToCheck.nftCollateralId = 0;

        if (!NFTfiSigningUtils.isValidLenderSignature(offerToCheck, _signature)) {
            revert InvalidLenderSignature();
        }

        uint32 loanId = _createLoan(
            LOAN_TYPE(),
            _loanTerms,
            _loanExtras,
            msg.sender,
            _signature.signer,
            _offer.referrer
        );

        // Emit an event with all relevant details from this transaction.
        emit LoanStarted(loanId, msg.sender, _signature.signer, _loanTerms, _loanExtras);

        return loanId;
    }

    /**
     * @notice This function is called by the borrower when accepting a lender's
     * collection offer with a given id range to begin a loan
     *
     * @param _loanTerms - The main Loan Terms struct. This data is saved upon loan creation on loanIdToLoan.
     * @param _loanExtras - The main Loan Terms struct. This data is saved upon loan creation on loanIdToLoanExtras.
     * @param _idRange - min and max (inclusive) Id ranges for collection offers on collections,
     * like ArtBlocks, where multiple collections are defined on one contract differentiated by id-ranges
     * @param _offer - The offer made by the lender.
     * @param _signature - The components of the lender's signature.
     * stolen or otherwise unwanted items
     */
    function _acceptOfferWithIdRange(
        LoanTerms memory _loanTerms,
        LoanExtras memory _loanExtras,
        Offer memory _offer,
        CollectionIdRange memory _idRange,
        Signature memory _signature
    ) internal {
        // still checking the nonce for possible cancellations
        if (_nonceHasBeenUsedForUser[_signature.signer][_signature.nonce]) {
            revert InvalidNonce();
        }
        // Note that we are not invalidating the nonce as part of acceptOffer (as is the case for loan types in general)
        // since the nonce that the lender signed with remains valid for all loans for the collection offer

        //check for id range
        if (_loanTerms.nftCollateralId < _idRange.minId || _loanTerms.nftCollateralId > _idRange.maxId) {
            revert CollateralIdNotInRange();
        }
        Offer memory offerToCheck = _offer;

        offerToCheck.nftCollateralId = 0;

        if (!NFTfiCollectionOfferSigningUtils.isValidLenderSignatureWithIdRange(offerToCheck, _idRange, _signature)) {
            revert InvalidLenderSignature();
        }

        uint32 loanId = _createLoan(
            LOAN_TYPE(),
            _loanTerms,
            _loanExtras,
            msg.sender,
            _signature.signer,
            _offer.referrer
        );

        // Emit an event with all relevant details from this transaction.
        emit LoanStarted(loanId, msg.sender, _signature.signer, _loanTerms, _loanExtras);
    }

    function _idRangeSanityCheck(CollectionIdRange memory _idRange) internal pure {
        if (_idRange.minId > _idRange.maxId) {
            revert MinIdGreaterThanMaxId();
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

// "compiler": "0.7.4" (or greater)
import {
    DirectLoanBaseMinimal,
    NFTfiSigningUtils,
    LoanChecksAndCalculations,
    LoanData
} from "./DirectLoanBaseMinimal.sol";
import {ContractKeys} from "../../../utils/ContractKeys.sol";

/**
 * @title  DirectLoanFixedOffer
 * @author NFTfi
 * @notice Main contract for NFTfi Direct Loans Fixed Type. This contract manages the ability to create NFT-backed
 * peer-to-peer loans of type Fixed (agreed to be a fixed-repayment loan) where the borrower pays the
 * maximumRepaymentAmount regardless of whether they repay early or not.
 *
 * There are two ways to commence an NFT-backed loan:
 *
 * a. The borrower accepts a lender's offer by calling `acceptOffer`.
 *   1. the borrower calls nftContract.approveAll(NFTfi), approving the NFTfi contract to move their NFT's on their
 * be1alf.
 *   2. the lender calls erc20Contract.approve(NFTfi), allowing NFTfi to move the lender's ERC20 tokens on their
 * behalf.
 *   3. the lender signs an off-chain message, proposing its offer terms.
 *   4. the borrower calls `acceptOffer` to accept these terms and enter into the loan. The NFT is stored in
 * the contract, the borrower receives the loan principal in the specified ERC20 currency, the lender receives an
 * NFTfi promissory note (in ERC721 form) that represents the rights to either the principal-plus-interest, or the
 * underlying NFT collateral if the borrower does not pay back in time, and the borrower receives obligation receipt
 * (in ERC721 form) that gives them the right to pay back the loan and get the collateral back.
 *
 * The lender can freely transfer and trade this ERC721 promissory note as they wish, with the knowledge that
 * transferring the ERC721 promissory note tranfsers the rights to principal-plus-interest and/or collateral, and that
 * they will no longer have a claim on the loan. The ERC721 promissory note itself represents that claim.
 *
 * The borrower can freely transfer and trade this ERC721 obligaiton receipt as they wish, with the knowledge that
 * transferring the ERC721 obligaiton receipt tranfsers the rights right to pay back the loan and get the collateral
 * back.
 *
 *
 * A loan may end in one of two ways:
 * - First, a borrower may call NFTfi.payBackLoan() and pay back the loan plus interest at any time, in which case they
 * receive their NFT back in the same transaction.
 * - Second, if the loan's duration has passed and the loan has not been paid back yet, a lender can call
 * NFTfi.liquidateOverdueLoan(), in which case they receive the underlying NFT collateral and forfeit the rights to the
 * principal-plus-interest, which the borrower now keeps.
 */
contract DirectLoanFixedOffer is DirectLoanBaseMinimal {
    /* ************* */
    /* CUSTOM ERRORS */
    /* ************* */

    error InvalidLenderSignature();
    error NegativeInterestRate();

    /* *********** */
    /* CONSTRUCTOR */
    /* *********** */

    /**
     * @dev Sets `hub` and permitted erc20-s
     *
     * @param _admin - Initial admin of this contract.
     * @param  _nftfiHub - NFTfiHub address
     * @param  _permittedErc20s - list of permitted ERC20 token contract addresses
     */
    constructor(
        address _admin,
        address _nftfiHub,
        address[] memory _permittedErc20s
    )
        DirectLoanBaseMinimal(
            _admin,
            _nftfiHub,
            ContractKeys.getIdFromStringKey("DIRECT_LOAN_COORDINATOR"),
            _permittedErc20s
        )
    {
        // solhint-disable-previous-line no-empty-blocks
    }

    /* ********* */
    /* FUNCTIONS */
    /* ********* */

    /**
     * @notice This function is called by the borrower when accepting a lender's offer to begin a loan.
     *
     * @param _offer - The offer made by the lender.
     * @param _signature - The components of the lender's signature.
     * @param _borrowerSettings - Some extra parameters that the borrower needs to set when accepting an offer.
     */
    function acceptOffer(
        Offer memory _offer,
        Signature memory _signature,
        BorrowerSettings memory _borrowerSettings
    ) external virtual whenNotPaused nonReentrant returns (uint32) {
        address nftWrapper = _getWrapper(_offer.nftCollateralContract);
        _loanSanityChecks(_offer, nftWrapper);
        _loanSanityChecksOffer(_offer);
        return
            _acceptOffer(
                _setupLoanTerms(_offer, nftWrapper),
                _setupLoanExtras(_borrowerSettings.revenueSharePartner, _borrowerSettings.referralFeeInBasisPoints),
                _offer,
                _signature
            );
    }

    /* ******************* */
    /* READ-ONLY FUNCTIONS */
    /* ******************* */

    /**
     * @notice This function returns a bytes32 value identifying the loan type for the coordinator
     */
    // all caps, because used to be a constant storage and the interface should be the same
    // solhint-disable-next-line func-name-mixedcase
    function LOAN_TYPE() public pure virtual returns (bytes32) {
        return bytes32("DIRECT_LOAN_FIXED_OFFER");
    }

    /**
     * @notice This function can be used to view the current quantity of the ERC20 currency used in the specified loan
     * required by the borrower to repay their loan, measured in the smallest unit of the ERC20 currency.
     *
     * @param _loanId  A unique identifier for this particular loan, sourced from the Loan Coordinator.
     *
     * @return The amount of the specified ERC20 currency required to pay back this loan, measured in the smallest unit
     * of the specified ERC20 currency.
     */
    function getPayoffAmount(uint32 _loanId) external view override returns (uint256) {
        LoanTerms storage loan = loanIdToLoan[_loanId];
        return loan.maximumRepaymentAmount;
    }

    /* ****************** */
    /* INTERNAL FUNCTIONS */
    /* ****************** */

    /**
     * @notice This function is called by the borrower when accepting a lender's offer to begin a loan.
     *
     * @param _loanTerms - The main Loan Terms struct. This data is saved upon loan creation on loanIdToLoan.
     * @param _loanExtras - The main Loan Terms struct. This data is saved upon loan creation on loanIdToLoanExtras.
     * @param _offer - The offer made by the lender.
     * @param _signature - The components of the lender's signature.
     */
    function _acceptOffer(
        LoanTerms memory _loanTerms,
        LoanExtras memory _loanExtras,
        Offer memory _offer,
        Signature memory _signature
    ) internal virtual returns (uint32) {
        // Check loan nonces. These are different from Ethereum account nonces.
        // Here, these are uint256 numbers that should uniquely identify
        // each signature for each user (i.e. each user should only create one
        // off-chain signature for each nonce, with a nonce being any arbitrary
        // uint256 value that they have not used yet for an off-chain NFTfi
        // signature).
        if (_nonceHasBeenUsedForUser[_signature.signer][_signature.nonce]) {
            revert InvalidNonce();
        }

        _nonceHasBeenUsedForUser[_signature.signer][_signature.nonce] = true;

        if (!NFTfiSigningUtils.isValidLenderSignature(_offer, _signature)) {
            revert InvalidLenderSignature();
        }

        uint32 loanId = _createLoan(
            LOAN_TYPE(),
            _loanTerms,
            _loanExtras,
            msg.sender,
            _signature.signer,
            _offer.referrer
        );

        // Emit an event with all relevant details from this transaction.
        emit LoanStarted(loanId, msg.sender, _signature.signer, _loanTerms, _loanExtras);
        return loanId;
    }

    /**
     * @dev Creates a `LoanTerms` struct using data sent as the lender's `_offer` on `acceptOffer`.
     * This is needed in order to avoid stack too deep issues.
     * Since this is a Fixed loan type loanInterestRateForDurationInBasisPoints is ignored.
     */
    function _setupLoanTerms(Offer memory _offer, address _nftWrapper) internal view returns (LoanTerms memory) {
        return
            LoanTerms({
                loanERC20Denomination: _offer.loanERC20Denomination,
                loanPrincipalAmount: _offer.loanPrincipalAmount,
                maximumRepaymentAmount: _offer.maximumRepaymentAmount,
                nftCollateralContract: _offer.nftCollateralContract,
                nftCollateralWrapper: _nftWrapper,
                nftCollateralId: _offer.nftCollateralId,
                loanStartTime: uint64(block.timestamp),
                loanDuration: _offer.loanDuration,
                loanInterestRateForDurationInBasisPoints: uint16(0),
                loanAdminFeeInBasisPoints: _offer.loanAdminFeeInBasisPoints,
                borrower: msg.sender
            });
    }

    /**
     * @dev Calculates the payoff amount and admin fee
     *
     * @param _loanTerms - Struct containing all the loan's parameters
     */
    function _payoffAndFee(
        LoanTerms memory _loanTerms
    ) internal pure override returns (uint256 adminFee, uint256 payoffAmount) {
        // Calculate amounts to send to lender and admins
        uint256 interestDue = _loanTerms.maximumRepaymentAmount - _loanTerms.loanPrincipalAmount;
        adminFee = LoanChecksAndCalculations.computeAdminFee(
            interestDue,
            uint256(_loanTerms.loanAdminFeeInBasisPoints)
        );
        payoffAmount = _loanTerms.maximumRepaymentAmount - adminFee;
    }

    /**
     * @dev Function that performs some validation checks over loan parameters when accepting an offer
     *
     */
    function _loanSanityChecksOffer(LoanData.Offer memory _offer) internal pure {
        if (_offer.maximumRepaymentAmount < _offer.loanPrincipalAmount) {
            revert NegativeInterestRate();
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

interface IDirectLoanBase {
    function maximumLoanDuration() external view returns (uint256);

    function adminFeeInBasisPoints() external view returns (uint16);

    // solhint-disable-next-line func-name-mixedcase
    function LOAN_COORDINATOR() external view returns (bytes32);

    function loanIdToLoan(
        uint32
    )
        external
        view
        returns (uint256, uint256, uint256, address, uint32, uint16, uint16, address, uint64, address, address);

    function loanRepaidOrLiquidated(uint32) external view returns (bool);

    function getWhetherNonceHasBeenUsedForUser(address _user, uint256 _nonce) external view returns (bool);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {IDirectLoanBase} from "./IDirectLoanBase.sol";
import {LoanData} from "./LoanData.sol";
import {IDirectLoanCoordinator} from "../../../interfaces/IDirectLoanCoordinator.sol";
import {ContractKeys} from "../../../utils/ContractKeys.sol";
import {INftfiHub} from "../../../interfaces/INftfiHub.sol";
import {IPermittedPartners} from "../../../interfaces/IPermittedPartners.sol";

import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";

/**
 * @title  LoanChecksAndCalculations
 * @author NFTfi
 * @notice Helper library for LoanBase
 */
library LoanChecksAndCalculations {
    uint16 private constant HUNDRED_PERCENT = 10000;

    /**
     * @dev Function that performs some validation checks before trying to repay a loan
     *
     * @param _loanId - The id of the loan being repaid
     */
    function payBackChecks(uint32 _loanId, INftfiHub _hub) external view {
        checkLoanIdValidity(_loanId, _hub);
        // Sanity check that payBackLoan() and liquidateOverdueLoan() have never been called on this loanId.
        // Depending on how the rest of the code turns out, this check may be unnecessary.
        // solhint-disable-next-line custom-errors
        require(!IDirectLoanBase(address(this)).loanRepaidOrLiquidated(_loanId), "Loan already repaid/liquidated");

        // Fetch loan details from storage, but store them in memory for the sake of saving gas.
        (, , , , uint32 loanDuration, , , , uint64 loanStartTime, , ) = IDirectLoanBase(address(this)).loanIdToLoan(
            _loanId
        );

        // When a loan exceeds the loan term, it is expired. At this stage the Lender can call Liquidate Loan to resolve
        // the loan.
        // solhint-disable-next-line custom-errors
        require(block.timestamp <= (uint256(loanStartTime) + uint256(loanDuration)), "Loan is expired");
    }

    function checkLoanIdValidity(uint32 _loanId, INftfiHub _hub) public view {
        // solhint-disable-next-line custom-errors
        require(
            IDirectLoanCoordinator(_hub.getContract(IDirectLoanBase(address(this)).LOAN_COORDINATOR())).isValidLoanId(
                _loanId,
                address(this)
            ),
            "invalid loanId"
        );
    }

    /**
     * @dev Function that the partner is permitted and returns its shared percent.
     *
     * @param _revenueSharePartner - Partner's address
     *
     * @return The revenue share percent for the partner.
     */
    function getRevenueSharePercent(address _revenueSharePartner, INftfiHub _hub) external view returns (uint16) {
        // return soon if no partner is set to avoid a public call
        if (_revenueSharePartner == address(0)) {
            return 0;
        }

        uint16 revenueSharePercent = IPermittedPartners(_hub.getContract(ContractKeys.PERMITTED_PARTNERS))
            .getPartnerPermit(_revenueSharePartner);

        return revenueSharePercent;
    }

    /**
     * @dev Performs some validation checks before trying to renegotiate a loan.
     * Needed to avoid stack too deep.
     *
     * @param _loan - The main Loan Terms struct.
     * @param _loanId - The unique identifier for the loan to be renegotiated
     * @param _newLoanDuration - The new amount of time (measured in seconds) that can elapse before the lender can
     * liquidate the loan and seize the underlying collateral NFT.
     * @param _newMaximumRepaymentAmount - The new maximum amount of money that the borrower would be required to
     * retrieve their collateral, measured in the smallest units of the ERC20 currency used for the loan. The
     * borrower will always have to pay this amount to retrieve their collateral, regardless of whether they repay
     * early.
     * @param _lenderNonce - The nonce referred to here is not the same as an Ethereum account's nonce. We are
     * referring instead to nonces that are used by both the lender and the borrower when they are first signing
     * off-chain NFTfi orders. These nonces can be any uint256 value that the user has not previously used to sign an
     * off-chain order. Each nonce can be used at most once per user within NFTfi, regardless of whether they are the
     * lender or the borrower in that situation. This serves two purposes:
     * - First, it prevents replay attacks where an attacker would submit a user's off-chain order more than once.
     * - Second, it allows a user to cancel an off-chain order by calling NFTfi.cancelLoanCommitmentBeforeLoanHasBegun()
     , which marks the nonce as used and prevents any future loan from using the user's off-chain order that contains
     * that nonce.
     * @return Borrower and Lender addresses
     */
    function renegotiationChecks(
        LoanData.LoanTerms memory _loan,
        uint32 _loanId,
        uint32 _newLoanDuration,
        uint256 _newMaximumRepaymentAmount,
        uint256 _lenderNonce,
        INftfiHub _hub
    ) external view returns (address, address) {
        checkLoanIdValidity(_loanId, _hub);
        IDirectLoanCoordinator loanCoordinator = IDirectLoanCoordinator(
            _hub.getContract(IDirectLoanBase(address(this)).LOAN_COORDINATOR())
        );
        uint256 smartNftId = loanCoordinator.getLoanData(_loanId).smartNftId;

        address borrower;

        if (_loan.borrower != address(0)) {
            borrower = _loan.borrower;
        } else {
            borrower = IERC721(loanCoordinator.obligationReceiptToken()).ownerOf(smartNftId);
        }

        // solhint-disable-next-line custom-errors
        require(msg.sender == borrower, "Only borrower can initiate");
        // solhint-disable-next-line custom-errors
        require(block.timestamp <= (uint256(_loan.loanStartTime) + _newLoanDuration), "New duration already expired");
        // solhint-disable-next-line custom-errors
        require(
            uint256(_newLoanDuration) <= IDirectLoanBase(address(this)).maximumLoanDuration(),
            "New duration exceeds maximum loan duration"
        );
        // solhint-disable-next-line custom-errors
        require(!IDirectLoanBase(address(this)).loanRepaidOrLiquidated(_loanId), "Loan already repaid/liquidated");
        // solhint-disable-next-line custom-errors
        require(
            _newMaximumRepaymentAmount >= _loan.loanPrincipalAmount,
            "Negative interest rate loans are not allowed."
        );

        // Fetch current owner of loan promissory note.
        address lender = IERC721(loanCoordinator.promissoryNoteToken()).ownerOf(smartNftId);

        // solhint-disable-next-line custom-errors
        require(
            !IDirectLoanBase(address(this)).getWhetherNonceHasBeenUsedForUser(lender, _lenderNonce),
            "Lender nonce invalid"
        );

        return (borrower, lender);
    }

    /**
     * @notice A convenience function computing the revenue share taken from the admin fee to transferr to the permitted
     * partner.
     *
     * @param _adminFee - The quantity of ERC20 currency (measured in smalled units of that ERC20 currency) that is due
     * as an admin fee.
     * @param _revenueShareInBasisPoints - The percent (measured in basis points) of the admin fee amount that will be
     * taken as a revenue share for a the partner, at the moment the loan is begun.
     *
     * @return The quantity of ERC20 currency (measured in smalled units of that ERC20 currency) that should be sent to
     * the `revenueSharePartner`.
     */
    function computeRevenueShare(
        uint256 _adminFee,
        uint256 _revenueShareInBasisPoints
    ) external pure returns (uint256) {
        return (_adminFee * _revenueShareInBasisPoints) / HUNDRED_PERCENT;
    }

    /**
     * @notice A convenience function computing the adminFee taken from a specified quantity of interest.
     *
     * @param _interestDue - The amount of interest due, measured in the smallest quantity of the ERC20 currency being
     * used to pay the interest.
     * @param _adminFeeInBasisPoints - The percent (measured in basis points) of the interest earned that will be taken
     * as a fee by the contract admins when the loan is repaid. The fee is stored in the loan struct to prevent an
     * attack where the contract admins could adjust the fee right before a loan is repaid, and take all of the interest
     * earned.
     *
     * @return The quantity of ERC20 currency (measured in smalled units of that ERC20 currency) that is due as an admin
     * fee.
     */
    function computeAdminFee(uint256 _interestDue, uint256 _adminFeeInBasisPoints) external pure returns (uint256) {
        return (_interestDue * _adminFeeInBasisPoints) / HUNDRED_PERCENT;
    }

    /**
     * @notice A convenience function computing the referral fee taken from the loan principal amount to transferr to
     * the referrer.
     *
     * @param _loanPrincipalAmount - The original sum of money transferred from lender to borrower at the beginning of
     * the loan, measured in loanERC20Denomination's smallest units.
     * @param _referralFeeInBasisPoints - The percent (measured in basis points) of the loan principal amount that will
     * be taken as a fee to pay to the referrer, 0 if the lender is not paying referral fee.
     * @param _referrer - The address of the referrer who found the lender matching the listing, Zero address to signal
     * that there is no referrer.
     *
     * @return The quantity of ERC20 currency (measured in smalled units of that ERC20 currency) that should be sent to
     * the referrer.
     */
    function computeReferralFee(
        uint256 _loanPrincipalAmount,
        uint256 _referralFeeInBasisPoints,
        address _referrer
    ) external pure returns (uint256) {
        if (_referralFeeInBasisPoints == 0 || _referrer == address(0)) {
            return 0;
        }
        return (_loanPrincipalAmount * _referralFeeInBasisPoints) / HUNDRED_PERCENT;
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

/**
 * @title  LoanData
 * @author NFTfi
 * @notice An interface containg the main Loan struct shared by Direct Loans types.
 */
interface LoanData {
    /* ********** */
    /* DATA TYPES */
    /* ********** */

    /**
     * @notice The main Loan Terms struct. This data is saved upon loan creation.
     *
     * @param loanERC20Denomination - The address of the ERC20 contract of the currency being used as principal/interest
     * for this loan.
     * @param loanPrincipalAmount - The original sum of money transferred from lender to borrower at the beginning of
     * the loan, measured in loanERC20Denomination's smallest units.
     * @param maximumRepaymentAmount - The maximum amount of money that the borrower would be required to retrieve their
     * collateral, measured in the smallest units of the ERC20 currency used for the loan. The borrower will always have
     * to pay this amount to retrieve their collateral, regardless of whether they repay early.
     * @param nftCollateralContract - The address of the the NFT collateral contract.
     * @param nftCollateralWrapper - The NFTfi wrapper of the NFT collateral contract.
     * @param nftCollateralId - The ID within the NFTCollateralContract for the NFT being used as collateral for this
     * loan. The NFT is stored within this contract during the duration of the loan.
     * @param loanStartTime - The block.timestamp when the loan first began (measured in seconds).
     * @param loanDuration - The amount of time (measured in seconds) that can elapse before the lender can liquidate
     * the loan and seize the underlying collateral NFT.
     * @param loanInterestRateForDurationInBasisPoints - This is the interest rate (measured in basis points, e.g.
     * hundreths of a percent) for the loan, that must be repaid pro-rata by the borrower at the conclusion of the loan
     * or risk seizure of their nft collateral. Note if the type of the loan is fixed then this value  is not used and
     * is irrelevant so it should be set to 0.
     * @param loanAdminFeeInBasisPoints - The percent (measured in basis points) of the interest earned that will be
     * taken as a fee by the contract admins when the loan is repaid. The fee is stored in the loan struct to prevent an
     * attack where the contract admins could adjust the fee right before a loan is repaid, and take all of the interest
     * earned.
     * @param borrower
     */
    struct LoanTerms {
        uint256 loanPrincipalAmount;
        uint256 maximumRepaymentAmount;
        uint256 nftCollateralId;
        address loanERC20Denomination;
        uint32 loanDuration;
        uint16 loanInterestRateForDurationInBasisPoints;
        uint16 loanAdminFeeInBasisPoints;
        address nftCollateralWrapper;
        uint64 loanStartTime;
        address nftCollateralContract;
        address borrower;
    }

    /**
     * @notice Some extra Loan's settings struct. This data is saved upon loan creation.
     * We need this to avoid stack too deep errors.
     *
     * @param revenueSharePartner - The address of the partner that will receive the revenue share.
     * @param revenueShareInBasisPoints - The percent (measured in basis points) of the admin fee amount that will be
     * taken as a revenue share for a t
     * @param referralFeeInBasisPoints - The percent (measured in basis points) of the loan principal amount that will
     * be taken as a fee to pay to the referrer, 0 if the lender is not paying referral fee.he partner, at the moment
     * the loan is begun.
     */
    struct LoanExtras {
        address revenueSharePartner;
        uint16 revenueShareInBasisPoints;
        uint16 referralFeeInBasisPoints;
    }

    /**
     * @notice The offer made by the lender. Used as parameter on both acceptOffer (initiated by the borrower)
     *
     * @param loanERC20Denomination - The address of the ERC20 contract of the currency being used as principal/interest
     * for this loan.
     * @param loanPrincipalAmount - The original sum of money transferred from lender to borrower at the beginning of
     * the loan, measured in loanERC20Denomination's smallest units.
     * @param maximumRepaymentAmount - The maximum amount of money that the borrower would be required to retrieve their
     *  collateral, measured in the smallest units of the ERC20 currency used for the loan. The borrower will always
     * have to pay this amount to retrieve their collateral, regardless of whether they repay early.
     * @param nftCollateralContract - The address of the ERC721 contract of the NFT collateral.
     * @param nftCollateralId - The ID within the NFTCollateralContract for the NFT being used as collateral for this
     * loan. The NFT is stored within this contract during the duration of the loan.
     * @param referrer - The address of the referrer who found the lender matching the listing, Zero address to signal
     * this there is no referrer.
     * @param loanDuration - The amount of time (measured in seconds) that can elapse before the lender can liquidate
     * the loan and seize the underlying collateral NFT.
     * @param loanAdminFeeInBasisPoints - The percent (measured in basis points) of the interest earned that will be
     * taken as a fee by the contract admins when the loan is repaid. The fee is stored in the loan struct to prevent an
     * attack where the contract admins could adjust the fee right before a loan is repaid, and take all of the interest
     * earned.
     */
    struct Offer {
        uint256 loanPrincipalAmount;
        uint256 maximumRepaymentAmount;
        uint256 nftCollateralId;
        address nftCollateralContract;
        uint32 loanDuration;
        uint16 loanAdminFeeInBasisPoints;
        address loanERC20Denomination;
        address referrer;
    }

    /**
     * @notice Signature related params. Used as parameter on both acceptOffer (containing borrower signature)
     *
     * @param signer - The address of the signer. The borrower for `acceptOffer`
     * @param nonce - The nonce referred here is not the same as an Ethereum account's nonce.
     * We are referring instead to a nonce that is used by the lender or the borrower when they are first signing
     * off-chain NFTfi orders. These nonce can be any uint256 value that the user has not previously used to sign an
     * off-chain order. Each nonce can be used at most once per user within NFTfi, regardless of whether they are the
     * lender or the borrower in that situation. This serves two purposes:
     * - First, it prevents replay attacks where an attacker would submit a user's off-chain order more than once.
     * - Second, it allows a user to cancel an off-chain order by calling NFTfi.cancelLoanCommitmentBeforeLoanHasBegun()
     * , which marks the nonce as used and prevents any future loan from using the user's off-chain order that contains
     * that nonce.
     * @param expiry - Date when the signature expires
     * @param signature - The ECDSA signature of the borrower or the lender, obtained off-chain ahead of time, signing
     * the following combination of parameters:
     * - Lender:
     *   - Offer.loanERC20Denomination
     *   - Offer.loanPrincipalAmount
     *   - Offer.maximumRepaymentAmount
     *   - Offer.nftCollateralContract
     *   - Offer.nftCollateralId
     *   - Offer.referrer
     *   - Offer.loanDuration
     *   - Offer.loanAdminFeeInBasisPoints
     *   - Signature.signer,
     *   - Signature.nonce,
     *   - Signature.expiry,
     *   - address of the loan type contract
     *   - chainId
     */
    struct Signature {
        uint256 nonce;
        uint256 expiry;
        address signer;
        bytes signature;
    }

    /**
     * inclusive min and max Id ranges for collection offers on collections,
     * like ArtBlocks, where multiple collections are defined on one contract differentiated by id-ranges
     */
    struct CollectionIdRange {
        uint256 minId;
        uint256 maxId;
    }

    /**
     * @notice Some extra parameters that the borrower needs to set when accepting an offer.
     *
     * @param revenueSharePartner - The address of the partner that will receive the revenue share.
     * @param referralFeeInBasisPoints - The percent (measured in basis points) of the loan principal amount that will
     * be taken as a fee to pay to the referrer, 0 if the lender is not paying referral fee.
     */
    struct BorrowerSettings {
        address revenueSharePartner;
        uint16 referralFeeInBasisPoints;
    }
}

// SPDX-License-Identifier: BUSL-1.1

import {IFlashloan} from "./IFlashloan.sol";
import {ISoloMargin} from "./ISoloMargin.sol";
import {Refinancing} from "../Refinancing.sol";
import {LoanData} from "../../loans/direct/loanTypes/LoanData.sol";

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

pragma solidity 0.8.19;

/**
 * @title Flashloan
 * @author NFTfi
 * @dev This contract allows for executing flash loans using the dYdX lending protocol.
 * It handles the initiation of the flash loans.
 */
abstract contract Flashloan is IFlashloan {
    // The address of the SoloMargin contract for executing flash loans.
    // solhint-disable-next-line immutable-vars-naming
    ISoloMargin public immutable soloMargin;

    // Mapping to keep track of tokens that can be flash loaned. (tokenAddress => isFlashloanble)
    mapping(address => bool) public tokenFlashloanble;
    // Mapping to keep track of market ids for each token. (tokenAddress => marketId)
    mapping(address => uint256) public marketIds;

    // Flash loan fee amount. Can be 0
    uint256 public flashloanFee;

    /**
     * @dev Contract constructor that sets the SoloMargin contract and the flash loan fee.
     * @param _soloMargin The address of the SoloMargin contract. (dYdX)
     * @param _flashloanFee The amount of the flash loan fee.
     */
    constructor(address _soloMargin, uint256 _flashloanFee) {
        soloMargin = ISoloMargin(_soloMargin);
        flashloanFee = _flashloanFee;
        if (_soloMargin != address(0)) {
            _loadTokens(_soloMargin);
        }
    }

    /**
     * @dev Loads tokens that can be flash loaned from the SoloMargin contract.
     * It uses the private _loadTokens function to populate the tokenFlashloanble and marketIds mappings.
     */
    function loadTokens() public {
        _loadTokens(address(soloMargin));
    }

    /**
     * @dev Helper function that populates the tokenFlashloanble and marketIds mappings.
     * @param _soloMargin The address of the SoloMargin contract.
     */
    function _loadTokens(address _soloMargin) private {
        for (uint256 i; i <= 3; ++i) {
            address tokenAddress = ISoloMargin(_soloMargin).getMarketTokenAddress(i);
            tokenFlashloanble[tokenAddress] = true;
            marketIds[tokenAddress] = i;
        }
    }

    /**
     * @dev Initiates a flash loan operation. Constructs an
     * operations array containing Withdraw, Call, and Deposit actions.
     * Then it approves the token transfer and calls the operate function on the soloMargin contract.
     * @param _borrower The address of the borrower.
     * @param _token The token to be flash loaned.
     * @param _amount The amount to be flash loaned.
     * @param _refinancingData Data related to the refinancing operation.
     * @param _offer The loan offer details.
     * @param _lenderSignature The lender's signature for the loan.
     * @param _borrowerSettings The borrower's settings for the loan.
     */
    function _flashLoan(
        address _borrower,
        address _token,
        uint256 _amount,
        bool _swapping,
        Refinancing.TargetLoanType _targetLoanType,
        Refinancing.RefinancingData memory _refinancingData,
        LoanData.Offer memory _offer,
        LoanData.CollectionIdRange memory _idRange,
        LoanData.Signature memory _lenderSignature,
        LoanData.BorrowerSettings memory _borrowerSettings
    ) internal {
        /*
        The flash loan functionality in dydx is predicated by their "operate" function,
        which takes a list of operations to execute, and defers validating the state of
        things until it's done executing them.
        
        We thus create three operations, a Withdraw (which loans us the funds), a Call
        (which invokes the callFunction method on this contract), and a Deposit (which
        repays the loan, plus the 2 wei fee), and pass them all to "operate".
        
        Note that the Deposit operation will invoke the transferFrom to pay the loan 
        (or whatever amount it was initialised with) back to itself, there is no need
        to pay it back explicitly.
        
        The loan must be given as an ERC-20 token, so WETH is used instead of ETH. Other
        currencies (DAI, USDC) are also available, their index can be looked up by
        calling getMarketTokenAddress on the solo margin contract, and set as the 
        primaryMarketId in the Withdraw and Deposit definitions.
        */

        uint256 primaryMarketId = marketIds[_token];

        ActionArgs[] memory operations = new ActionArgs[](3);

        operations[0] = ActionArgs({
            actionType: ActionType.Withdraw,
            accountId: 0,
            amount: AssetAmount({
                sign: false,
                denomination: AssetDenomination.Wei,
                ref: AssetReference.Delta,
                value: _amount // Amount to borrow
            }),
            primaryMarketId: primaryMarketId,
            secondaryMarketId: 0,
            otherAddress: address(this),
            otherAccountId: 0,
            data: ""
        });

        operations[1] = ActionArgs({
            actionType: ActionType.Call,
            accountId: 0,
            amount: AssetAmount({
                sign: false,
                denomination: AssetDenomination.Wei,
                ref: AssetReference.Delta,
                value: 0
            }),
            primaryMarketId: primaryMarketId,
            secondaryMarketId: 0,
            otherAddress: address(this),
            otherAccountId: 0,
            data: abi.encode(
                _borrower,
                _token,
                _amount,
                _swapping,
                _targetLoanType,
                _refinancingData,
                _offer,
                _idRange,
                _lenderSignature,
                _borrowerSettings
            )
        });

        operations[2] = ActionArgs({
            actionType: ActionType.Deposit,
            accountId: 0,
            amount: AssetAmount({
                sign: true,
                denomination: AssetDenomination.Wei,
                ref: AssetReference.Delta,
                value: _amount + flashloanFee
            }),
            primaryMarketId: primaryMarketId,
            secondaryMarketId: 0,
            otherAddress: address(this),
            otherAccountId: 0,
            data: ""
        });

        IERC20(_token).approve(address(soloMargin), _amount + flashloanFee);

        AccountInfo[] memory accountInfos = new AccountInfo[](1);
        accountInfos[0] = AccountInfo({owner: address(this), number: 1});

        soloMargin.operate(accountInfos, operations);
    }

    /**
     * @dev This function is called by the dYdX protocol after the loan is given.
     * It is intended to be overridden in a derived contract to implement custom logic.
     * @param sender The address initiating the call.
     * @param accountInfo Account related information.
     * @param data The data passed in the call.
     */
    function callFunction(address sender, AccountInfo memory accountInfo, bytes memory data) external virtual override {
        // solhint-disable-previous-line no-empty-blocks
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

/**
 * @title IFlashloan
 * @author NFTfi
 * @dev This is an interface for the Flashloan contract.
 * It includes the definitions for data types and function used in the flashloan operations.
 */
interface IFlashloan {
    /**
     * @dev Enum representing the denomination of an asset.
     * Assets can be denominated in Wei or Par.
     */
    enum AssetDenomination {
        Wei,
        Par
    }

    /**
     * @dev Enum representing the reference of an asset amount.
     * Assets can be referenced by a delta (change in value) or target (final value).
     */
    enum AssetReference {
        Delta,
        Target
    }

    /**
     * @dev Enum representing the type of action to be performed.
     * This can be any one among several options including Deposit, Withdraw, Transfer, etc.
     */
    enum ActionType {
        Deposit,
        Withdraw,
        Transfer,
        Buy,
        Sell,
        Trade,
        Liquidate,
        Vaporize,
        Call
    }

    /**
     * @dev Struct representing an asset amount for an action.
     * It includes information about the sign (positive/negative),
     * denomination (Wei/Par), reference (Delta/Target), and the value.
     */
    struct AssetAmount {
        bool sign;
        AssetDenomination denomination;
        AssetReference ref;
        uint256 value;
    }

    /**
     * @dev Struct representing an action.
     * It includes information about the type of action, the accountId,
     * the amount of the asset, market ids, address of the other party,
     * the other account's id, and any additional data.
     */
    struct ActionArgs {
        ActionType actionType;
        uint256 accountId;
        AssetAmount amount;
        uint256 primaryMarketId;
        uint256 secondaryMarketId;
        address otherAddress;
        uint256 otherAccountId;
        bytes data;
    }

    /**
     * @dev Struct representing the account information.
     * It includes the owner's address and the account number.
     */
    struct AccountInfo {
        address owner;
        uint256 number;
    }

    /**
     * @dev Function that is called after a flash loan operation.
     * @param sender The address initiating the call.
     * @param accountInfo Account related information.
     * @param data The data passed in the call.
     */
    function callFunction(address sender, AccountInfo memory accountInfo, bytes memory data) external;
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {IFlashloan} from "./IFlashloan.sol";

/**
 * @title ISoloMargin
 * @author NFTfi
 * @dev Interface for dYdX's SoloMargin contract.
 * It includes essential methods needed to interact with the SoloMargin contract.
 * These methods are used for initiating flash loans and getting token address of the market.
 */
interface ISoloMargin {
    /**
     * @dev Function to bundle multiple operations in a single transaction.
     * The operations are executed atomically and the state is maintained to ensure protocol's solvency.
     * @param accounts An array of AccountInfo objects, which contains the address and number of each account involved.
     * @param actions An array of ActionArgs objects, representing the actions to be executed.
     */
    function operate(IFlashloan.AccountInfo[] memory accounts, IFlashloan.ActionArgs[] memory actions) external;

    /**
     * @dev Function to get the token address of the market based on the given marketId.
     * @param marketId The ID of the market to get the token address for.
     * @return Address of the token for the specified market.
     */
    function getMarketTokenAddress(uint256 marketId) external view returns (address);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

/**
 * @title IRefinancingAdapter
 * @author NFTfi
 *
 * @dev This is the interface for Refinancing Adapters. It provides several methods for managing and retrieving
 * information about contracts that are eligible for refinancing.
 *
 * Adapters should implement this interface
 */
interface IRefinancingAdapter {
    /**
     * @dev Returns the borrower's address for a specific refinancable
     *
     * @param _refinanceableContract Address of the contract containing the refinanceable
     * @param _refinancableIdentifier Unique identifier for the refinanceable.
     *
     * @return Address of the borrower.
     */
    function getBorrowerAddress(
        address _refinanceableContract,
        uint256 _refinancableIdentifier
    ) external returns (address);

    /**
     * @dev Transfers the role of borrower to refinancing contract for a specific refinanceable.
     *
     * @param _refinanceableContract Address of the contract containing the refinanceable
     * @param _refinancableIdentifier Unique identifier for the loan.
     *
     * @return True if the operation was successful.
     */
    function transferBorrowerRole(
        address _refinanceableContract,
        uint256 _refinancableIdentifier
    ) external returns (bool);

    /**
     * @dev Pays off a refinanceable with a specified amount of a specified token.
     *
     * @param _refinanceableContract Address of the contract containing the refinanceable
     * @param _refinancableIdentifier Unique identifier for the refinanceable.
     * @param _payBackToken Token used to pay back the refinanceable.
     * @param _payBackAmount Amount of tokens used to pay back the refinanceable.
     *
     * @return True if the operation was successful.
     */
    function payOffRefinancable(
        address _refinanceableContract,
        uint256 _refinancableIdentifier,
        address _payBackToken,
        uint256 _payBackAmount
    ) external returns (bool);

    /**
     * @dev Returns the collateral information for a specific refinancable.
     *
     * @param _refinanceableContract Address of the contract containing the refinanceable
     * @param _refinancableIdentifier Unique identifier for the refinanceable.
     *
     * @return The address of the collateral token and the amount of collateral.
     */
    function getCollateral(
        address _refinanceableContract,
        uint256 _refinancableIdentifier
    ) external view returns (address, uint256);

    /**
     * @dev Returns the payoff details for a specific refinancable.
     *
     * @param _refinanceableContract Address of the contract containing the refinanceable
     * @param _refinancableIdentifier Unique identifier for the loan.
     *
     * @return The address of the payoff token and the required payoff amount.
     */
    function getPayoffDetails(
        address _refinanceableContract,
        uint256 _refinancableIdentifier
    ) external view returns (address, uint256);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {Ownable} from "../../utils/Ownable.sol";
import {ContractKeys} from "../../utils/ContractKeys.sol";

/**
 * @title  PermittedNFTsAndTypeRegistry
 * @author NFTfi
 * @dev Registry for refinanceable contracts supported by NFTfi.
 * Each refinanceable contract is associated with a refinanceableType.
 */
contract RefinancingAdapterRegistry is Ownable {
    mapping(bytes32 => address) private refinanceableTypes;
    mapping(address => bytes32) private refinanceableContracts;

    /* ****** */
    /* EVENTS */
    /* ****** */

    /**
     * @notice This event is fired whenever the admins register a refinancing type.
     *
     * @param refinanceableType - refinanceable type e.g. bytes32("DIRECT_LOAN_FIXED_OFFER")
     * @param refinancingAdapter - Address of the refinancing adapter contract.
     */
    event TypeUpdated(bytes32 indexed refinanceableType, address indexed refinancingAdapter);

    /**
     * @notice This event is fired whenever the admin sets a new refinanceable contract
     *
     * @param refinanceableContract - Address of the refinanceable contract.
     * @param refinanceableType - refinanceable type e.g. bytes32("DIRECT_LOAN_FIXED_OFFER")
     */
    event NewRefinanceableContract(address indexed refinanceableContract, bytes32 indexed refinanceableType);

    /* *********** */
    /* CONSTRUCTOR */
    /* *********** */

    /**
     * @dev Initialize `refinanceableTypes` with a batch of permitted refinancing types.
     *
     * @param _admin - Initial admin of this contract.
     */
    /*
     * @param _definedRefinanceableTypes - Array of defined refinancing types.
     * @param _refinancingAdapters - Array of refinancing adapter contracts.
     * @param _refinanceableTypes - Array of refinancing types  e.g. "DIRECT_LOAN_FIXED_OFFER"
     * @param _refinanceableContracts - Array of refinanceable contract addresses.
     * - "" means "disable this permit"
     * - != "" means "enable permit with the given Refinanceable Type"
     */
    constructor(
        address _admin,
        string[] memory _definedRefinanceableTypes,
        address[] memory _refinancingAdapters,
        string[] memory _refinanceableTypes,
        address[] memory _refinanceableContracts
    ) Ownable(_admin) {
        _setRefinanceableTypes(_definedRefinanceableTypes, _refinancingAdapters);
        _setRefinanceableContracts(_refinanceableContracts, _refinanceableTypes);
    }

    /* ********* */
    /* FUNCTIONS */
    /* ********* */

    /**
     * @notice Changes the status of a refinanceable contract.
     * This includes both adding a refinanceable contract to the permitted list and removing it.
     *
     * @param _refinanceableContract - Address of the refinanceable contract.
     * @param _refinanceableType - Refinanceable type, e.g., "DIRECT_LOAN_FIXED_OFFER".
     * - "" means "disable this permit"
     * - != "" means "enable permit with the given NFT Type"
     */
    function setRefinanceableContract(
        address _refinanceableContract,
        string memory _refinanceableType
    ) external onlyOwner {
        _setRefinanceableContract(_refinanceableContract, _refinanceableType);
    }

    /**
     * @notice Changes the status of a batch of refinanceable contracts.
     * This includes both adding refinanceable contracts to the permitted list and removing them.
     *
     * @param _refinanceableContracts - Array of refinanceable contract addresses.
     * @param _refinanceableTypes - Array of refinanceable types associated with the refinanceable contracts.
     * - "" means "disable this permit"
     * - != "" means "enable permit with the given NFT Type"
     */
    function setRefinanceableContracts(
        address[] memory _refinanceableContracts,
        string[] memory _refinanceableTypes
    ) external onlyOwner {
        _setRefinanceableContracts(_refinanceableContracts, _refinanceableTypes);
    }

    /**
     * @notice Looks up the refinanceable type associated with a refinanceable contract.
     *
     * @param _refinanceableContract - Address of the refinanceable contract.
     * @return The refinanceable type:
     * - bytes32("") means "not registered"
     * - != bytes32("") means "permitted with the given refinanceable type"
     */
    function getRefinanceableContract(address _refinanceableContract) external view returns (bytes32) {
        return refinanceableContracts[_refinanceableContract];
    }

    /**
     * @notice Looks up the address of the refinanceable adapter associated with the refinanceable contract type.
     *
     * @param _refinanceableContract - Address of the refinanceable contract.
     * @return The address of the refinanceable adapter contract.
     */
    function getRefinancingAdapter(address _refinanceableContract) public view returns (address) {
        bytes32 refinanceableType = refinanceableContracts[_refinanceableContract];
        return getRefinancingAdapterOfType(refinanceableType);
    }

    /**
     * @notice Sets or updates the address of the refinanceable adapter contract for the given refinanceable type.
     * Set address(0) for a refinanceable type to unregister it.
     *
     * @param _refinanceableType - Refinanceable type, e.g., "DIRECT_LOAN_FIXED_OFFER"
     * @param _refinancingAdapter - Address of the refinancing adapter contract that implements the refinanceable
     * behavior for dealing with the correct refinanceable type
     */
    function setRefinanceableType(string memory _refinanceableType, address _refinancingAdapter) external onlyOwner {
        _setRefinanceableType(_refinanceableType, _refinancingAdapter);
    }

    /**
     * @notice Sets or updates the addresses of the refinanceable adapter
     * contracts for the given batch of refinanceable types.
     * Set address(0) for a refinanceable type to unregister it.
     *
     * @param _refinanceableTypes - Array of refinanceable types, e.g., "DIRECT_LOAN_FIXED_OFFER"
     * @param _refinancingAdapters - Array of addresses of the refinancing adapter contracts that implement
     * the refinanceable behavior for dealing with the correct refinanceable type
     */
    function setRefinanceableTypes(
        string[] memory _refinanceableTypes,
        address[] memory _refinancingAdapters
    ) external onlyOwner {
        _setRefinanceableTypes(_refinanceableTypes, _refinancingAdapters);
    }

    /**
     * @notice Gets the address of the refinancing adapter contract that implements the given refinanceable type.
     *
     * @param  _refinanceableType - Refinanceable type, e.g., bytes32("DIRECT_LOAN_FIXED_OFFER")
     * @return The address of the refinancing adapter contract.
     */
    function getRefinancingAdapterOfType(bytes32 _refinanceableType) public view returns (address) {
        return refinanceableTypes[_refinanceableType];
    }

    /**
     * @notice Sets or updates the address of the refinancing adapter contract for the given refinanceable type.
     * Set address(0) to unregister a refinanceable type.
     *
     * @param _refinanceableType - Refinanceable type, e.g., "DIRECT_LOAN_FIXED_OFFER"
     * @param _refinancingAdapter - Address of the refinancing adapter contract that implements the
     * refinanceable behavior for dealing with the correct refinanceable type
     */

    function _setRefinanceableType(string memory _refinanceableType, address _refinancingAdapter) internal {
        // solhint-disable-next-line custom-errors
        require(bytes(_refinanceableType).length != 0, "refinanceableType is empty");
        bytes32 refinanceableTypeKey = ContractKeys.getIdFromStringKey(_refinanceableType);

        refinanceableTypes[refinanceableTypeKey] = _refinancingAdapter;

        emit TypeUpdated(refinanceableTypeKey, _refinancingAdapter);
    }

    /**
     * @notice Batch sets or updates the addresses of the refinancing adapter
     * contracts for the given batch of refinanceable types.
     * Set address(0) to unregister a refinanceable type.
     *
     * @param _refinanceableTypes - Array of refinanceable types, e.g., "DIRECT_LOAN_FIXED_OFFER"
     * @param _refinancingAdapters - Array of addresses of the refinancing adapter contracts that implement the
     * refinanceable behavior for dealing with the correct refinanceable type
     */
    function _setRefinanceableTypes(
        string[] memory _refinanceableTypes,
        address[] memory _refinancingAdapters
    ) internal {
        // solhint-disable-next-line custom-errors
        require(
            _refinanceableTypes.length == _refinancingAdapters.length,
            "setRefinanceableTypes function information arity mismatch"
        );

        for (uint256 i; i < _refinancingAdapters.length; ++i) {
            _setRefinanceableType(_refinanceableTypes[i], _refinancingAdapters[i]);
        }
    }

    /**
     * @notice Changes the registered status of a refinanceable contract.
     * This includes both adding a refinanceable contract to the registered list and removing it.
     *
     * @param _refinanceableContract - Address of the refinanceable contract.
     * @param _refinanceableType - Refinanceable type, e.g., "DIRECT_LOAN_FIXED_OFFER".
     * - bytes32("") means "disable this permit"
     * - != bytes32("") means "enable permit with the given NFT Type"
     */
    function _setRefinanceableContract(address _refinanceableContract, string memory _refinanceableType) internal {
        // solhint-disable-next-line custom-errors
        require(_refinanceableContract != address(0), "refinanceableContract is zero address");
        bytes32 refinanceableTypeKey = ContractKeys.getIdFromStringKey(_refinanceableType);

        if (refinanceableTypeKey != 0) {
            // solhint-disable-next-line custom-errors
            require(
                getRefinancingAdapterOfType(refinanceableTypeKey) != address(0),
                "refinanceable type not registered"
            );
        }

        refinanceableContracts[_refinanceableContract] = refinanceableTypeKey;
        emit NewRefinanceableContract(_refinanceableContract, refinanceableTypeKey);
    }

    /**
     * @notice Changes the registered status of multiple refinanceable contracts.
     * This function can only be called by the contract owner.
     * It includes both adding refinanceable contracts to the registered list and removing them.
     *
     * @param _refinanceableContracts - Array of refinanceable contract addresses.
     * @param _refinanceableTypes - Array of refinanceable types associated with
     * the refinanceable contracts, e.g., "DIRECT_LOAN_FIXED_OFFER".
     * - "" means "disable this permit"
     * - != "" means "enable permit with the given NFT Type"
     */
    function _setRefinanceableContracts(
        address[] memory _refinanceableContracts,
        string[] memory _refinanceableTypes
    ) internal {
        // solhint-disable-next-line custom-errors
        require(
            _refinanceableContracts.length == _refinanceableTypes.length,
            "setRefinanceableContracts function information arity mismatch"
        );

        for (uint256 i; i < _refinanceableContracts.length; ++i) {
            _setRefinanceableContract(_refinanceableContracts[i], _refinanceableTypes[i]);
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {ISwapRouter} from "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import {IQuoter} from "@uniswap/v3-periphery/contracts/interfaces/IQuoter.sol";

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract SwapFlashloanWETH {
    // solhint-disable-next-line immutable-vars-naming
    address public immutable swapRouterAddress;
    // solhint-disable-next-line immutable-vars-naming
    address public immutable quoterAddress;
    // solhint-disable-next-line immutable-vars-naming
    address public immutable wethAddress;

    /**
     * @dev stores the fee rates for tokens supported by this contract.
     * The keys are token addresses, and the values are the associated fee rates.
     */
    mapping(address => uint24) public supportedTokenFeeRates;

    error tokensFeeRatesArityMismatch();

    /**
     * @dev A struct to hold constructor parameters for the SwapFlashloanWETH contract.
     * (there were too many parameters in the Refinancing constructor)
     *
     * @param swapRouterAddress The address of the Uniswap V3 swap router.
     * @param quoterAddress The address of the Uniswap V3 quoter to estimate trade amounts.
     * @param wethAddress The address of the WETH token contract.
     * @param supportedTokens An array of token addresses that are supported for swaps.
     * @param swapFeeRates An array of fee rates corresponding to the supported tokens.
     */
    struct SwapConstructorParams {
        address swapRouterAddress;
        address quoterAddress;
        address wethAddress;
        address[] supportedTokens;
        uint24[] swapFeeRates;
    }

    /**
     * @dev Creates an instance of the SwapFlashloanWETH contract.
     *
     * @param _params A `SwapConstructorParams` struct containing:
     *                - swapRouterAddress: The address of the Uniswap V3 swap router.
     *                - quoterAddress: The address of the Uniswap V3 quoter for trade estimations.
     *                - wethAddress: The address of the WETH token contract.
     *                - supportedTokens: An array of supported token addresses for swapping.
     *                - swapFeeRates: An array of fee rates corresponding to each supported token.
     *
     * Requirements:
     *
     * - Each supported token address in `_params.supportedTokens` must have a corresponding
     *   fee rate in `_params.swapFeeRates`.
     */
    constructor(SwapConstructorParams memory _params) {
        swapRouterAddress = _params.swapRouterAddress;
        quoterAddress = _params.quoterAddress;
        wethAddress = _params.wethAddress;
        _setSupportedTokenFeeRates(_params.supportedTokens, _params.swapFeeRates);
    }

    /**
     * @dev Sets the fee rates for supported tokens in a single transaction.
     *
     * @param _supportedTokens An array of supported token addresses.
     * @param _swapFeeRates An array of corresponding swap fee rates.
     *
     * Requirements:
     *
     * - The length of the `_supportedTokens` array must be equal to the length of the `_swapFeeRates` array.
     */
    function _setSupportedTokenFeeRates(address[] memory _supportedTokens, uint24[] memory _swapFeeRates) internal {
        if (_supportedTokens.length != _swapFeeRates.length) revert tokensFeeRatesArityMismatch();

        for (uint256 i; i < _supportedTokens.length; ++i) {
            _setSupportedTokenFeeRate(_supportedTokens[i], _swapFeeRates[i]);
        }
    }

    /**
     * @dev Sets the fee rate for a single supported token.
     *
     * @param _supportedToken The address of the supported token.
     * @param _swapFeeRate The swap fee rate for the token.
     */
    function _setSupportedTokenFeeRate(address _supportedToken, uint24 _swapFeeRate) internal {
        supportedTokenFeeRates[_supportedToken] = _swapFeeRate;
    }

    /**
     * @dev Retrieves the swap fee rate for a given token.
     *
     * @param _token The address of the token to query the fee rate for.
     * @return uint24 The fee rate for swaps involving the specified token.
     */
    function getSwapFeeRate(address _token) public view returns (uint24) {
        return supportedTokenFeeRates[_token];
    }

    /**
     * @dev Estimates the amount of WETH needed to receive a specific amount of a given token.
     *
     * @param _tokenOut The address of the token to receive.
     * @param _amountOut The desired amount of the token to receive.
     * @return uint256 The estimated amount of WETH required.
     */
    function getWethAmountNeeded(address _tokenOut, uint256 _amountOut) public returns (uint256) {
        return
            IQuoter(quoterAddress).quoteExactOutputSingle(
                wethAddress,
                _tokenOut,
                getSwapFeeRate(_tokenOut),
                _amountOut,
                uint160(0) // sqrtPriceLimitX96
            );
    }

    /**
     * @dev Estimates the amount of a token needed to receive a specific amount of WETH.
     *
     * @param _tokenIn The address of the token to provide.
     * @param _amountOut The desired amount of WETH to receive.
     * @return uint256 The estimated amount of the input token required.
     */
    function getTokenAmountNeeded(address _tokenIn, uint256 _amountOut) public returns (uint256) {
        return
            IQuoter(quoterAddress).quoteExactOutputSingle(
                _tokenIn,
                wethAddress,
                getSwapFeeRate(_tokenIn),
                _amountOut,
                uint160(0) // sqrtPriceLimitX96
            );
    }

    /**
     * @dev Internal function to swap a token for WETH (Wrapped Ether) using the Uniswap V3 router.
     *
     * This function will attempt to swap the entirety of this contract's balance of the input token
     * for the specified amount of WETH, at the fee rate applicable to the input token. If the swap
     * cannot be completed, it will revert.
     *
     * @param _tokenIn The address of the token to be swapped for WETH.
     * @param _amountOutWeth The desired amount of WETH to receive from the swap.
     *
     * Requirements:
     *
     * - The contract must have a balance of at least `_amountOutWeth` of the token at `_tokenIn`.
     * - The contract must have approval to spend the input token on the Uniswap V3 router.
     */
    function _swapToWeth(address _tokenIn, uint256 _amountOutWeth) internal {
        uint256 balance = IERC20(_tokenIn).balanceOf(address(this));
        IERC20(_tokenIn).approve(swapRouterAddress, balance);

        ISwapRouter(swapRouterAddress).exactOutputSingle(
            ISwapRouter.ExactOutputSingleParams({
                tokenIn: _tokenIn,
                tokenOut: wethAddress,
                fee: getSwapFeeRate(_tokenIn),
                recipient: address(this),
                deadline: block.timestamp + 15, // TODO double check
                amountOut: _amountOutWeth,
                amountInMaximum: balance,
                sqrtPriceLimitX96: uint160(0)
            })
        );
    }

    /**
     * @dev Internal function to swap WETH (Wrapped Ether) for another token using the Uniswap V3 router.
     *
     * This function will attempt to swap the entirety of this contract's balance of WETH
     * for the specified amount of the output token, at the fee rate applicable to the output token.
     * If the swap cannot be completed, it will revert.
     *
     * @param _tokenOut The address of the token to receive from the swap.
     * @param _amountOutToken The desired amount of the output token to receive from the swap.
     *
     * Requirements:
     *
     * - The contract must have a balance of at least `_amountOutToken` worth of WETH.
     * - The contract must have approval to spend WETH on the Uniswap V3 router.
     */
    function _swapFromWeth(address _tokenOut, uint256 _amountOutToken) internal {
        uint256 balance = IERC20(wethAddress).balanceOf(address(this));
        IERC20(wethAddress).approve(swapRouterAddress, balance);

        ISwapRouter(swapRouterAddress).exactOutputSingle(
            ISwapRouter.ExactOutputSingleParams({
                tokenIn: wethAddress,
                tokenOut: _tokenOut,
                fee: getSwapFeeRate(_tokenOut),
                recipient: address(this),
                deadline: block.timestamp + 15, // TODO double check
                amountOut: _amountOutToken,
                amountInMaximum: balance,
                sqrtPriceLimitX96: uint160(0)
            })
        );
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";

import {INftfiHub} from "../interfaces/INftfiHub.sol";

/**
 * @title SmartNft
 * @author NFTfi
 * @dev An ERC721 token which represents a very basic implementation of the NFTfi V2 SmartNFT.
 */
contract SmartNft is ERC721, AccessControl {
    using Address for address;
    using Strings for uint256;

    /**
     * @dev This struct contains data needed to find the loan linked to a SmartNft.
     */
    struct Loan {
        address loanCoordinator;
        uint256 loanId;
    }

    /* ******* */
    /* STORAGE */
    /* ******* */

    bytes32 public constant LOAN_COORDINATOR_ROLE = keccak256("LOAN_COORDINATOR_ROLE");
    bytes32 public constant BASE_URI_ROLE = keccak256("BASE_URI_ROLE");

    // solhint-disable-next-line immutable-vars-naming
    INftfiHub public immutable hub;

    // smartNftId => Loan
    mapping(uint256 => Loan) public loans;

    string public baseURI;

    /**
     * @dev Grants the contract the default admin role to `_admin`.
     * Grants LOAN_COORDINATOR_ROLE to `_loanCoordinator`.
     *
     * @param _admin - Account to set as the admin of roles
     * @param _nftfiHub - Address of the NftfiHub contract
     * @param _loanCoordinator - Initial loan coordinator
     * @param _name - Name for the SmarNFT
     * @param _symbol - Symbol for the SmarNFT
     * @param _customBaseURI - Base URI for the SmarNFT
     */
    constructor(
        address _admin,
        address _nftfiHub,
        address _loanCoordinator,
        string memory _name,
        string memory _symbol,
        string memory _customBaseURI
    ) ERC721(_name, _symbol) {
        _setupRole(DEFAULT_ADMIN_ROLE, _admin);
        _setupRole(BASE_URI_ROLE, _admin);
        _setupRole(LOAN_COORDINATOR_ROLE, _loanCoordinator);
        _setBaseURI(_customBaseURI);
        hub = INftfiHub(_nftfiHub);
    }

    /**
     * @dev Grants LOAN_COORDINATOR_ROLE to `_account`.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function setLoanCoordinator(address _account) external {
        grantRole(LOAN_COORDINATOR_ROLE, _account);
    }

    /**
     * @dev Mints a new token with `_tokenId` and assigne to `_to`.
     *
     * Requirements:
     *
     * - the caller must have `LOAN_COORDINATOR_ROLE` role.
     *
     * @param _to The address reciving the SmartNft
     * @param _tokenId The id of the new SmartNft
     * @param _data Up to the first 32 bytes contains an integer which represents the loanId linked to the SmartNft
     */
    function mint(address _to, uint256 _tokenId, bytes calldata _data) external onlyRole(LOAN_COORDINATOR_ROLE) {
        // solhint-disable-next-line custom-errors
        require(_data.length > 0, "data must contain loanId");
        uint256 loanId = abi.decode(_data, (uint256));
        loans[_tokenId] = Loan({loanCoordinator: msg.sender, loanId: loanId});
        _safeMint(_to, _tokenId, _data);
    }

    /**
     * @dev Burns `_tokenId` token.
     *
     * Requirements:
     *
     * - the caller must have `LOAN_COORDINATOR_ROLE` role.
     */
    function burn(uint256 _tokenId) external onlyRole(LOAN_COORDINATOR_ROLE) {
        _burn(_tokenId);
    }

    /**
     * @dev Sets baseURI.
     * @param _customBaseURI - Base URI for the SmarNFT
     */
    function setBaseURI(string memory _customBaseURI) external onlyRole(BASE_URI_ROLE) {
        _setBaseURI(_customBaseURI);
    }

    function exists(uint256 _tokenId) external view returns (bool) {
        return _exists(_tokenId);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 _interfaceId) public view virtual override(ERC721, AccessControl) returns (bool) {
        return super.supportsInterface(_interfaceId);
    }

    /**
     * @dev Sets baseURI.
     */
    function _setBaseURI(string memory _customBaseURI) internal virtual {
        baseURI = bytes(_customBaseURI).length > 0
            ? string(abi.encodePacked(_customBaseURI, _getChainID().toString(), "/"))
            : "";
    }

    /** @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`.
     */
    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }

    /**
     * @dev This function gets the current chain ID.
     */
    function _getChainID() internal view returns (uint256) {
        uint256 id;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            id := chainid()
        }
        return id;
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

/**
 * @title ContractKeys
 * @author NFTfi
 * @dev Common library for contract keys
 */
library ContractKeys {
    bytes32 public constant PERMITTED_ERC20S = bytes32("PERMITTED_ERC20S");
    bytes32 public constant PERMITTED_NFTS = bytes32("PERMITTED_NFTS");
    bytes32 public constant PERMITTED_PARTNERS = bytes32("PERMITTED_PARTNERS");
    bytes32 public constant NFT_TYPE_REGISTRY = bytes32("NFT_TYPE_REGISTRY");
    bytes32 public constant LOAN_REGISTRY = bytes32("LOAN_REGISTRY");
    bytes32 public constant PERMITTED_SNFT_RECEIVER = bytes32("PERMITTED_SNFT_RECEIVER");

    /**
     * @notice Returns the bytes32 representation of a string
     * @param _key the string key
     * @return id bytes32 representation
     */
    function getIdFromStringKey(string memory _key) external pure returns (bytes32 id) {
        // solhint-disable-next-line custom-errors
        require(bytes(_key).length <= 32, "invalid key");

        // solhint-disable-next-line no-inline-assembly
        assembly {
            id := mload(add(_key, 32))
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {LoanData} from "../loans/direct/loanTypes/LoanData.sol";
import {SignatureChecker, ECDSA} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";

/**
 * @title  NFTfiCollectionOfferSigningUtils
 * @author NFTfi
 * @notice Helper contract for NFTfi. This contract manages verifying signatures from off-chain NFTfi orders.
 * Based on the version of this same contract used on NFTfi V1
 */
library NFTfiCollectionOfferSigningUtils {
    /* ********* */
    /* FUNCTIONS */
    /* ********* */

    /**
     * @dev This function gets the current chain ID.
     */
    function getChainID() internal view returns (uint256) {
        uint256 id;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * @notice This function is when the borrower accepts a lender's offer, to validate the lender's signature that the
     * lender provided off-chain to verify that it did indeed made such offer.
     *
     * @param _offer - The offer struct containing:
     * - loanERC20Denomination: The address of the ERC20 contract of the currency being used as principal/interest
     * for this loan.
     * - loanPrincipalAmount: The original sum of money transferred from lender to borrower at the beginning of
     * the loan, measured in loanERC20Denomination's smallest units.
     * - maximumRepaymentAmount: The maximum amount of money that the borrower would be required to retrieve their
     * collateral, measured in the smallest units of the ERC20 currency used for the loan. The borrower will always have
     * to pay this amount to retrieve their collateral, regardless of whether they repay early.
     * - nftCollateralContract: The address of the ERC721 contract of the NFT collateral.
     * - nftCollateralId: The ID within the NFTCollateralContract for the NFT being used as collateral for this
     * loan. The NFT is stored within this contract during the duration of the loan.
     * - referrer: The address of the referrer who found the lender matching the listing, Zero address to signal
     * this there is no referrer.
     * - loanDuration: The amount of time (measured in seconds) that can elapse before the lender can liquidate the
     * loan and seize the underlying collateral NFT.
     * - loanInterestRateForDurationInBasisPoints: This is the interest rate (measured in basis points, e.g.
     * hundreths of a percent) for the loan, that must be repaid pro-rata by the borrower at the conclusion of the loan
     * or risk seizure of their nft collateral. Note if the type of the loan is fixed then this value  is not used and
     * is irrelevant so it should be set to 0.
     * - loanAdminFeeInBasisPoints: The percent (measured in basis points) of the interest earned that will be
     * taken as a fee by the contract admins when the loan is repaid. The fee is stored in the loan struct to prevent an
     * attack where the contract admins could adjust the fee right before a loan is repaid, and take all of the interest
     * earned.
     * @param _idRange - min and max (inclusive) Id ranges for collection offers on collections,
     * like ArtBlocks, where multiple collections are defined on one contract differentiated by id-ranges
     * @param _signature - The signature structure containing:
     * - signer: The address of the signer. The borrower for `acceptOffer`
     * - nonce: The nonce referred here is not the same as an Ethereum account's nonce.
     * We are referring instead to a nonce that is used by the lender or the borrower when they are first signing
     * off-chain NFTfi orders. These nonce can be any uint256 value that the user has not previously used to sign an
     * off-chain order. Each nonce can be used at most once per user within NFTfi, regardless of whether they are the
     * lender or the borrower in that situation. This serves two purposes:
     *   - First, it prevents replay attacks where an attacker would submit a user's off-chain order more than once.
     *   - Second, it allows a user to cancel an off-chain order by calling
     * NFTfi.cancelLoanCommitmentBeforeLoanHasBegun(), which marks the nonce as used and prevents any future loan from
     * using the user's off-chain order that contains that nonce.
     * - expiry: Date when the signature expires
     * - signature: The ECDSA signature of the lender, obtained off-chain ahead of time, signing the following
     * combination of parameters:
     *   - offer.loanERC20Denomination
     *   - offer.loanPrincipalAmount
     *   - offer.maximumRepaymentAmount
     *   - offer.nftCollateralContract
     *   - offer.nftCollateralId
     *   - offer.referrer
     *   - offer.loanDuration
     *   - offer.loanAdminFeeInBasisPoints,
     *   - idRange.minId,
     *   - idRange.maxId,
     *   - signature.signer,
     *   - signature.nonce,
     *   - signature.expiry,
     *   - address of this contract
     *   - chainId
     */
    function isValidLenderSignatureWithIdRange(
        LoanData.Offer memory _offer,
        LoanData.CollectionIdRange memory _idRange,
        LoanData.Signature memory _signature
    ) internal view returns (bool) {
        return isValidLenderSignatureWithIdRange(_offer, _idRange, _signature, address(this));
    }

    /**
     * @dev This function overload the previous function to allow the caller to specify the address of the contract
     *
     */
    function isValidLenderSignatureWithIdRange(
        LoanData.Offer memory _offer,
        LoanData.CollectionIdRange memory _idRange,
        LoanData.Signature memory _signature,
        address _loanContract
    ) internal view returns (bool) {
        // solhint-disable-next-line custom-errors
        require(block.timestamp <= _signature.expiry, "Lender Signature has expired");
        // solhint-disable-next-line custom-errors
        require(_loanContract != address(0), "Loan is zero address");
        if (_signature.signer == address(0)) {
            return false;
        } else {
            bytes32 message = keccak256(
                abi.encodePacked(
                    getEncodedOffer(_offer),
                    abi.encodePacked(_idRange.minId, _idRange.maxId),
                    getEncodedSignature(_signature),
                    _loanContract,
                    getChainID()
                )
            );

            return
                SignatureChecker.isValidSignatureNow(
                    _signature.signer,
                    ECDSA.toEthSignedMessageHash(message),
                    _signature.signature
                );
        }
    }

    /**
     * @dev We need this to avoid stack too deep errors.
     */
    function getEncodedOffer(LoanData.Offer memory _offer) internal pure returns (bytes memory) {
        return
            abi.encodePacked(
                _offer.loanERC20Denomination,
                _offer.loanPrincipalAmount,
                _offer.maximumRepaymentAmount,
                _offer.nftCollateralContract,
                _offer.nftCollateralId,
                _offer.referrer,
                _offer.loanDuration,
                _offer.loanAdminFeeInBasisPoints
            );
    }

    /**
     * @dev We need this to avoid stack too deep errors.
     */
    function getEncodedSignature(LoanData.Signature memory _signature) internal pure returns (bytes memory) {
        return abi.encodePacked(_signature.signer, _signature.nonce, _signature.expiry);
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {LoanData} from "../loans/direct/loanTypes/LoanData.sol";
import {SignatureChecker, ECDSA} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";

/**
 * @title  NFTfiSigningUtils
 * @author NFTfi
 * @notice Helper contract for NFTfi. This contract manages verifying signatures from off-chain NFTfi orders.
 * Based on the version of this same contract used on NFTfi V1
 */
library NFTfiSigningUtils {
    /* ********* */
    /* FUNCTIONS */
    /* ********* */

    /**
     * @dev This function gets the current chain ID.
     */
    function getChainID() internal view returns (uint256) {
        uint256 id;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * @notice This function is when the borrower accepts a lender's offer, to validate the lender's signature that the
     * lender provided off-chain to verify that it did indeed made such offer.
     *
     * @param _offer - The offer struct containing:
     * - loanERC20Denomination: The address of the ERC20 contract of the currency being used as principal/interest
     * for this loan.
     * - loanPrincipalAmount: The original sum of money transferred from lender to borrower at the beginning of
     * the loan, measured in loanERC20Denomination's smallest units.
     * - maximumRepaymentAmount: The maximum amount of money that the borrower would be required to retrieve their
     * collateral, measured in the smallest units of the ERC20 currency used for the loan. The borrower will always have
     * to pay this amount to retrieve their collateral, regardless of whether they repay early.
     * - nftCollateralContract: The address of the ERC721 contract of the NFT collateral.
     * - nftCollateralId: The ID within the NFTCollateralContract for the NFT being used as collateral for this
     * loan. The NFT is stored within this contract during the duration of the loan.
     * - referrer: The address of the referrer who found the lender matching the listing, Zero address to signal
     * this there is no referrer.
     * - loanDuration: The amount of time (measured in seconds) that can elapse before the lender can liquidate the
     * loan and seize the underlying collateral NFT.
     * - loanInterestRateForDurationInBasisPoints: This is the interest rate (measured in basis points, e.g.
     * hundreths of a percent) for the loan, that must be repaid pro-rata by the borrower at the conclusion of the loan
     * or risk seizure of their nft collateral. Note if the type of the loan is fixed then this value  is not used and
     * is irrelevant so it should be set to 0.
     * - loanAdminFeeInBasisPoints: The percent (measured in basis points) of the interest earned that will be
     * taken as a fee by the contract admins when the loan is repaid. The fee is stored in the loan struct to prevent an
     * attack where the contract admins could adjust the fee right before a loan is repaid, and take all of the interest
     * earned.
     * @param _signature - The signature structure containing:
     * - signer: The address of the signer. The borrower for `acceptOffer`
     * - nonce: The nonce referred here is not the same as an Ethereum account's nonce.
     * We are referring instead to a nonce that is used by the lender or the borrower when they are first signing
     * off-chain NFTfi orders. These nonce can be any uint256 value that the user has not previously used to sign an
     * off-chain order. Each nonce can be used at most once per user within NFTfi, regardless of whether they are the
     * lender or the borrower in that situation. This serves two purposes:
     *   - First, it prevents replay attacks where an attacker would submit a user's off-chain order more than once.
     *   - Second, it allows a user to cancel an off-chain order by calling
     * NFTfi.cancelLoanCommitmentBeforeLoanHasBegun(), which marks the nonce as used and prevents any future loan from
     * using the user's off-chain order that contains that nonce.
     * - expiry: Date when the signature expires
     * - signature: The ECDSA signature of the lender, obtained off-chain ahead of time, signing the following
     * combination of parameters:
     *   - offer.loanERC20Denomination
     *   - offer.loanPrincipalAmount
     *   - offer.maximumRepaymentAmount
     *   - offer.nftCollateralContract
     *   - offer.nftCollateralId
     *   - offer.referrer
     *   - offer.loanDuration
     *   - offer.loanAdminFeeInBasisPoints
     *   - signature.signer,
     *   - signature.nonce,
     *   - signature.expiry,
     *   - address of this contract
     *   - chainId
     */
    function isValidLenderSignature(
        LoanData.Offer memory _offer,
        LoanData.Signature memory _signature
    ) external view returns (bool) {
        return isValidLenderSignature(_offer, _signature, address(this));
    }

    /**
     * @dev This function overload the previous function to allow the caller to specify the address of the contract
     *
     */
    function isValidLenderSignature(
        LoanData.Offer memory _offer,
        LoanData.Signature memory _signature,
        address _loanContract
    ) public view returns (bool) {
        // solhint-disable-next-line custom-errors
        require(block.timestamp <= _signature.expiry, "Lender Signature has expired");
        // solhint-disable-next-line custom-errors
        require(_loanContract != address(0), "Loan is zero address");
        if (_signature.signer == address(0)) {
            return false;
        } else {
            bytes32 message = keccak256(
                abi.encodePacked(getEncodedOffer(_offer), getEncodedSignature(_signature), _loanContract, getChainID())
            );

            return
                SignatureChecker.isValidSignatureNow(
                    _signature.signer,
                    ECDSA.toEthSignedMessageHash(message),
                    _signature.signature
                );
        }
    }

    /**
     * @notice This function is called in renegotiateLoan() to validate the lender's signature that the lender provided
     * off-chain to verify that they did indeed want to agree to this loan renegotiation according to these terms.
     *
     * @param _loanId - The unique identifier for the loan to be renegotiated
     * @param _newLoanDuration - The new amount of time (measured in seconds) that can elapse before the lender can
     * liquidate the loan and seize the underlying collateral NFT.
     * @param _newMaximumRepaymentAmount - The new maximum amount of money that the borrower would be required to
     * retrieve their collateral, measured in the smallest units of the ERC20 currency used for the loan. The
     * borrower will always have to pay this amount to retrieve their collateral, regardless of whether they repay
     * early.
     * @param _renegotiationFee Agreed upon fee in ether that borrower pays for the lender for the renegitiation
     * @param _signature - The signature structure containing:
     * - signer: The address of the signer. The borrower for `acceptOffer`
     * - nonce: The nonce referred here is not the same as an Ethereum account's nonce.
     * We are referring instead to a nonce that is used by the lender or the borrower when they are first signing
     * off-chain NFTfi orders. These nonce can be any uint256 value that the user has not previously used to sign an
     * off-chain order. Each nonce can be used at most once per user within NFTfi, regardless of whether they are the
     * lender or the borrower in that situation. This serves two purposes:
     * - First, it prevents replay attacks where an attacker would submit a user's off-chain order more than once.
     * - Second, it allows a user to cancel an off-chain order by calling NFTfi.cancelLoanCommitmentBeforeLoanHasBegun()
     * , which marks the nonce as used and prevents any future loan from using the user's off-chain order that contains
     * that nonce.
     * - expiry - The date when the renegotiation offer expires
     * - lenderSignature - The ECDSA signature of the lender, obtained off-chain ahead of time, signing the
     * following combination of parameters:
     * - _loanId
     * - _newLoanDuration
     * - _newMaximumRepaymentAmount
     * - _lender
     * - _lenderNonce
     * - _expiry
     * - address of this contract
     * - chainId
     */
    function isValidLenderRenegotiationSignature(
        uint256 _loanId,
        uint32 _newLoanDuration,
        uint256 _newMaximumRepaymentAmount,
        uint256 _renegotiationFee,
        LoanData.Signature memory _signature
    ) external view returns (bool) {
        return
            isValidLenderRenegotiationSignature(
                _loanId,
                _newLoanDuration,
                _newMaximumRepaymentAmount,
                _renegotiationFee,
                _signature,
                address(this)
            );
    }

    /**
     * @dev This function overload the previous function to allow the caller to specify the address of the contract
     *
     */
    function isValidLenderRenegotiationSignature(
        uint256 _loanId,
        uint32 _newLoanDuration,
        uint256 _newMaximumRepaymentAmount,
        uint256 _renegotiationFee,
        LoanData.Signature memory _signature,
        address _loanContract
    ) public view returns (bool) {
        // solhint-disable-next-line custom-errors
        require(block.timestamp <= _signature.expiry, "Renegotiation Signature expired");
        // solhint-disable-next-line custom-errors
        require(_loanContract != address(0), "Loan is zero address");
        if (_signature.signer == address(0)) {
            return false;
        } else {
            bytes32 message = keccak256(
                abi.encodePacked(
                    _loanId,
                    _newLoanDuration,
                    _newMaximumRepaymentAmount,
                    _renegotiationFee,
                    getEncodedSignature(_signature),
                    _loanContract,
                    getChainID()
                )
            );

            return
                SignatureChecker.isValidSignatureNow(
                    _signature.signer,
                    ECDSA.toEthSignedMessageHash(message),
                    _signature.signature
                );
        }
    }

    /**
     * @dev We need this to avoid stack too deep errors.
     */
    function getEncodedOffer(LoanData.Offer memory _offer) internal pure returns (bytes memory) {
        return
            abi.encodePacked(
                _offer.loanERC20Denomination,
                _offer.loanPrincipalAmount,
                _offer.maximumRepaymentAmount,
                _offer.nftCollateralContract,
                _offer.nftCollateralId,
                _offer.referrer,
                _offer.loanDuration,
                _offer.loanAdminFeeInBasisPoints
            );
    }

    /**
     * @dev We need this to avoid stack too deep errors.
     */
    function getEncodedSignature(LoanData.Signature memory _signature) internal pure returns (bytes memory) {
        return abi.encodePacked(_signature.signer, _signature.nonce, _signature.expiry);
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.19;

import {IERC1155Receiver, IERC165} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {ERC721Holder, IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";

/**
 * @title NftReceiver
 * @author NFTfi
 * @dev Base contract with capabilities for receiving ERC1155 and ERC721 tokens
 */
abstract contract NftReceiver is IERC1155Receiver, ERC721Holder {
    /**
     *  @dev Handles the receipt of a single ERC1155 token type. This function is called at the end of a
     * `safeTransferFrom` after the balance has been updated.
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if allowed
     */
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes calldata
    ) external virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    /**
     *  @dev Handles the receipt of a multiple ERC1155 token types. This function is called at the end of a
     * `safeBatchTransferFrom` after the balances have been updated.
     *  @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if allowed
     */
    function onERC1155BatchReceived(
        address,
        address,
        uint256[] calldata,
        uint256[] calldata,
        bytes calldata
    ) external virtual override returns (bytes4) {
        // solhint-disable-next-line custom-errors
        revert("ERC1155 batch not supported");
    }

    /**
     * @dev Checks whether this contract implements the interface defined by `interfaceId`.
     * @param _interfaceId Id of the interface
     * @return true if this contract implements the interface
     */
    function supportsInterface(bytes4 _interfaceId) public view virtual override returns (bool) {
        return
            _interfaceId == type(IERC1155Receiver).interfaceId ||
            _interfaceId == type(IERC721Receiver).interfaceId ||
            _interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.19;

import {Context} from "@openzeppelin/contracts/utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 *
 * Modified version from openzeppelin/contracts/access/Ownable.sol that allows to
 * initialize the owner using a parameter in the constructor
 */
abstract contract Ownable is Context {
    address private _owner;

    address private _ownerCandidate;

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        // solhint-disable-next-line custom-errors
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor(address _initialOwner) {
        _setOwner(_initialOwner);
    }

    /**
     * @dev Requests transferring ownership of the contract to a new account (`_newOwnerCandidate`).
     * Can only be called by the current owner.
     */
    function requestTransferOwnership(address _newOwnerCandidate) public virtual onlyOwner {
        // solhint-disable-next-line custom-errors
        require(_newOwnerCandidate != address(0), "Ownable: new owner is the zero address");
        _ownerCandidate = _newOwnerCandidate;
    }

    function acceptTransferOwnership() public virtual {
        // solhint-disable-next-line custom-errors
        require(_ownerCandidate == _msgSender(), "Ownable: not owner candidate");
        _setOwner(_ownerCandidate);
        delete _ownerCandidate;
    }

    function cancelTransferOwnership() public virtual onlyOwner {
        delete _ownerCandidate;
    }

    function rejectTransferOwnership() public virtual {
        // solhint-disable-next-line custom-errors
        require(_ownerCandidate == _msgSender(), "Ownable: not owner candidate");
        delete _ownerCandidate;
    }

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

    /**
     * @dev Sets the owner.
     */
    function _setOwner(address _newOwner) internal {
        address oldOwner = _owner;
        _owner = _newOwner;
        emit OwnershipTransferred(oldOwner, _newOwner);
    }
}

{
  "metadata": {
    "bytecodeHash": "none",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 100
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {
    "contracts/utils/ContractKeys.sol": {
      "ContractKeys": "0x733ac632056aa272130af63809ff3301c80bd1e7"
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_nftfiHub","type":"address"},{"internalType":"address","name":"_targetLoanFixedOfferContract","type":"address"},{"internalType":"address","name":"_targetLoanCollectionOfferContract","type":"address"},{"internalType":"address","name":"_admin","type":"address"},{"internalType":"string[]","name":"_definedRefinanceableTypes","type":"string[]"},{"internalType":"address[]","name":"_refinancingAdapters","type":"address[]"},{"internalType":"string[]","name":"_refinanceableTypes","type":"string[]"},{"internalType":"address[]","name":"_refinanceableContracts","type":"address[]"},{"internalType":"address","name":"_soloMargin","type":"address"},{"internalType":"uint256","name":"_flashloanFee","type":"uint256"},{"components":[{"internalType":"address","name":"swapRouterAddress","type":"address"},{"internalType":"address","name":"quoterAddress","type":"address"},{"internalType":"address","name":"wethAddress","type":"address"},{"internalType":"address[]","name":"supportedTokens","type":"address[]"},{"internalType":"uint24[]","name":"swapFeeRates","type":"uint24[]"}],"internalType":"struct SwapFlashloanWETH.SwapConstructorParams","name":"_swapContructorParams","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"callerNotBorrowerOfOldLoan","type":"error"},{"inputs":[],"name":"callerNotFlashloanContract","type":"error"},{"inputs":[],"name":"collateralNotOwned","type":"error"},{"inputs":[],"name":"denominationMismatch","type":"error"},{"inputs":[],"name":"flashloanInitiatorNotThisContract","type":"error"},{"inputs":[],"name":"tokensFeeRatesArityMismatch","type":"error"},{"inputs":[],"name":"unsupportedCollateral","type":"error"},{"inputs":[],"name":"wrongTargetLoanType","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"refinanceableContract","type":"address"},{"indexed":true,"internalType":"bytes32","name":"refinanceableType","type":"bytes32"}],"name":"NewRefinanceableContract","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldLoanContract","type":"address"},{"indexed":true,"internalType":"uint256","name":"oldLoanId","type":"uint256"},{"indexed":true,"internalType":"uint32","name":"newLoanId","type":"uint32"}],"name":"Refinanced","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"refinanceableType","type":"bytes32"},{"indexed":true,"internalType":"address","name":"refinancingAdapter","type":"address"}],"name":"TypeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"acceptTransferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"number","type":"uint256"}],"internalType":"struct IFlashloan.AccountInfo","name":"","type":"tuple"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"callFunction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cancelTransferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flashloanFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_refinanceableContract","type":"address"}],"name":"getRefinanceableContract","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_refinanceableContract","type":"address"}],"name":"getRefinancingAdapter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_refinanceableType","type":"bytes32"}],"name":"getRefinancingAdapterOfType","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"getSwapFeeRate","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTargetCoordinator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenIn","type":"address"},{"internalType":"uint256","name":"_amountOut","type":"uint256"}],"name":"getTokenAmountNeeded","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenOut","type":"address"},{"internalType":"uint256","name":"_amountOut","type":"uint256"}],"name":"getWethAmountNeeded","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"hub","outputs":[{"internalType":"contract INftfiHub","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"loadTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"marketIds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quoterAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"loanIdentifier","type":"uint256"},{"internalType":"address","name":"refinanceableContract","type":"address"}],"internalType":"struct Refinancing.RefinancingData","name":"_refinancingData","type":"tuple"},{"components":[{"internalType":"uint256","name":"loanPrincipalAmount","type":"uint256"},{"internalType":"uint256","name":"maximumRepaymentAmount","type":"uint256"},{"internalType":"uint256","name":"nftCollateralId","type":"uint256"},{"internalType":"address","name":"nftCollateralContract","type":"address"},{"internalType":"uint32","name":"loanDuration","type":"uint32"},{"internalType":"uint16","name":"loanAdminFeeInBasisPoints","type":"uint16"},{"internalType":"address","name":"loanERC20Denomination","type":"address"},{"internalType":"address","name":"referrer","type":"address"}],"internalType":"struct LoanData.Offer","name":"_offer","type":"tuple"},{"components":[{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct LoanData.Signature","name":"_lenderSignature","type":"tuple"},{"components":[{"internalType":"address","name":"revenueSharePartner","type":"address"},{"internalType":"uint16","name":"referralFeeInBasisPoints","type":"uint16"}],"internalType":"struct LoanData.BorrowerSettings","name":"_borrowerSettings","type":"tuple"}],"name":"refinanceCollectionOfferLoan","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"loanIdentifier","type":"uint256"},{"internalType":"address","name":"refinanceableContract","type":"address"}],"internalType":"struct Refinancing.RefinancingData","name":"_refinancingData","type":"tuple"},{"components":[{"internalType":"uint256","name":"loanPrincipalAmount","type":"uint256"},{"internalType":"uint256","name":"maximumRepaymentAmount","type":"uint256"},{"internalType":"uint256","name":"nftCollateralId","type":"uint256"},{"internalType":"address","name":"nftCollateralContract","type":"address"},{"internalType":"uint32","name":"loanDuration","type":"uint32"},{"internalType":"uint16","name":"loanAdminFeeInBasisPoints","type":"uint16"},{"internalType":"address","name":"loanERC20Denomination","type":"address"},{"internalType":"address","name":"referrer","type":"address"}],"internalType":"struct LoanData.Offer","name":"_offer","type":"tuple"},{"components":[{"internalType":"uint256","name":"minId","type":"uint256"},{"internalType":"uint256","name":"maxId","type":"uint256"}],"internalType":"struct LoanData.CollectionIdRange","name":"_idRange","type":"tuple"},{"components":[{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct LoanData.Signature","name":"_lenderSignature","type":"tuple"},{"components":[{"internalType":"address","name":"revenueSharePartner","type":"address"},{"internalType":"uint16","name":"referralFeeInBasisPoints","type":"uint16"}],"internalType":"struct LoanData.BorrowerSettings","name":"_borrowerSettings","type":"tuple"}],"name":"refinanceCollectionRangeOfferLoan","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"loanIdentifier","type":"uint256"},{"internalType":"address","name":"refinanceableContract","type":"address"}],"internalType":"struct Refinancing.RefinancingData","name":"_refinancingData","type":"tuple"},{"components":[{"internalType":"uint256","name":"loanPrincipalAmount","type":"uint256"},{"internalType":"uint256","name":"maximumRepaymentAmount","type":"uint256"},{"internalType":"uint256","name":"nftCollateralId","type":"uint256"},{"internalType":"address","name":"nftCollateralContract","type":"address"},{"internalType":"uint32","name":"loanDuration","type":"uint32"},{"internalType":"uint16","name":"loanAdminFeeInBasisPoints","type":"uint16"},{"internalType":"address","name":"loanERC20Denomination","type":"address"},{"internalType":"address","name":"referrer","type":"address"}],"internalType":"struct LoanData.Offer","name":"_offer","type":"tuple"},{"components":[{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct LoanData.Signature","name":"_lenderSignature","type":"tuple"},{"components":[{"internalType":"address","name":"revenueSharePartner","type":"address"},{"internalType":"uint16","name":"referralFeeInBasisPoints","type":"uint16"}],"internalType":"struct LoanData.BorrowerSettings","name":"_borrowerSettings","type":"tuple"}],"name":"refinanceLoan","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rejectTransferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwnerCandidate","type":"address"}],"name":"requestTransferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_flashloanFee","type":"uint256"}],"name":"setFlashloanFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_refinanceableContract","type":"address"},{"internalType":"string","name":"_refinanceableType","type":"string"}],"name":"setRefinanceableContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_refinanceableContracts","type":"address[]"},{"internalType":"string[]","name":"_refinanceableTypes","type":"string[]"}],"name":"setRefinanceableContracts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_refinanceableType","type":"string"},{"internalType":"address","name":"_refinancingAdapter","type":"address"}],"name":"setRefinanceableType","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string[]","name":"_refinanceableTypes","type":"string[]"},{"internalType":"address[]","name":"_refinancingAdapters","type":"address[]"}],"name":"setRefinanceableTypes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_supportedToken","type":"address"},{"internalType":"uint24","name":"_swapFeeRate","type":"uint24"}],"name":"setSupportedTokenSwapFeeRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_supportedTokens","type":"address[]"},{"internalType":"uint24[]","name":"_swapFeeRates","type":"uint24[]"}],"name":"setSupportedTokenSwapFeeRates","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_targetLoanFixedOfferContract","type":"address"}],"name":"setTargetLoanFixedOfferContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_targetLoanCollectionOfferContract","type":"address"}],"name":"settargetLoanCollectionOfferContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"soloMargin","outputs":[{"internalType":"contract ISoloMargin","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"supportedTokenFeeRates","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapRouterAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"targetLoanCollectionOfferContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"targetLoanFixedOfferContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokenFlashloanble","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wethAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

-----Decoded View---------------
Arg [0] : _nftfiHub (address): 0x4deAcdDEF0E6ada9a35e360126181C75fA7F8EdA
Arg [1] : _targetLoanFixedOfferContract (address): 0xd0a40eB7FD94eE97102BA8e9342243A2b2E22207
Arg [2] : _targetLoanCollectionOfferContract (address): 0xD0C6e59B50C32530C627107F50Acc71958C4341F
Arg [3] : _admin (address): 0xDcA17eeDc1aa3dbB14361678566b2dA5A1Bb4C31
Arg [4] : _definedRefinanceableTypes (string[]): NFTFI
Arg [5] : _refinancingAdapters (address[]): 0xAd42445545C9a368Fba9e71f9B4b441BE6458D1D
Arg [6] : _refinanceableTypes (string[]): NFTFI,NFTFI,NFTFI,NFTFI,NFTFI
Arg [7] : _refinanceableContracts (address[]): 0xd0a40eB7FD94eE97102BA8e9342243A2b2E22207,0xD0C6e59B50C32530C627107F50Acc71958C4341F,0xE52Cec0E90115AbeB3304BaA36bc2655731f7934,0x8252Df1d8b29057d1Afe3062bf5a64D503152BC8,0xf896527c49b44aAb3Cf22aE356Fa3AF8E331F280
Arg [8] : _soloMargin (address): 0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e
Arg [9] : _flashloanFee (uint256): 2
Arg [10] : _swapContructorParams (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]

-----Encoded View---------------
48 Constructor Arguments found :
Arg [0] : 0000000000000000000000004deacddef0e6ada9a35e360126181c75fa7f8eda
Arg [1] : 000000000000000000000000d0a40eb7fd94ee97102ba8e9342243a2b2e22207
Arg [2] : 000000000000000000000000d0c6e59b50c32530c627107f50acc71958c4341f
Arg [3] : 000000000000000000000000dca17eedc1aa3dbb14361678566b2da5a1bb4c31
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [5] : 00000000000000000000000000000000000000000000000000000000000001e0
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000220
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000420
Arg [8] : 0000000000000000000000001e0447b19bb6ecfdae1e4ae1694b0c3659614e4e
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [10] : 00000000000000000000000000000000000000000000000000000000000004e0
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [14] : 4e46544649000000000000000000000000000000000000000000000000000000
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [16] : 000000000000000000000000ad42445545c9a368fba9e71f9b4b441be6458d1d
Arg [17] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [18] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [19] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [20] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [21] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [22] : 00000000000000000000000000000000000000000000000000000000000001a0
Arg [23] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [24] : 4e46544649000000000000000000000000000000000000000000000000000000
Arg [25] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [26] : 4e46544649000000000000000000000000000000000000000000000000000000
Arg [27] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [28] : 4e46544649000000000000000000000000000000000000000000000000000000
Arg [29] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [30] : 4e46544649000000000000000000000000000000000000000000000000000000
Arg [31] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [32] : 4e46544649000000000000000000000000000000000000000000000000000000
Arg [33] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [34] : 000000000000000000000000d0a40eb7fd94ee97102ba8e9342243a2b2e22207
Arg [35] : 000000000000000000000000d0c6e59b50c32530c627107f50acc71958c4341f
Arg [36] : 000000000000000000000000e52cec0e90115abeb3304baa36bc2655731f7934
Arg [37] : 0000000000000000000000008252df1d8b29057d1afe3062bf5a64d503152bc8
Arg [38] : 000000000000000000000000f896527c49b44aab3cf22ae356fa3af8e331f280
Arg [39] : 000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564
Arg [40] : 000000000000000000000000b27308f9f90d607463bb33ea1bebb41c27ce5ab6
Arg [41] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
Arg [42] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [43] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [44] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [45] : 0000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca0
Arg [46] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [47] : 0000000000000000000000000000000000000000000000000000000000000064