EIP 4353: Viewing Staked Tokens in NFT

aug2uag · October 9, 2021, 3:15am

I’m staking tokens on NFTs and would like an interface to get the amount of tokens staked by tokenId.

The proof-of-concept / prototype NFT did hold value / amount of tokens that were successfully transferred. Within the smart contract, an amount is mapped to tokenId, so I can get the value from an individual token in a custom manner.

However, I’m wanting the ability to see if other tokens on other contracts are staked for my UI/UX. For my purposes, value is only added at mint, and the token amount does not change-- this could vary on other implementations where proof-of-stake or post-mint deposits occur.

Any thoughts how retrieving token deposit / amount / staked could be accessed from web3? Does this already exist or could it become an EIP?

aug2uag · October 9, 2021, 5:11am

EIP issue was opened at:

github.com/ethereum/EIPs

Interface for Staked Tokens in NFTs

opened 04:57AM - 09 Oct 21 UTC

aug2uag

```yaml --- 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 ```js // 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](https://ethereum.stackexchange.com/a/70116/70167): ```js 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](https://creativecommons.org/publicdomain/zero/1.0/).

fulldecent · October 12, 2021, 4:11am

Before going ahead and standardizing something, please launch your own product and then after that build the case for why other people need to do this the exact same way you did it.

aug2uag · October 12, 2021, 5:21am

The product is available on the Apple AppStore under “Iconic Apps”, there are two apps in production beta undergoing finalization. The tokens are bound to NFTs at mint and in my use case the tokens are never able to be disassociated from commodity NFTs. In this way, we can ensure NFTs will remain with their assigned token amounts.

The primary impetus for my request is the need to display token values on an explorer and elsewhere including wallets and marketplaces. Although my app is not in its intended final state (it will be undergoing improvements to its tokenomics in the coming weeks), I encourage others to try and view staked token balances on NFTs to encounter the issue I am facing.

pizzarob · May 28, 2022, 2:03am

Hi. I think any kind of NFT staking is interesting and have implemented different variations in several products I’ve built over the last few years.

I guess my question is why does this need to be a standard and why now? It seems like you can definitely implement this interface and provide documentation for marketplaces and wallets to support but right now it seems very specific to your product. If there seemed to be interest in this standard I think it makes sense. But permanently staked ERC20 tokens tied to NFTs seems very one off, no?