Implement Non Fungible Token Royalty (EIP2981)

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+ * `ERC2891`: add a new extension of `ERC721` to handle royalty information.([#3012](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3012))
  * `GovernorTimelockControl`: improve the `state()` function to have it reflect cases where a proposal has been canceled directly on the timelock. ([#2977](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2977))
  * `Math`: add a `abs(int256)` method that returns the unsigned absolute value of a signed value. ([#2984](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2984))
  * Preset contracts are now deprecated in favor of [Contracts Wizard](https://wizard.openzeppelin.com). ([#2986](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2986))

contracts/interfaces/IERC2981.sol

@@ -14,10 +14,10 @@ interface IERC2981 is IERC165 {
      * @param tokenId - the NFT asset queried for royalty information
      * @param salePrice - the sale price of the NFT asset specified by `tokenId`
      * @return receiver - address of who should be sent the royalty payment
-     * @return royaltyAmount - the royalty payment amount for `salePrice`
+     * @return royaltyFraction - the royalty payment amount for `salePrice`
      */
     function royaltyInfo(uint256 tokenId, uint256 salePrice)
         external
         view
-        returns (address receiver, uint256 royaltyAmount);
+        returns (address receiver, uint256 royaltyFraction);
 }

contracts/interfaces/draft-IERC2981.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/draft-ERC721Royalty.sol)
+
+pragma solidity ^0.8.0;
+
+import "../token/ERC721/extensions/draft-IERC721Royalty.sol";

contracts/mocks/ERC721RoyaltyMock.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "../token/ERC721/extensions/draft-ERC721Royalty.sol";
+
+contract ERC721RoyaltyMock is ERC721Royalty {
+    constructor(string memory name, string memory symbol) ERC721(name, symbol) {}
+
+    function setTokenRoyalty(
+        uint256 tokenId,
+        address recipient,
+        uint256 fraction
+    ) public {
+        _setTokenRoyalty(tokenId, recipient, fraction);
+    }
+
+    function setGlobalRoyalty(address recipient, uint256 fraction) public {
+        _setGlobalRoyalty(recipient, fraction);
+    }
+
+    function mint(address to, uint256 tokenId) public {
+        _mint(to, tokenId);
+    }
+
+    function burn(uint256 tokenId) public {
+        _burn(tokenId);
+    }
+}

contracts/token/ERC721/extensions/draft-ERC721Royalty.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/draft-ERC721Royalty.sol)
+
+pragma solidity ^0.8.0;
+
+import "../ERC721.sol";
+import "./draft-IERC721Royalty.sol";
+import "../../../utils/introspection/ERC165.sol";
+
+/**
+ * @dev Implementation of the ERC721 Royalty extension allowing royalty information to be stored and retrieved, as defined in
+ * https://eips.ethereum.org/EIPS/eip-2981[EIP-2981].
+ *
+ * Adds the {_setTokenRoyalty} methods to set the token royalty information, and {_setGlobalRoyalty} method to set a global
+ * royalty information.
+ *
+ * _Available since v4.5._
+ */
+abstract contract ERC721Royalty is IERC721Royalty, ERC721 {
+    struct RoyaltyInfo {
+        address receiver;
+        uint256 royaltyFraction;
+    }
+
+    RoyaltyInfo private _globalRoyaltyInfo;
+    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
+
+    /**
+     * @dev Sets tokens royalties
+     *
+     * Requirements:
+     * - `tokenId` must be already mined.
+     * - `receiver` cannot be the zero address.
+     * - `fraction` must indicate the percentage fraction using two decimals.
+     */
+    function _setTokenRoyalty(
+        uint256 tokenId,
+        address receiver,
+        uint256 fraction
+    ) internal virtual {
+        require(fraction > 0, "ERC2981: Royalty percentage is too low");
+        require(fraction <= _feeDenominator(), "ERC2981: Royalty percentage will exceed salePrice");
+        require(receiver != address(0), "ERC2981: Invalid receiver");
+        require(_exists(tokenId), "ERC2981: Nonexistent token");
+
+        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, fraction);
+    }
+
+    /**
+     *
+     * @dev Sets global royalty
+     *
+     * Requirements:
+     * - `receiver` cannot be the zero address.
+     * - `fraction` must indicate the percentage fraction. Needs to be set appropriately
+     * according to the _feeDenominator granularity.
+     */
+    function _setGlobalRoyalty(address receiver, uint256 fraction) internal virtual {
+        require(fraction > 0, "ERC2981: Royalty percentage is too low");
+        require(fraction <= _feeDenominator(), "ERC2981: Royalty percentage will exceed salePrice");
+        require(receiver != address(0), "ERC2981: Invalid receiver");
+
+        _globalRoyaltyInfo = RoyaltyInfo(receiver, fraction);
+    }
+
+    /**
+     * @dev See {IERC721Royalty-royaltyInfo}
+     */
+    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view override returns (address, uint256) {
+        RoyaltyInfo memory royalty;
+
+        if (_tokenRoyaltyInfo[_tokenId].receiver != address(0)) {
+            royalty = _tokenRoyaltyInfo[_tokenId];
+        } else {
+            royalty = _globalRoyaltyInfo;
+        }
+
+        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();
+
+        return (royalty.receiver, royaltyAmount);
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, IERC165) returns (bool) {
+        return interfaceId == type(IERC721Royalty).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    /**
+     * @dev Returns the percentage granularity being used. The default denominator is 10000
+     *  but it can be customized by an override.
+     */
+    function _feeDenominator() internal pure virtual returns (uint256) {
+        return 10000;
+    }
+
+    /**
+     * @dev Removes `tokenId` royalty information.
+     * The royalty information is cleared when the token is burned.
+     *
+     * Requirements:
+     *
+     * - `tokenId` royalty information must exist.
+     *
+     */
+    function _deleteTokenRoyalty(uint256 tokenId) internal virtual {
+        if (_tokenRoyaltyInfo[tokenId].royaltyFraction != 0) {
+            delete _tokenRoyaltyInfo[tokenId];
+        }
+    }
+
+    /**
+     * @dev Destroys `tokenId`.
+     * The royalty information is cleared when the token is burned.
+     *
+     * Requirements:
+     *
+     * - `tokenId` must exist.
+     *
+     * Emits a {Transfer} event.
+     */
+    function _burn(uint256 tokenId) internal virtual override {
+        super._burn(tokenId);
+        _deleteTokenRoyalty(tokenId);
+    }
+}

contracts/token/ERC721/extensions/draft-IERC721Royalty.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/draft-ERC721Royalty.sol)
+
+pragma solidity ^0.8.0;
+
+import "../../../interfaces/IERC165.sol";
+
+/**
+ * @dev Interface for the NFT Royalty Standard.
+ *
+ * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
+ * support for royalty payments across all NFT marketplaces and ecosystem participants.
+ * _Available since v4.5._
+ */
+interface IERC721Royalty is IERC165 {
+    /**
+     * @dev Called with the sale price to determine how much royalty
+     * is owed and to whom.
+     *
+     * Requirements:
+     * - `_tokenId` must be already mined, and have its royalty info set
+     * - `_salePrice` cannot be the zero.
+     *
+     */
+    function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
+        external
+        view
+        returns (address receiver, uint256 royaltyFraction);
+}

test/token/ERC721/extensions/ERC721Royalty.test.js

@@ -0,0 +1,145 @@
+const { BN, constants, expectRevert } = require('@openzeppelin/test-helpers');
+const { expect } = require('chai');
+const { ZERO_ADDRESS } = constants;
+
+const { shouldSupportInterfaces } = require('../../../utils/introspection/SupportsInterface.behavior');
+
+const ERC721RoyaltyMock = artifacts.require('ERC721RoyaltyMock');
+
+contract('ERC721Royalty', function (accounts) {
+  const [ account1 ] = accounts;
+  const tokenId1 = new BN('1');
+  const tokenId2 = new BN('2');
+  const salePrice = new BN('1000');
+  const royaltyFraction = new BN('10');
+
+  beforeEach(async function () {
+    this.token = await ERC721RoyaltyMock.new('My Token', 'TKN');
+
+    await this.token.mint(account1, tokenId1);
+    await this.token.mint(account1, tokenId2);
+  });
+
+  shouldSupportInterfaces(['ERC2981']);
+
+  describe('global royalty', function () {
+    beforeEach(async function () {
+      await this.token.setGlobalRoyalty(account1, royaltyFraction);
+    });
+
+    it('updates royalty amount', async function () {
+      const newPercentage = new BN('25');
+      let royalty = new BN((salePrice * royaltyFraction) / 10000);
+      // Initial royalty check
+      const initInfo = await this.token.royaltyInfo(tokenId1, salePrice);
+
+      expect(initInfo[0]).to.be.equal(account1);
+      expect(initInfo[1]).to.be.bignumber.equal(royalty);
+
+      // Updated royalty check
+      await this.token.setGlobalRoyalty(account1, newPercentage);
+      royalty = new BN((salePrice * newPercentage) / 10000);
+      const newInfo = await this.token.royaltyInfo(tokenId1, salePrice);
+
+      expect(newInfo[0]).to.be.equal(account1);
+      expect(newInfo[1]).to.be.bignumber.equal(royalty);
+    });
+
+    it('holds same royalty value for different tokens', async function () {
+      const newPercentage = new BN('20');
+      await this.token.setGlobalRoyalty(account1, newPercentage);
+
+      const token1Info = await this.token.royaltyInfo(tokenId1, salePrice);
+      const token2Info = await this.token.royaltyInfo(tokenId2, salePrice);
+
+      expect(token1Info[1]).to.be.bignumber.equal(token2Info[1]);
+    });
+
+    it('reverts if invalid parameters', async function () {
+      await expectRevert(
+        this.token.setGlobalRoyalty(ZERO_ADDRESS, royaltyFraction),
+        'ERC2981: Invalid receiver',
+      );
+
+      await expectRevert(
+        this.token.setGlobalRoyalty(account1, new BN('0')),
+        'ERC2981: Royalty percentage is too low',
+      );
+
+      await expectRevert(
+        this.token.setTokenRoyalty(tokenId1, account1, new BN('11000')),
+        'ERC2981: Royalty percentage will exceed salePrice',
+      );
+    });
+  });
+
+  describe('token based royalty', function () {
+    beforeEach(async function () {
+      await this.token.setTokenRoyalty(tokenId1, account1, royaltyFraction);
+    });
+
+    it('updates royalty amount', async function () {
+      const newPercentage = new BN('25');
+      let royalty = new BN((salePrice * royaltyFraction) / 10000);
+      // Initial royalty check
+      const initInfo = await this.token.royaltyInfo(tokenId1, salePrice);
+
+      expect(initInfo[0]).to.be.equal(account1);
+      expect(initInfo[1]).to.be.bignumber.equal(royalty);
+
+      // Updated royalty check
+      await this.token.setTokenRoyalty(tokenId1, account1, newPercentage);
+      royalty = new BN((salePrice * newPercentage) / 10000);
+      const newInfo = await this.token.royaltyInfo(tokenId1, salePrice);
+
+      expect(newInfo[0]).to.be.equal(account1);
+      expect(newInfo[1]).to.be.bignumber.equal(royalty);
+    });
+
+    it('holds different values for different tokens', async function () {
+      const newPercentage = new BN('20');
+      await this.token.setTokenRoyalty(tokenId2, account1, newPercentage);
+
+      const token1Info = await this.token.royaltyInfo(tokenId1, salePrice);
+      const token2Info = await this.token.royaltyInfo(tokenId2, salePrice);
+
+      // must be different even at the same SalePrice
+      expect(token1Info[1]).to.not.be.equal(token2Info.royaltyFraction);
+    });
+
+    it('reverts if invalid parameters', async function () {
+      await expectRevert(
+        this.token.setTokenRoyalty(tokenId1, ZERO_ADDRESS, royaltyFraction),
+        'ERC2981: Invalid receiver',
+      );
+
+      await expectRevert(
+        this.token.setTokenRoyalty(tokenId1, account1, new BN('0')),
+        'ERC2981: Royalty percentage is too low',
+      );
+
+      await expectRevert(
+        this.token.setTokenRoyalty(tokenId1, account1, new BN('11000')),
+        'ERC2981: Royalty percentage will exceed salePrice',
+      );
+
+      await expectRevert(
+        this.token.setTokenRoyalty(new BN('787'), account1, new BN('100')),
+        'ERC2981: Nonexistent token',
+      );
+    });
+
+    it('removes royalty information after burn', async function () {
+      await this.token.burn(tokenId1);
+      const tokenInfo = await this.token.royaltyInfo(tokenId1, salePrice);
+
+      expect(tokenInfo[0]).to.be.equal(ZERO_ADDRESS);
+      expect(tokenInfo[1]).to.be.bignumber.equal(new BN('0'));
+
+      await expectRevert(
+        this.token.setTokenRoyalty(tokenId1, account1, new BN('100')),
+        'ERC2981: Nonexistent token',
+      );
+    });
+  });
+});

test/utils/introspection/SupportsInterface.behavior.js

@@ -74,6 +74,9 @@ const INTERFACES = {
     'proposalEta(uint256)',
     'queue(address[],uint256[],bytes[],bytes32)',
   ],
+  ERC2981: [
+    'royaltyInfo(uint256,uint256)',
+  ],
 };
 
 const INTERFACE_IDS = {};