EIP-2981: ERC-721 Royalty standard - Standardized means of accepting royalties for NFT marketplaces across the ecosystem

EIPS/EIP-1776.md

@@ -0,0 +1,187 @@
+---
+eip: 1776
+title: ERC-721 Royalty Standard
+author: Zach Burks (@vexycats)
+discussions-to: https://github.com/ethereum/EIPs/issues/2907
+status: Draft
+type: Standards Track
+category: ERC
+created: 2020-09-15
+requires: 721
+---
+
+## Simple Summary
+
+A standardized way to handle royalty payments for ERC-721 tokens, including publicly viewable information and notification of payment event.
+
+## Abstract
+
+Many of the largest ERC-721 marketplaces have implemented a form of royalties that is not compatible across the board and therefore worthless if the NFT is sold on another marketplace, defeating the purpose of any royalty system. This standard is a proposed way to minimally implement royalties that can be accepted across any type of NFT marketplace smart contracts. This standard allows for a royalty standard to be accepted on all marketplaces - leaving the funds transfer up to the marketplace itself, and only providing a means to fetch the royalty amounts and a event to be fired off when transfer has happened.  
+
+## Motivation
+
+This extension provides even more flexibility to the [ERC-721 specification](./eip-721.md). It is possible to set a royalty amount that can be paid to the creator on any marketplace that implements this ERC. If a marketplace chooses not to implement this ERC then of course no funds are paid for secondary sales. But seeing as how most NFT marketplace have developed some sort of royalty system themselves - and all of them are singular and only work on their own contracts - there needs to be an accepted standard way of providing royalties - if the creator so chooses to set royalties on their NFTs.
+Many decentralized marketplaces use different means to facilitate the trade of NFTs - therefore this ERC does not propose a method of transferring funds - but it simply provides a means to return the royalty amounts, and a function to be called once the transfer has been completed. Allowing each marketplace to easily integrate the standard in whatever flow they currently use for their marketplace.
+
+
+## Specification
+
+The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL
+NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and
+"OPTIONAL" in this document are to be interpreted as described in
+RFC 2119.
+
+**ERC-721 compliant contracts MAY implement this ERC for royalties to provide a standard method of accepting royalty payments and receiving royalty information**
+
+The `_RoyaltyAmount` **MUST** be calculated as a percentage - such as "5" - for 5%. This is **REQUIRED** to maintain uniformity across the standard. 
+
+Marketplaces that implement the `Royalty` standard **MAY** implement any method of calculation or transfer of funds depending on their marketplace style and smart contract code. 
+
+```solidity
+pragma solidity ^0.6.0;
+import "./ERC165.sol";
+
+/**
+ * @dev Implementation of royalties for 721s
+ *
+ */
+abstract contract Royalties is ERC165 {
+    /*
+     * ERC165 bytes to add to interface array - set in parent contract implementing this standard
+     *
+     * bytes4(keccak256('royaltyInfo()')) == 0x46e80720
+     * bytes4 private constant _INTERFACE_ID_ERC721ROYALTIES = 0x46e80720;
+     * _registerInterface(_INTERFACE_ID_ERC721ROYALTIES);
+     */
+
+    uint256 private royalty_amount;
+    address private creator;
+    bytes4 private constant _INTERFACE_ID_ERC721ROYALTIES = 0x46e80720;
+    /**
+    @notice This event is emitted when royalties are transferred.
+
+    @dev The marketplace would emit this event from their contracts. Or they would call royaltiesReceived() function.
+
+    @param creator The original creator of the NFT entitled to the royalties
+    @param buyer The person buying the NFT on a secondary sale
+    @param amount The amount being paid to the creator
+    */
+    event ReceivedRoyalties(
+        address indexed creator,
+        address indexed buyer,
+        uint256 indexed amount
+    );
+
+    /**
+     *  @notice Constructor called from the NFT being deployed with the value for the royalty in percentage and the creator who will receive the royalty payment
+     *
+     *  @param _amount The percentage value on each sale that will be transferred to the creator
+     *  @param _creator The original creator of the NFT entitled to the royalties
+     *
+     */
+
+    constructor(uint256 _amount, address _creator) internal {
+        royalty_amount = _amount;
+        creator = _creator;
+        _registerInterface(_INTERFACE_ID_ERC721ROYALTIES);
+    }
+
+    /**
+     *      @notice Called to return the royalty amount that was set and only return that amount
+     */
+    function royaltyAmount() public view returns (uint256) {
+        return royalty_amount;
+    }
+
+    /**
+     *      @notice Called to return both the creator's address and the royalty percentage - this would be the main function called by marketplaces unless they specifically need just the royaltyAmount
+     */
+    function royaltyInfo() external view returns (uint256, address) {
+        return (royalty_amount, creator);
+    }
+
+    /**
+     *      @notice Called to verify if contract implements royalties - OPTIONAL as supportsInterface()  can be called as well.
+     *      @param _creator The original creator of the NFT entitled to the royalties
+     *      @param _buyer The buyer of the NFT in a secondary sale
+     *      @param _amount The amount paid for royalties on this secondary sale. (Price of ERC721 sold * Royalty Percentage)
+     */
+    function royaltiesReceived(
+        address _creator,
+        address _buyer,
+        uint256 _amount
+    ) external {
+        emit ReceivedRoyalties(_creator, _buyer, _amount);
+    }
+
+    /**
+     *      @notice Called to verify if contract implements royalties - OPTIONAL as supportsInterface()  can be called as well.
+     */
+    function hasRoyalties() public pure returns (bool) {
+        return true;
+    }
+}
+
+
+
+```
+
+### Examples
+
+The `Royalty` ERC being used on a ERC-721 during deployment:
+
+**Deploying an ERC-721 and setting the royalty amount and creator**
+
+```   
+constructor (string memory name, string memory symbol, string memory baseURI)  public  Royalties(royalty_amount, msg.sender){
+        _name = name;
+        _symbol = symbol;
+        _setBaseURI(baseURI);
+        // register the supported interfaces to conform to ERC721 via ERC165
+        _registerInterface(_INTERFACE_ID_ERC721);
+        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
+        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
+        // Royalties interface 
+        _registerInterface(_INTERFACE_ID_ERC721ROYALTIES);
+    }
+```
+
+**Checking if the NFT being purchased/sold on your marketplace implemented royalties (note using address.call() is completely **OPTIONAL** and is just one method)**
+
+```  
+function checkRoyalties(address _token) internal  returns(bool){
+   (bool success,) = address(_token).call(abi.encodeWithSignature("royaltyInfo()"));
+    return success;
+    }
+```
+
+**Transferring funds and calling the event to be emitted**
+
+``` 
+   _recipient.transfer(amount);
+   IERC1776(_tokenAddress).royaltiesReceived(_recipient, _buyer, amount);
+```
+
+
+## Rationale
+
+There are many marketplaces for NFTs and the ones that support royalties are using their own standard version of royalties that are not compatible with other marketplaces. Just as in the early days of Ethereum, smart contracts are varied by ecosystem and not compatible. This would solve that issue such that an NFT created, purchased, or sold on one marketplace, provides the royalties that the creator is entitled too, regardless of the next marketplace/ecosystem it is sold at. 
+
+Without a set standard of way to do royalties, we won't have any effective means to provide royalties across the board, this obviously hampers the growth and adoption of NFTs, as the flexibility of the token and the UX is poor. 
+
+*"Yes we have royalties, but if your NFT is sold on another marketplace, we cannot provide royalties" .... "But can't I sell my NFT anywhere with a click of my wallet?" .... "Yes... but we don't have a standard for royalties so you'll lose out"*
+
+This is poor UX and easily fixed with an accepted standard. 
+
+
+## Backwards Compatibility
+
+Completely compatible with current ERC-721 standards - in fact it requires it. 
+
+## Security Considerations
+
+There are no security considerations related directly to the implementation of this standard.
+
+## Copyright
+
+Copyright and related rights waived via [CC0](https://creativecommons.org/publicdomain/zero/1.0/).