[ERC7565] 資産をNFTとしてロックしてDeFiなどで担保にできる仕組みを理解しよう！

    interface IPerpetualContractNFT {

        // Emitted when an NFT is collateralized for obtaining a loan
        event Collateralized(uint256 indexed tokenId, address indexed owner, uint256 loanAmount, uint256 interestRate, uint256 loanDuration);

        // Emitted when a loan secured by an NFT is fully repaid, releasing the NFT from collateral
        event LoanRepaid(uint256 indexed tokenId, address indexed owner);

        // Emitted when a loan defaults, resulting in the transfer of the NFT to the lender
        event Defaulted(uint256 indexed tokenId, address indexed lender);

        // Enables an NFT owner to collateralize their NFT in exchange for a loan
        // @param tokenId The NFT to be used as collateral
        // @param loanAmount The amount of funds to be borrowed
        // @param interestRate The interest rate for the loan
        // @param loanDuration The duration of the loan
        function collateralize(uint256 tokenId, uint256 loanAmount, uint256 interestRate, uint64 loanDuration) external;

        // Enables a borrower to repay their loan and regain ownership of the collateralized NFT
        // @param tokenId The NFT that was used as collateral
        // @param repayAmount The amount of funds to be repaid
        function repayLoan(uint256 tokenId, uint256 repayAmount) external;

        // Allows querying the loan terms for a given NFT
        // @param tokenId The NFT used as collateral
        // @return loanAmount The amount of funds borrowed
        // @return interestRate The interest rate for the loan
        // @return loanDuration The duration of the loan
        // @return loanDueDate The due date for the loan repayment
        function getLoanTerms(uint256 tokenId) external view returns (uint256 loanAmount, uint256 interestRate, uint256 loanDuration, uint256 loanDueDate);

        // Allows querying the current owner of the NFT
        // @param tokenId The NFT in question
        // @return The address of the current owner
        function currentOwner(uint256 tokenId) external view returns (address);

        // View the total amount required to repay the loan for a given NFT
        // @param tokenId The NFT used as collateral
        // @return The total amount required to repay the loan, including interest
        function viewRepayAmount(uint256 tokenId) external view returns (uint256);
    }

// SPDX-License-Identifier: CC0-1.0 
pragma solidity ^0.8.0;

//import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./IPerpetualContractNFT.sol";
import "./ERC4907/ERC4907.sol";

contract PerpetualContractNFT is ERC4907, IPerpetualContractNFT {
    struct LoanInfo {
        address borrower;   // Address that borrowed against the NFT
        uint256 loanAmount; // Amount of funds borrowed
        uint256 interestRate; // Interest rate for the loan
        uint64 loanDuration; // Duration of the loan
        uint256 loanStartTime; // Timestamp when the loan starts
    }

    mapping(uint256 => LoanInfo) internal _loans;

    //Constructor to initialize the Perpetual Contract NFT contract with the given name and symbo
    constructor(string memory name_, string memory symbol_)
        ERC4907(name_, symbol_)
    {}

    function collateralize(uint256 tokenId, uint256 loanAmount, uint256 interestRate, uint64 loanDuration) public override {
        require(ownerOf(tokenId) == msg.sender || isApprovedForAll(ownerOf(tokenId), msg.sender) || getApproved(tokenId) == msg.sender, "Not owner nor approved");

        LoanInfo storage info = _loans[tokenId];
        info.borrower = msg.sender;
        // The loan amount should reflect the asset's value as represented by the NFT, considering an appropriate loan-to-value (LTV) ratio.
        info.loanAmount = loanAmount;
        info.interestRate = interestRate;
        info.loanDuration = loanDuration;
        info.loanStartTime = block.timestamp;

        setUser(tokenId, address(this), loanDuration);
        emit Collateralized(tokenId, msg.sender, loanAmount, interestRate, loanDuration);

        // Further logic can be implemented here to manage the lending of assets
    }

    function repayLoan(uint256 tokenId, uint256 repayAmount) public override {
        require(_loans[tokenId].borrower == msg.sender, "Not the borrower.");

        // Calculate the total amount due for repayment
        uint256 totalDue = viewRepayAmount(tokenId);

        // Check if the repayAmount is sufficient to cover at least a part of the total due amount
        require(repayAmount <= totalDue, "Repay amount exceeds total due.");

        // Calculate the remaining loan amount after repayment
        _loans[tokenId].loanAmount = totalDue - repayAmount;

        // Resets the user of the NFT to the default state if the entire loan amount is fully repaid
        if(_loans[tokenId].loanAmount == 0) {
            setUser(tokenId, address(0), 0);
        }

        emit LoanRepaid(tokenId, msg.sender);
    }


    function getLoanTerms(uint256 tokenId) public view override returns (uint256, uint256, uint256, uint256) {
        LoanInfo storage info = _loans[tokenId];
        return (info.loanAmount, info.interestRate, info.loanDuration, info.loanStartTime);
    }

    function currentOwner(uint256 tokenId) public view override returns (address) {
        return ownerOf(tokenId);
    }

    function viewRepayAmount(uint256 tokenId) public view returns (uint256) {
        if (_loans[tokenId].loanAmount == 0) {
            // If the loan amount is zero, there is nothing to repay
            return 0;
        }

        // The interest is calculated on an hourly basis, prorated based on the actual duration for which the loan was held.
        // If the borrower repays before the loan duration ends, they are charged interest only for the time the loan was held.
        // For example, if the annual interest rate is 5% and the borrower repays in half the loan term, they pay only 2.5% interest.
        uint256 elapsed = block.timestamp > (_loans[tokenId].loanStartTime + _loans[tokenId].loanDuration) 
                        ? _loans[tokenId].loanDuration  / 1 hours
                        : (block.timestamp - _loans[tokenId].loanStartTime) / 1 hours;

        // Round up
        // Example: 15/4 = 3.75
        // round((15 + 4 - 1)/4) = 4, round((15/4) = 3)
        uint256 interest = ((_loans[tokenId].loanAmount * _loans[tokenId].interestRate / 100) * elapsed + (_loans[tokenId].loanDuration / 1 hours) - 1) / 
                    (_loans[tokenId].loanDuration / 1 hours);

        // Calculate the total amount due
        uint256 totalDue = _loans[tokenId].loanAmount + interest;

        return totalDue;
    }

    // Additional functions and logic to handle loan defaults, transfers, and other aspects of the NFT lifecycle
}

