PawningShop：一种NFT抵押借贷的实现

代码：PawningShop

contract PawningShop {

    using SafeMath for uint256;
    using SafeMath for uint8;

    enum PawnStatus {
        CREATED,
        CANCELLED,
        DEAL,
        LIQUIDATED,
        REPAID
    }
    struct Pawn {
        // who borrows money
        address creator;
        address contractAddress;
        uint256 tokenId;
        PawnStatus status;
    }
    struct Bid {
        address creator; // who create the bid
        uint256 loanAmount;
        // the amount of wei the lender lend to the borrower
        uint256 interest; // the maximum interest that the borrower have to pay in wei
        uint256 loanStartTime; // timestamp
        uint256 loanDuration; // duration in days
        bool isInterestProRated; // if the borrower pays sonner, then pays less interest
    }
    address public owner;
    address[] public _whiteListNFT;
    uint256 public _feeRate;
    uint256 public _totalNumberOfPawn = 0;
    uint256 public _totalNumberOfBid = 0;
    // mapping nft address -> token id -> pawn
    mapping(uint256 => Pawn) public _pawns;
    // mapping bid id => bid
    mapping(uint256 => Bid) public _bids;
    // mapping bid id to pawn id
    mapping(uint256 => uint256) public _bidToPawn;
    mapping(uint256 => uint256) public _pawnToBid;

    constructor() {
        owner = msg.sender;
    }

    event PawnCreated(address borrower, uint256 indexed pawnId);
    event PawnCancelled(address borrower, uint256 indexed pawnId);
    event PawnDeal(address borrower, address lender, uint256 indexed pawnId, uint256 bidId);
    event PawnRepaid(address borrower, address lender, uint256 indexed pawnId, uint256 bidId);
    event PawnLiquidated(address borrower, address lender, uint256 indexed pawnId, uint256 bidId);
    event BidCreated(address borrower, address lender, uint256 pawnId, uint256 indexed bidId);
    event BidAccepted(address borrower, address lender, uint256 pawnId, uint256 indexed bidId);
    event BidCancelled(address borrower, address lender, uint256 pawnId, uint256 indexed bidId);
    event WhiteListAdded(address smartContract);
    event WhiteListRemoved(address smartContract);

    function getPawnById(uint256 id) public view returns(Pawn memory) {
        return _pawns[id];
    }

    function createPawn(address tokenAddress, uint256 tokenId) public {
        _totalNumberOfPawn += 1;
        bool isInWhiteList = false;
        for (uint256 i = 0; i < _whiteListNFT.length; i++) {
            if (tokenAddress == _whiteListNFT[i]) {
                isInWhiteList = true;
            }
        }
        address sender = msg.sender;
        require(
            isInWhiteList == true,
            "PawningShop: smart contract is not in white list"
        );
        bool isApproved = IERC721(tokenAddress).getApproved(tokenId) ==
            address(this);
        bool isApprovedForAll = IERC721(tokenAddress).isApprovedForAll(
            sender,
            address(this)
        );
        require(
            isApproved || isApprovedForAll,
            "PawningShop: haven't got permission to transfer"
        );

        IERC721(tokenAddress).transferFrom(msg.sender, address(this), tokenId);

        _pawns[_totalNumberOfPawn].creator = sender;
        _pawns[_totalNumberOfPawn].contractAddress = tokenAddress;
        _pawns[_totalNumberOfPawn].tokenId = tokenId;
        _pawns[_totalNumberOfPawn].status = PawnStatus.CREATED;
        emit PawnCreated(sender, _totalNumberOfPawn);
    }

    function cancelPawn(uint256 pawnId) public {
        Pawn storage pawn = _pawns[pawnId];
        address creator = pawn.creator;
        require(
            pawn.status == PawnStatus.CREATED,
            "PawningShop: Only can cancel when it has status of CREATED"
        );
        require(
            msg.sender == creator,
            "PawningShop: Only owner of the pawn can cancel it"
        );
        require(
            _pawnToBid[pawnId] == 0,
            "PawningShop: Only can cancel when no bid is accepted"
        );
        pawn.status = PawnStatus.CANCELLED;
        IERC721(pawn.contractAddress).transferFrom(address(this), creator, pawn.tokenId);
        emit PawnCancelled(owner, pawnId);
    }

    function createBid(
        uint256 rate,
        uint256 duration,
        bool isInterestProRated,
        uint256 pawnId
    ) public payable {
        _totalNumberOfBid += 1;
        address lender = msg.sender;
        uint256 amount = msg.value;
        Pawn storage pawn = _pawns[pawnId];
        address borrower = pawn.creator;
        require(pawnId > 0, "PawningShop: pawn id is not valid");
        require(
            borrower != address(0) || pawn.contractAddress != address(0), 
            "Pawningshop: pawn is not existed"
        );
        require(
            borrower != lender,
            "PawningShop: creator of the pawn cannot make a bid"
        );
        require(
            pawn.status == PawnStatus.CREATED,
            "PawningShop: cannot bid this pawn"
        );
        require(
            amount > 0,
            "PawningShop: amount of money must be bigger than 0"
        );

        _bids[_totalNumberOfBid].creator = lender;
        _bids[_totalNumberOfBid].loanAmount = amount;
        _bids[_totalNumberOfBid].interest = rate;
        _bids[_totalNumberOfBid].loanDuration = duration;
        _bids[_totalNumberOfBid].isInterestProRated = isInterestProRated;
        // _bids[_totalNumberOfBid].loanStartTime = loanStartTime;
        // loanStartTime will be set when the borrower accepts bid

        _bidToPawn[_totalNumberOfBid] = pawnId;
        emit BidCreated(borrower, lender, pawnId, _totalNumberOfBid);
    }

    function cancelBid(uint256 bidId) public {
        Bid memory currBid = _bids[bidId];
        address payable lender = payable(currBid.creator);
        address sender = msg.sender;
        require(
            sender == lender,
            "PawningShop: only creator can cancel the bid"
        );
        uint256 pawnId = _bidToPawn[bidId];
        address borrower = _pawns[pawnId].creator;
        require(
            _pawnToBid[pawnId] != bidId,
            "PawningShop: your bid is accepted, cannot cancel"
        );
        lender.transfer(currBid.loanAmount);
        delete _bids[bidId];
        delete _bidToPawn[bidId];
        emit BidCancelled(borrower, lender, pawnId, bidId);
    }

    function acceptBid(uint256 bidId) public {
        Bid storage currBid = _bids[bidId];
        address lender = currBid.creator;
        uint256 pawnId = _bidToPawn[bidId];
        require(
            pawnId > 0,
            "PawningShop: The pawn is not existed"
        );
        Pawn storage pawn = _pawns[pawnId];
        address payable borrower = payable(pawn.creator);
        require(
            borrower == msg.sender,
            "PawningShop: only creator of pawn can accept bid"
        );
        borrower.transfer(currBid.loanAmount);
        pawn.status = PawnStatus.DEAL;
        _pawnToBid[pawnId] = bidId;
        currBid.loanStartTime = block.timestamp;
        emit BidAccepted(borrower, lender, pawnId, bidId);
    }

    function repaid(uint256 pawnId) public payable {
        Pawn storage currPawn = _pawns[pawnId];
        address borrower = currPawn.creator;
        require(
            borrower == msg.sender,
            "PawningShop: Only creator of pawn can repay"
        );
        uint256 bidId = _pawnToBid[pawnId];
        require(
            bidId != 0,
            "PawningShop: This pawn doen't have any accepted bid"
        );
        Bid storage currBid = _bids[bidId];
        uint256 repayDeadline = _calculateRepayDeadline(currBid.loanStartTime, currBid.loanDuration);
        require(
            block.timestamp <= repayDeadline,
            "PawningShop: to late to repaid"
        );
        uint256 value = msg.value;
        uint256 repaidAmount = _calculateRepaidAmount(
            currBid.loanAmount,
            currBid.interest,
            currBid.loanStartTime,
            currBid.loanDuration,
            currBid.isInterestProRated
        );
        require(
            value == repaidAmount,
            "PawningShop: pay exactly repaid amount"
        );
        // transfer token back to borrower
        IERC721(currPawn.contractAddress).transferFrom(address(this), currPawn.creator, currPawn.tokenId);
        // transfer money to lender
        address payable lender = payable(currBid.creator);
        lender.transfer(value);
        delete _pawnToBid[pawnId];
        delete _bidToPawn[bidId];
        emit PawnRepaid(borrower, lender, pawnId, bidId);
    }

    function _calculateRepayDeadline(uint256 loanStartTime, uint256 loanDuration) public pure returns(uint256) {
        uint256 loanDurationInSeconds = loanDuration.mul(1 days);
        uint256 repayDeadline = loanStartTime.add(loanDurationInSeconds);
        return repayDeadline;
    }

    function _calculateRepaidAmount(
        uint256 original, uint256 interest, uint256 loanStartTime, uint256 duration, bool isInterestProRated
    ) public view returns (uint256) {
        uint256 interestDue = interest;
        if (isInterestProRated) {
            uint256 interestPerDay = interest.div(duration);
            uint256 secondPassed = block.timestamp.sub(loanStartTime);
            uint256 dayPassed = ceilDiv(secondPassed, 1 days);
            interestDue = dayPassed.mul(interestPerDay);
        }
        return original.add(interestDue);
    }

    function getRepaidAmount(uint256 pawnId) public view returns(uint256) {
        require(pawnId > 0, "PawningShop: pawn id is not existed");
        uint256 bidId = _pawnToBid[pawnId];
        require(bidId > 0, "PawningShop: pawn doesn't have a accepted bid or the pawn is done");
        Bid storage bid = _bids[bidId];
        return _calculateRepaidAmount(bid.loanAmount, bid.interest, bid.loanStartTime, bid.loanDuration, bid.isInterestProRated);
    }
    
    // get this from openzeppelin
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }

    function liquidate(uint256 bidId) public {
        Bid storage currBid = _bids[bidId];
        address lender = currBid.creator;
        require(lender == msg.sender, "PawningShop: only creator of bid can liquidate token");
        require(block.timestamp > currBid.loanStartTime + currBid.loanAmount, "PawningShop: Not valid time to liquidate");
        uint256 pawnId = _bidToPawn[bidId];
        require(_pawnToBid[pawnId] == bidId, "PawningShop: this bid is not accepted by borrower");
        Pawn storage currPawn = _pawns[pawnId];
        address pawner = currPawn.creator;
        IERC721(currPawn.contractAddress).transferFrom(address(this), lender, currPawn.tokenId);
        emit PawnLiquidated(pawner, lender, pawnId, bidId);
    }

    function addToWhiteList(address smartContract) public {
        require(msg.sender == owner, "PawningShop: Only owner can add address to white list");
        require(smartContract != address(0), "PawningShop: smart contract address must be different with 0");
        uint256 i = 0;
        for (i = 0; i < _whiteListNFT.length; i++) {
            if (_whiteListNFT[i] == smartContract) {
                return;
            }
        }
        _whiteListNFT.push(smartContract);
        emit WhiteListAdded(smartContract);
    }

    function removeFromWhiteList(address smartContract) public {
        require(msg.sender == owner, "PawningShop: Only owner can remove address from white list");
        uint256 i;
        for (i = 0; i < _whiteListNFT.length; i++) {
            if (_whiteListNFT[i] == smartContract) {
                break;
            }
        }
        delete _whiteListNFT[i];
        emit WhiteListRemoved(smartContract);
    }

    function getWhiteList() public view returns(address[] memory) {
        return _whiteListNFT;
    }
}

