NFT Lending Integration

Integrate your NFT lending protocol with the Wasabi liquidity layer.

Requirements

1. A new smart contract that allows Wasabi to interact with your lending protocol,

2. API (or an SDK) that allows fetching for loan offers and any related variables & metadata (signature, nonce, etc.) required to borrow.

Part 1: Implementing the INFTLending Interface

We created an NFT lending interface that can make borrow and repay loans. Implement this interface which will call your protocol's smart contracts.

/// @notice NFTLending Interface
interface INFTLending {
    /// @notice Loan Details struct
    /// @param borrowAmount Borrow amount
    /// @param repayAmount Repay amount
    /// @param loanExpiration Loan expiration
    /// @param nftAddress The collateral NFT address
    /// @param tokenId The collateral NFT ID
    struct LoanDetails {
        uint256 borrowAmount;
        uint256 repayAmount;
        uint256 loanExpiration;
        address nftAddress;
        uint256 tokenId;
    }

    /// @notice Get loan details for given loan id
    /// @param _loanId The loan id
    function getLoanDetails(
        uint256 _loanId
    ) external view returns (LoanDetails memory);

    /// @notice Borrow WETH from the protocol
    /// @param _inputData Encoded input parameters
    /// @return _loanId The loan id
    function borrow(
        bytes calldata _inputData
    ) external payable returns (uint256 _loanId);

    /// @notice Repay the loan
    /// @param _loanId The if of loan to repay
    /// @param _receiver The address that should receive the collateral NFT
    function repay(uint256 _loanId, address _receiver) external payable;
}

Create a Solidity contract This contract should serve as the core component representing your lending protocol and must include the following functions:

• getLoanDetails(uint256 _loanId): Implement this function to retrieve comprehensive loan details based on a specified loan ID. It should return a LoanDetails object.

  • The repayAmount should be the principal + max interest. So if the lending protocol accrues interest, repayAmount should be returned as the fully accrued interest amount.

• borrow(bytes calldata _inputData): Develop this function to enable Wasabi to request and receive ETH loans from your protocol.

  • Related borrow request data that will be passed to the lending protocol will be appropriately encoded off-chain and should be decoded here. The decoded parameters should be used to call the lending protocol functions. The following snippet is from ArcadeLending.sol

 // 1. Decode `inputData` into appropriate variables
(
    LoanLibrary.LoanTerms memory loanTerms,
    address borrower,
    address lender,
    LoanLibrary.Signature memory sig,
    uint160 nonce,
    LoanLibrary.Predicate[] memory itemPredicates
) = abi.decode(
    _inputData,
    (LoanLibrary.LoanTerms, address, address, LoanLibrary.Signature, uint160, LoanLibrary.Predicate[])
);

• repay(uint256 _loanId, address _receiver): Implement this function to facilitate loan repayments initiated by Wasabi. Ensure the collateral NFTs are returned to the designated address.

Resources

• INFTLending Interface

• Example implementation (Arcade.xyz)

Part 2: Loan Offers

Create an API or SDK that the Wasabi team will be able to use to fetch collection loan offers from your protocol.

We require 2 endpoints,

• A collection offer list endpoint,

• A collection offer transaction data endpoint.

Collection Loan Offer List Endpoint

Create an endpoint that should return a list of collection-wide loan offers. This endpoint should take in a NFT collection address and filter offers with that address. For each offer, we need the following variables:

• id A unique ID that points to the loan offer

• loanAmount The amount that the borrower will receive

• duration The duration for the loan in seconds

• upfrontFee Any fee that is paid to the protocol when a user borrows, 0 otherwise

• totalAvailableSize The total available size for this offer.

  • For individual offers, it should match the loanAmount

  • If the offer can be taken up multiple times, then the total committed amount for the offer

Example:

{
      "id": "a7ba77f9-2417-42de-acb2-ffa038891e4c",
      "loanAmount": "3925306000000000000",
      "paybackAmount": "4312459468493150700",
      "duration": 2592000,
      "upfrontFee": "0",
      "totalAvailableSize": "3925306000000000000"
}

Offer Transaction Data Endpoint

Create an endpoint that will return the variables that should be used when borrowing from your protocol. These variables will be encoded and then sent for a transaction submission. Once the transaction is submitted, the data will be decoded and sent to your protocol. An example can be found here:

Part 1: Implementing the INFTLending Interface

Once these endpoints are created, you should send us documentation and examples so we can integrate them into our NFT Lending Indexer server.