struct LoanInfo {
    address borrower;   // Address that borrowed against the NFT
    uint256 loanAmount; // Amount of funds borrowed
    uint256 interestRate; // Interest rate for the loan
    uint64 loanDuration; // Duration of the loan
    uint256 loanStartTime; // Timestamp when the loan starts
}

mapping(uint256 => LoanInfo) internal _loans;

function collateralize(uint256 tokenId, uint256 loanAmount, uint256 interestRate, uint64 loanDuration) public override {
    require(ownerOf(tokenId) == msg.sender || isApprovedForAll(ownerOf(tokenId), msg.sender) || getApproved(tokenId) == msg.sender, "Not owner nor approved");
    LoanInfo storage info = _loans[tokenId];
    info.borrower = msg.sender;
    info.loanAmount = loanAmount;
    info.interestRate = interestRate;
    info.loanDuration = loanDuration;
    info.loanStartTime = block.timestamp;
    setUser(tokenId, address(this), loanDuration);
    emit Collateralized(tokenId, msg.sender, loanAmount, interestRate, loanDuration);
}

function repayLoan(uint256 tokenId, uint256 repayAmount) public override {
    require(_loans[tokenId].borrower == msg.sender, "Not the borrower.");
    uint256 totalDue = viewRepayAmount(tokenId);
    require(repayAmount <= totalDue, "Repay amount exceeds total due.");
    _loans[tokenId].loanAmount = totalDue - repayAmount;
    if(_loans[tokenId].loanAmount == 0) {
        setUser(tokenId, address(0), 0);
    }
    emit LoanRepaid(tokenId, msg.sender);
}

function getLoanTerms(uint256 tokenId) public view override returns (uint256, uint256, uint256, uint256) {
    LoanInfo storage info = _loans[tokenId];
    return (info.loanAmount, info.interestRate, info.loanDuration, info.loanStartTime);
}

function currentOwner(uint256 tokenId) public view override returns (address) {
    return ownerOf(tokenId);
}

function viewRepayAmount(uint256 tokenId) public view returns (uint256) {
    if (_loans[tokenId].loanAmount == 0) {
        return 0;
    }
    uint256 elapsed = block.timestamp > (_loans[tokenId].loanStartTime + _loans[tokenId].loanDuration) 
                    ? _loans[tokenId].loanDuration  / 1 hours
                    : (block.timestamp - _loans[tokenId].loanStartTime) / 1 hours;
    uint256 interest = ((_loans[tokenId].loanAmount * _loans[tokenId].interestRate / 100) * elapsed + (_loans[tokenId].loanDuration / 1 hours) - 1) / 
                (_loans[tokenId].loanDuration / 1 hours);
    uint256 totalDue = _loans[tokenId].loanAmount + interest;
    return totalDue;
}