1、概述

PawningShop是一种基于NFT的抵押借贷的实现。PawningShop中有两种角色：一种是抵押NFT的人，他需要通过抵押NFT借入一笔钱，我们叫他borrower，另一种是借出钱的人，我们叫他lender。

PawningShop的大致流程如下：

1、borrower创建一个NFT的抵押订单

2、lender针对抵押订单创建出价单，出价信息包括借出多少钱，借出的时间，以及借出的利息。

3、borrower选择一个合适出价单进行抵押借贷

4、borrower在规定时间内还本金和利息，就可以收回抵押的NFT

5、borrower如果没有在规定时间内归还本金和利息，lender就可以进行清算，这时候NFT就会被转移给lender。

PawningShop合约其实是有bug的，详情见下文，但是整体设计思路值得借鉴。

2、borrower创建抵押订单

function createPawn(address tokenAddress, uint256 tokenId) public {
        _totalNumberOfPawn += 1;
        bool isInWhiteList = false;
        for (uint256 i = 0; i < _whiteListNFT.length; i++) {
            if (tokenAddress == _whiteListNFT[i]) {
                isInWhiteList = true;
            }
        }
        address sender = msg.sender;
        require(
            isInWhiteList == true,
            "PawningShop: smart contract is not in white list"
        );
        bool isApproved = IERC721(tokenAddress).getApproved(tokenId) ==
            address(this);
        bool isApprovedForAll = IERC721(tokenAddress).isApprovedForAll(
            sender,
            address(this)
        );
        require(
            isApproved || isApprovedForAll,
            "PawningShop: haven't got permission to transfer"
        );

        IERC721(tokenAddress).transferFrom(msg.sender, address(this), tokenId);

        _pawns[_totalNumberOfPawn].creator = sender;
        _pawns[_totalNumberOfPawn].contractAddress = tokenAddress;
        _pawns[_totalNumberOfPawn].tokenId = tokenId;
        _pawns[_totalNumberOfPawn].status = PawnStatus.CREATED;
        emit PawnCreated(sender, _totalNumberOfPawn);
    }

