Merge pull request #147 from solidstate-network/ERC2981

ERC2981

Author: 0xCourtney

abi/ERC2981.json

@@ -0,0 +1,50 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "tokenId",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "salePrice",
+        "type": "uint256"
+      }
+    ],
+    "name": "royaltyInfo",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes4",
+        "name": "interfaceId",
+        "type": "bytes4"
+      }
+    ],
+    "name": "supportsInterface",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

abi/IERC2981.json

@@ -0,0 +1,50 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "tokenId",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "salePrice",
+        "type": "uint256"
+      }
+    ],
+    "name": "royaltyInfo",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "receiever",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "royaltyAmount",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes4",
+        "name": "interfaceId",
+        "type": "bytes4"
+      }
+    ],
+    "name": "supportsInterface",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

contracts/interfaces/IERC2981.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.8;
+
+import { IERC165 } from './IERC165.sol';
+import { IERC2981Internal } from './IERC2981Internal.sol';
+
+/**
+ * @title ERC2981 interface
+ * @dev see https://eips.ethereum.org/EIPS/eip-2981
+ */
+interface IERC2981 is IERC2981Internal, IERC165 {
+    /**
+     * @notice called with the sale price to determine how much royalty is owed and to whom
+     * @param tokenId the ERC721 or ERC1155 token id to query for royalty information
+     * @param salePrice the sale price of the given asset
+     * @return receiever rightful recipient of royalty
+     * @return royaltyAmount amount of royalty owed
+     */
+    function royaltyInfo(uint256 tokenId, uint256 salePrice)
+        external
+        view
+        returns (address receiever, uint256 royaltyAmount);
+}

contracts/interfaces/IERC2981Internal.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.8;
+
+/**
+ * @title ERC2981 interface
+ */
+interface IERC2981Internal {
+
+}

contracts/token/common/ERC2981/ERC2981.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.8;
+
+import { IERC2981 } from '../../../interfaces/IERC2981.sol';
+
+import { ERC2981Storage } from './ERC2981Storage.sol';
+import { ERC2981Internal } from './ERC2981Internal.sol';
+
+/**
+ * @title ERC2981 implementation
+ */
+abstract contract ERC2981 is IERC2981, ERC2981Internal {
+    /**
+     * @notice inheritdoc IERC2981
+     */
+    function royaltyInfo(uint256 tokenId, uint256 salePrice)
+        external
+        view
+        returns (address, uint256)
+    {
+        return _royaltyInfo(tokenId, salePrice);
+    }
+}

contracts/token/common/ERC2981/ERC2981Internal.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.8;
+
+import { ERC2981Storage } from './ERC2981Storage.sol';
+import { IERC2981Internal } from '../../../interfaces/IERC2981Internal.sol';
+
+/**
+ * @title ERC2981 internal functions
+ */
+abstract contract ERC2981Internal is IERC2981Internal {
+    /**
+     * @notice calculate how much royalty is owed and to whom
+     * @dev royalty must be paid in addition to, rather than deducted from, salePrice
+     * @param tokenId the ERC721 or ERC1155 token id to query for royalty information
+     * @param salePrice the sale price of the given asset
+     * @return royaltyReceiver rightful recipient of royalty
+     * @return royalty amount of royalty owed
+     */
+    function _royaltyInfo(uint256 tokenId, uint256 salePrice)
+        internal
+        view
+        virtual
+        returns (address royaltyReceiver, uint256 royalty)
+    {
+        uint256 royaltyBPS = _getRoyaltyBPS(tokenId);
+
+        // intermediate multiplication overflow is theoretically possible here, but
+        // not an issue in practice because of practical constraints of salePrice
+        return (_getRoyaltyReceiver(tokenId), (royaltyBPS * salePrice) / 10000);
+    }
+
+    /**
+     * @notice query the royalty rate (denominated in basis points) for given token id
+     * @dev implementation supports per-token-id values as well as a global default
+     * @param tokenId token whose royalty rate to query
+     * @return royaltyBPS royalty rate
+     */
+    function _getRoyaltyBPS(uint256 tokenId)
+        internal
+        view
+        virtual
+        returns (uint16 royaltyBPS)
+    {
+        ERC2981Storage.Layout storage l = ERC2981Storage.layout();
+        royaltyBPS = l.royaltiesBPS[tokenId];
+
+        if (royaltyBPS == 0) {
+            royaltyBPS = l.defaultRoyaltyBPS;
+        }
+    }
+
+    /**
+     * @notice query the royalty receiver for given token id
+     * @dev implementation supports per-token-id values as well as a global default
+     * @param tokenId token whose royalty receiver to query
+     * @return royaltyReceiver royalty receiver
+     */
+    function _getRoyaltyReceiver(uint256 tokenId)
+        internal
+        view
+        virtual
+        returns (address royaltyReceiver)
+    {
+        ERC2981Storage.Layout storage l = ERC2981Storage.layout();
+        royaltyReceiver = l.royaltyReceivers[tokenId];
+
+        if (royaltyReceiver == address(0)) {
+            royaltyReceiver = l.defaultRoyaltyReceiver;
+        }
+    }
+}

