ERC-7565: 将永久合约 NFT 作为抵押品

    interface IPerpetualContractNFT {

        // 当 NFT 被抵押以获得贷款时发出
        event Collateralized(uint256 indexed tokenId, address indexed owner, uint256 loanAmount, uint256 interestRate, uint256 loanDuration);

        // 当由 NFT 担保的贷款全部偿还时发出，从抵押品中释放 NFT
        event LoanRepaid(uint256 indexed tokenId, address indexed owner);

        // 当贷款违约时发出，导致 NFT 转移给贷款人
        event Defaulted(uint256 indexed tokenId, address indexed lender);

        // 使 NFT 所有者能够抵押其 NFT 以换取贷款
        // @param tokenId 要用作抵押品的 NFT
        // @param loanAmount 要借入的资金额
        // @param interestRate 贷款利率
        // @param loanDuration 贷款期限
        function collateralize(uint256 tokenId, uint256 loanAmount, uint256 interestRate, uint64 loanDuration) external;

        // 使借款人能够偿还贷款并重新获得抵押 NFT 的所有权
        // @param tokenId 用作抵押品的 NFT
        // @param repayAmount 要偿还的资金额
        function repayLoan(uint256 tokenId, uint256 repayAmount) external;

        // 允许查询给定 NFT 的贷款条款
        // @param tokenId 用作抵押品的 NFT
        // @return loanAmount 借入的资金额
        // @return interestRate 贷款利率
        // @return loanDuration 贷款期限
        // @return loanDueDate 贷款到期日
        function getLoanTerms(uint256 tokenId) external view returns (uint256 loanAmount, uint256 interestRate, uint256 loanDuration, uint256 loanDueDate);

        // 允许查询 NFT 的当前所有者
        // @param tokenId 有问题的 NFT
        // @return 当前所有者的地址
        function currentOwner(uint256 tokenId) external view returns (address);

        // 查看偿还给定 NFT 贷款所需的总金额
        // @param tokenId 用作抵押品的 NFT
        // @return 偿还贷款所需的总金额，包括利息
        function viewRepayAmount(uint256 tokenId) external view returns (uint256);
    }

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

import "./PerpetualContractNFT.sol";

contract PerpetualContractNFTDemo is PerpetualContractNFT {

    constructor(string memory name, string memory symbol)
        PerpetualContractNFT(name, symbol)
    {         
    }

    function mint(uint256 tokenId, address to) public {
        _mint(to, tokenId);
    }
}

import { expect } from "chai";
import { ethers } from "hardhat";

describe("PerpetualContractNFTDemo", function () {
    it("should allow an owner to collateralize an NFT, rent it to a contract, and then have the owner repay the loan", async function () {
        const [owner] = await ethers.getSigners();

        const PerpetualContractNFTDemo = await ethers.getContractFactory("PerpetualContractNFTDemo");
        const demo = await PerpetualContractNFTDemo.deploy("DemoNFT", "DNFT");
        await demo.waitForDeployment();
        expect(demo.target).to.be.properAddress;

        // Mint an NFT to the owner
        // 将 NFT 铸造给所有者
        await demo.mint(1, owner.address);

        // Owner collateralizes the NFT for a loan
        // 所有者抵押 NFT 以获得贷款
        const loanAmount = ethers.parseUnits("1", "ether"); // 1 Ether in Wei. Use Wei to avoid precision error.
        const interest = 5; // 5% interest
        const expiration = Math.floor(new Date().getTime() / 1000) + 3600; // Expire after 60 minutes (3600 seconds), convert it to seconds because `hours` in solidity converted to seconds
        
        await demo.connect(owner).collateralize(1, loanAmount, interest, expiration); // tokenId, loanAmount, interestRate, loanDuration

        // Check current user of the NFT (should be the contract address)
        // 检查 NFT 的当前用户（应该是合约地址）
        expect(await demo.userOf(1)).to.equal(demo.target);

        // Borrower repays the loan to release the NFT
        // 借款人偿还贷款以释放 NFT
        const repayAmountWei = await demo.connect(owner).viewRepayAmount(1);
        await demo.connect(owner).repayLoan(1, repayAmountWei);
        
        // Check if the NFT is returned to the original owner after the loan is repaid
        // 检查贷款偿还后 NFT 是否返回给原始所有者
        expect(await demo.userOf(1)).to.equal("0x0000000000000000000000000000000000000000");
    });
    });

// 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
    //构造函数用于使用给定的名称和符号初始化永久合约 NFT 合约
    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.
        // 贷款金额应反映 NFT 所代表的资产价值，同时考虑到适当的贷款价值比 (LTV)。
        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
        // 检查 repayAmount 是否足以至少支付一部分到期总额
        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
        // 如果全部贷款金额已全部偿还，则将 NFT 的用户重置为默认状态
        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.
        // 利息按小时计算，按贷款实际持有时间按比例计算。
        // 如果借款人在贷款期限结束前偿还贷款，则仅收取贷款持有期间的利息。
        // 例如，如果年利率为 5%，并且借款人在贷款期限的一半时偿还贷款，则他们仅支付 2.5% 的利息。
        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
        // 示例：15/4 = 3.75
        // round((15 + 4 - 1)/4) = 4, round((15/4) = 3)
        // 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
    // 其他功能和逻辑，用于处理贷款违约、转移和 NFT 生命周期的其他方面
}