首先生成订单号，然后校验是否是白名单，然后需要给PawningShop这个合约授权，然后将NFT转给这个合约保管。最后生成一条抵押记录。

3、borrower取消抵押订单

function cancelPawn(uint256 pawnId) public {
        Pawn storage pawn = _pawns[pawnId];
        address creator = pawn.creator;
        require(
            pawn.status == PawnStatus.CREATED,
            "PawningShop: Only can cancel when it has status of CREATED"
        );
        require(
            msg.sender == creator,
            "PawningShop: Only owner of the pawn can cancel it"
        );
        require(
            _pawnToBid[pawnId] == 0,
            "PawningShop: Only can cancel when no bid is accepted"
        );
        pawn.status = PawnStatus.CANCELLED;
        IERC721(pawn.contractAddress).transferFrom(address(this), creator, pawn.tokenId);
        emit PawnCancelled(owner, pawnId);
    }

首先根据订单号拿到抵押订单，然后校验订单状态，必须是创建状态，然后校验抵押人身份和当前操作人是否一致以及抵押订单是否存在，最后把订单改成取消状态，并且把NFT还给抵押人。

4、lender创建出借订单

function createBid(
        uint256 rate,
        uint256 duration,
        bool isInterestProRated,
        uint256 pawnId
    ) public payable {
        _totalNumberOfBid += 1;
        address lender = msg.sender;
        uint256 amount = msg.value;
        Pawn storage pawn = _pawns[pawnId];
        address borrower = pawn.creator;
        require(pawnId > 0, "PawningShop: pawn id is not valid");
        require(
            borrower != address(0) || pawn.contractAddress != address(0), 
            "Pawningshop: pawn is not existed"
        );
        require(
            borrower != lender,
            "PawningShop: creator of the pawn cannot make a bid"
        );
        require(
            pawn.status == PawnStatus.CREATED,
            "PawningShop: cannot bid this pawn"
        );
        require(
            amount > 0,
            "PawningShop: amount of money must be bigger than 0"
        );

        _bids[_totalNumberOfBid].creator = lender;
        _bids[_totalNumberOfBid].loanAmount = amount;
        _bids[_totalNumberOfBid].interest = rate;
        _bids[_totalNumberOfBid].loanDuration = duration;
        _bids[_totalNumberOfBid].isInterestProRated = isInterestProRated;
        // _bids[_totalNumberOfBid].loanStartTime = loanStartTime;
        // loanStartTime will be set when the borrower accepts bid

        _bidToPawn[_totalNumberOfBid] = pawnId;
        emit BidCreated(borrower, lender, pawnId, _totalNumberOfBid);
    }