contracts/token/common/ERC2981/ERC2981Mock.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.8;
+
+import { ERC2981, IERC2981 } from './ERC2981.sol';
+import { ERC2981Storage } from './ERC2981Storage.sol';
+
+import { IERC165, ERC165, ERC165Storage } from '../../../introspection/ERC165.sol';
+
+contract ERC2981Mock is ERC2981, ERC165 {
+    using ERC165Storage for ERC165Storage.Layout;
+
+    constructor(
+        uint16 defaultRoyaltyBPS,
+        uint16[] memory royaltiesBPS,
+        address defaultRoyaltyReceiver
+    ) {
+        {
+            ERC2981Storage.Layout storage l = ERC2981Storage.layout();
+            l.defaultRoyaltyBPS = defaultRoyaltyBPS;
+            l.defaultRoyaltyReceiver = defaultRoyaltyReceiver;
+
+            for (uint8 i = 0; i < royaltiesBPS.length; i++) {
+                l.royaltiesBPS[i] = royaltiesBPS[i];
+            }
+        }
+
+        {
+            ERC165Storage.Layout storage l = ERC165Storage.layout();
+            l.setSupportedInterface(type(IERC165).interfaceId, true);
+            l.setSupportedInterface(type(IERC2981).interfaceId, true);
+        }
+    }
+
+    function setRoyalty(uint16 defaultRoyaltyBPS) external {
+        ERC2981Storage.layout().defaultRoyaltyBPS = defaultRoyaltyBPS;
+    }
+}

contracts/token/common/ERC2981/ERC2981Storage.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.8;
+
+library ERC2981Storage {
+    struct Layout {
+        // token id -> royalty (denominated in basis points)
+        mapping(uint256 => uint16) royaltiesBPS;
+        uint16 defaultRoyaltyBPS;
+        // token id -> receiver address
+        mapping(uint256 => address) royaltyReceivers;
+        address defaultRoyaltyReceiver;
+    }
+
+    bytes32 internal constant STORAGE_SLOT =
+        keccak256('solidstate.contracts.storage.ERC2981');
+
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            l.slot := slot
+        }
+    }
+}

spec/token/common/ERC2981.behavior.ts

@@ -0,0 +1,65 @@
+import { describeBehaviorOfERC165 } from '../../introspection';
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
+import { describeFilter } from '@solidstate/library';
+import { ERC2981Mock } from '@solidstate/typechain-types';
+import { expect } from 'chai';
+import { BigNumber } from 'ethers';
+import { ethers } from 'hardhat';
+
+export function describeBehaviorOfERC2981(
+  deploy: () => Promise<ERC2981Mock>,
+  skips?: string[],
+) {
+  const describe = describeFilter(skips);
+
+  describe('::ERC2981', function () {
+    let tokenIdOne = BigNumber.from(1);
+    let tokenIdTwo = BigNumber.from(2);
+    let tokenIdThree = BigNumber.from(3);
+
+    let receiver: SignerWithAddress;
+    let instance: ERC2981Mock;
+
+    before(async function () {
+      receiver = (await ethers.getSigners())[1];
+      instance = await deploy();
+    });
+
+    describeBehaviorOfERC165(
+      deploy,
+      {
+        interfaceIds: ['0x2a55205a'],
+      },
+      skips,
+    );
+
+    describe('#royaltyInfo()', () => {
+      it('returns 0 if salePrice is 0', async function () {
+        const [, royaltyAmount] = await instance.royaltyInfo(
+          0,
+          BigNumber.from(0),
+        );
+
+        expect(royaltyAmount).to.equal(BigNumber.from(0));
+      });
+
+      it('returns receiver address', async function () {
+        const [recipient] = await instance.royaltyInfo(0, BigNumber.from(0));
+        expect(recipient).to.equal(await receiver.getAddress());
+      });
+
+      it('calculates royalty using global if local does not exist', async function () {
+        let [, royaltyAmount] = await instance.royaltyInfo(0, 10000);
+        expect(royaltyAmount).to.equal(BigNumber.from(10000));
+      });
+
+      it('calculates royalty using local', async function () {
+        let [, royaltyAmount] = await instance.royaltyInfo(tokenIdOne, 10000);
+        expect(royaltyAmount).to.equal(BigNumber.from(100));
+
+        [, royaltyAmount] = await instance.royaltyInfo(tokenIdTwo, 10000);
+        expect(royaltyAmount).to.equal(BigNumber.from(1000));
+      });
+    });
+  });
+}

spec/token/common/index.ts

@@ -0,0 +1 @@
+export * from './ERC2981.behavior';