Implement Non Fungible Token Royalty (EIP2981)

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+ * `ERC2891`: add a new extension of `ERC721` to handle royalty information.([]())
  * `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,23 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "../token/ERC721/extensions/draft-ERC721Royalty.sol";
+
+contract ERC721RoyaltyMock is ERC721Royalty {
+    bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
+
+    constructor() public {}
+
+    function setTokenRoyalty(
+        uint256 tokenId,
+        address recipient,
+        uint256 fraction
+    ) public {
+        _setTokenRoyalty(tokenId, recipient, fraction);
+    }
+
+    function setGlobalRoyalty(address recipient, uint256 fraction) public {
+        _setGlobalRoyalty(recipient, fraction);
+    }
+}

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

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/draft-ERC721Royalty.sol)
+
+pragma solidity ^0.8.0;
+
+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 ERC165, IERC721Royalty {
+    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 < 100, "ERC2981: Royalty percentage is too high");
+        require(receiver != address(0), "ERC2981: Invalid receiver");
+
+        _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 < 100, "ERC2981: Royalty percentage is too high");
+        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) {
+        address receiver;
+        uint256 royaltyAmount;
+
+        if (_tokenRoyaltyInfo[_tokenId].receiver != address(0)) {
+            RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];
+            receiver = royalty.receiver;
+            royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();
+        } else {
+            receiver = _globalRoyaltyInfo.receiver;
+            royaltyAmount = (_salePrice * _globalRoyaltyInfo.royaltyFraction) / _feeDenominator();
+        }
+
+        return (receiver, royaltyAmount);
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, 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;
+    }
+}

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

@@ -0,0 +1,27 @@
+// 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
+ *
+ * _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,114 @@
+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();
+  });
+
+  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('100')),
+        'ERC2981: Royalty percentage is too high',
+      );
+    });
+  });
+
+  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('100')),
+        'ERC2981: Royalty percentage is too high',
+      );
+    });
+  });
+});

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 = {};