首先生成出借单订单号，然后校验抵押订单的合法性，然后需要保证抵押人和出借人不能是同一个人，最后生成一个出借订单。这里使用msg.value作为出借金额，因此出借金额暂时由当前合约保管。

5、lender取消出借订单

function cancelBid(uint256 bidId) public {
        Bid memory currBid = _bids[bidId];
        address payable lender = payable(currBid.creator);
        address sender = msg.sender;
        require(
            sender == lender,
            "PawningShop: only creator can cancel the bid"
        );
        uint256 pawnId = _bidToPawn[bidId];
        address borrower = _pawns[pawnId].creator;
        require(
            _pawnToBid[pawnId] != bidId,
            "PawningShop: your bid is accepted, cannot cancel"
        );
        lender.transfer(currBid.loanAmount);
        delete _bids[bidId];
        delete _bidToPawn[bidId];
        emit BidCancelled(borrower, lender, pawnId, bidId);
    }

取消出借单会校验操作人权限，然后校验出借单是否被执行。如果没有被执行，会把出借金额转还给出借人。

6、borrower选择出借单

function acceptBid(uint256 bidId) public {
        Bid storage currBid = _bids[bidId];
        address lender = currBid.creator;
        uint256 pawnId = _bidToPawn[bidId];
        require(
            pawnId > 0,
            "PawningShop: The pawn is not existed"
        );
        Pawn storage pawn = _pawns[pawnId];
        address payable borrower = payable(pawn.creator);
        require(
            borrower == msg.sender,
            "PawningShop: only creator of pawn can accept bid"
        );
        borrower.transfer(currBid.loanAmount);
        pawn.status = PawnStatus.DEAL;
        _pawnToBid[pawnId] = bidId;
        currBid.loanStartTime = block.timestamp;
        emit BidAccepted(borrower, lender, pawnId, bidId);
    }

