Interface for Staked Tokens in NFTs

[aug2uag]

---
eip: <to be assigned>
title: Interface for Staked Tokens in NFTs
description: This interface enables access to publicly viewable staking data of an NFT.
author: <Rex Creed (@aug2uag), Dane Scarborough <dane@nftapps.us>>
status: Draft
type: Standards Track
category: ERC
created: 2021-10-08
---

Abstract

ERC721s can be staked with tokens, but there's no means of retrieving the amount of tokens staked and/or bound to an NFT. This proposal outlines a standard that may be implemented by all wallets and marketplaces easily to correctly retrive the staked token amount of an NFT.

Motivation

The absence of staked tokens data limits the ability of the token owner to convey to another, for any purpose including to transact, the true amount of staked tokens as may be viewable in a wallet, marketplace, or explorer. The ability to identify and verify an exogenous value derived from the staking process may be critical to the aims of an NFT holder.

Specification

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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 IERC721Staked {
    
    /**
     * @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);

     /**
     * @dev Returns uint256 of the amount of on-chain ERC20 or like tokens staked and/or bound to the NFT.
     * 
     * @dev Wallets and marketplaces would need to call this for displaying the amount of tokens staked and/or bound to the NFT.
     */
    function stakedAmount() external view returns (uint256);
    
}

Suggested flow:

Constructor/deployment

• Creator - the owner of an NFT with its own rules for depositing tokens at and/or after the minting of a token.
• Token Amount - the current amount of on-chain ERC20 or derived tokens bound to an NFT from one or more deposits.

NFT displayed in wallet or marketplace

Wallet or marketplace checks if an NFT has publicly staked tokens available for view - if so, call stakedAmount() to get the current amount of tokens staked and/or bound to the NFT.

The logical code looks something like this and inspired by William Entriken:

abstract contract StakedNFT {

    /// @dev mapping tokenId to staked amount
    mapping (uint256 => uint256) private stakedTokens;
 
    /// @dev mints a new NFT
    /// @param _to address that will own the minted NFT
    /// @param _tokenId (timestamp) id the NFT
    function mint(
        address payable _to,
        uint256 _tokenId
    )
        external 
        payable
        onlyOwner
    {
        _safeMint(_to, _tokenId);
        stakedTokens[_tokenId] = msg.value;
    }

    /// @dev if interface is supported 
    /// @param interfaceId interface to check
    function supportsInterface
    (
        bytes4 interfaceId
    ) 
        public
        view
        virtual
        override
        (
            ERC165,
            IERC165
        )
        returns 
        (
            bool
        ) 
    {
        return
            super.supportsInterface(interfaceId);
    }

    /// @dev returns the current amount of tokens staked
    /// @param _tokenId target NFT
    function stakedAmount
    (
        uint256 _tokenId
    ) 
        public 
        view 
        returns 
        (
            uint256
        ) 
    {
        return stakedTokens[_tokenId];
    }

}

Rationale

This standard is completely agnostic to how tokens are deposited or handled by the NFT. It is, therefore, the choice and responsibility of the author to encode and communicate the encoding of their tokenomics to purchasees of their token and/or to make their contracts viewable by purchasees.

For example, tokens may be deposited at any time with any method. Also, tokens may be transferred at any time with any method. This method will identify whether the NFT has publicly vieweable staked tokens.

However, even if there are no tokens at any given time, the views should treat a supporting interface without any staked tokens assuming tokens may be added in the future. The contract logic should determine whether a possibility exists for additional tokens to be added, i.e., a depositingType boolean. For example, if all tokens are withdrawn and no additional tokens will be deposited, it would be desired for a non-supporting interface response to be returned. There may be additional identifiers whether the NFT is a one-time deposit and if the NFT disallows withdraw actions. These may help the interface to provide additional insight and standardizations across staking operations.

Copyright

Copyright and related rights waived via CC0.

[aug2uag]

One of the limiting features of staking NFTs is the inability to prove whether the value was removed while claiming to hold a value and proving that the NFT holds a value. To counter this:

• enforcing that value is added at mint where the transaction is easily identified
• enforcing the standard applies only to a single payable function at burn

These qualities are currently being used in production by myself and others; a standard would assist in the identification of conforming NFTs for display in wallets. I am in the process of developing such a wallet that will be displaying the staked amount of tokens of NFTs.

I'm looking forward to hearing feedback and input from others to push the goalpost on this.

[MicahZoltu]

If you want to move forward with this, I recommend turning it into an EIP by creating a pull request against this repository. Alternatively, you can open a discussion on Ethereum Magicians (see link from bot above). While this issue has been grandfathered in, we generally no longer use GitHub issues for EIP discussions.