先通过出借单找到抵押单，然后找到抵押单对应的borrower，然后需要校验当前操作人就是borrower，最后把出借的钱转给borrower，更新抵押单的状态为完成，更新抵押单到出借单的关联关系。

这里似乎少了对抵押单状态的校验，这样borrower就可以多次执行acceptBid方法，如果当前合约有大量的ETH余额，就可以被全部套出来。

7、borrower正常还贷

function repaid(uint256 pawnId) public payable {
        Pawn storage currPawn = _pawns[pawnId];
        address borrower = currPawn.creator;
        require(
            borrower == msg.sender,
            "PawningShop: Only creator of pawn can repay"
        );
        uint256 bidId = _pawnToBid[pawnId];
        require(
            bidId != 0,
            "PawningShop: This pawn doen't have any accepted bid"
        );
        Bid storage currBid = _bids[bidId];
        uint256 repayDeadline = _calculateRepayDeadline(currBid.loanStartTime, currBid.loanDuration);
        require(
            block.timestamp <= repayDeadline,
            "PawningShop: to late to repaid"
        );
        uint256 value = msg.value;
        uint256 repaidAmount = _calculateRepaidAmount(
            currBid.loanAmount,
            currBid.interest,
            currBid.loanStartTime,
            currBid.loanDuration,
            currBid.isInterestProRated
        );
        require(
            value == repaidAmount,
            "PawningShop: pay exactly repaid amount"
        );
        // transfer token back to borrower
        IERC721(currPawn.contractAddress).transferFrom(address(this), currPawn.creator, currPawn.tokenId);
        // transfer money to lender
        address payable lender = payable(currBid.creator);
        lender.transfer(value);
        delete _pawnToBid[pawnId];
        delete _bidToPawn[bidId];
        emit PawnRepaid(borrower, lender, pawnId, bidId);
    }

首先校验borrower和操作人是否一致，然后拿到出借单，计算出借最晚归还时间，而且当前时间必须小于这个最晚归还时间，然后计算应付金额。然后把NFT转还给borrower，把应付金额转给lender。最后删除抵押单和出借单之间的关系。

这里多次调用repaid是不会有问题的，因为最后删掉了关联关系：delete _bidToPawn[bidId];

7、borrower还款超时，lender发起清算

function liquidate(uint256 bidId) public {
        Bid storage currBid = _bids[bidId];
        address lender = currBid.creator;
        require(lender == msg.sender, "PawningShop: only creator of bid can liquidate token");
        require(block.timestamp > currBid.loanStartTime + currBid.loanAmount, "PawningShop: Not valid time to liquidate");
        uint256 pawnId = _bidToPawn[bidId];
        require(_pawnToBid[pawnId] == bidId, "PawningShop: this bid is not accepted by borrower");
        Pawn storage currPawn = _pawns[pawnId];
        address pawner = currPawn.creator;
        IERC721(currPawn.contractAddress).transferFrom(address(this), lender, currPawn.tokenId);
        emit PawnLiquidated(pawner, lender, pawnId, bidId);
    }

首先校验操作人权限，然后校验是否真的超时，然后根据出借单找到抵押单，将抵押物转移给lender。