dexorder

lib_openzeppelin_contracts/test/utils/introspection/ERC165.test.js

@@ -0,0 +1,18 @@
+const { ethers } = require('hardhat');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { shouldSupportInterfaces } = require('./SupportsInterface.behavior');
+
+async function fixture() {
+  return {
+    mock: await ethers.deployContract('$ERC165'),
+  };
+}
+
+describe('ERC165', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  shouldSupportInterfaces();
+});

lib_openzeppelin_contracts/test/utils/introspection/ERC165Checker.test.js

@@ -0,0 +1,245 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const DUMMY_ID = '0xdeadbeef';
+const DUMMY_ID_2 = '0xcafebabe';
+const DUMMY_ID_3 = '0xdecafbad';
+const DUMMY_UNSUPPORTED_ID = '0xbaddcafe';
+const DUMMY_UNSUPPORTED_ID_2 = '0xbaadcafe';
+const DUMMY_ACCOUNT = '0x1111111111111111111111111111111111111111';
+
+async function fixture() {
+  return { mock: await ethers.deployContract('$ERC165Checker') };
+}
+
+describe('ERC165Checker', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('ERC165 missing return data', function () {
+    before(async function () {
+      this.target = await ethers.deployContract('ERC165MissingData');
+    });
+
+    it('does not support ERC165', async function () {
+      expect(await this.mock.$supportsERC165(this.target)).to.be.false;
+    });
+
+    it('does not support mock interface via supportsInterface', async function () {
+      expect(await this.mock.$supportsInterface(this.target, DUMMY_ID)).to.be.false;
+    });
+
+    it('does not support mock interface via supportsAllInterfaces', async function () {
+      expect(await this.mock.$supportsAllInterfaces(this.target, [DUMMY_ID])).to.be.false;
+    });
+
+    it('does not support mock interface via getSupportedInterfaces', async function () {
+      expect(await this.mock.$getSupportedInterfaces(this.target, [DUMMY_ID])).to.deep.equal([false]);
+    });
+
+    it('does not support mock interface via supportsERC165InterfaceUnchecked', async function () {
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, DUMMY_ID)).to.be.false;
+    });
+  });
+
+  describe('ERC165 malicious return data', function () {
+    beforeEach(async function () {
+      this.target = await ethers.deployContract('ERC165MaliciousData');
+    });
+
+    it('does not support ERC165', async function () {
+      expect(await this.mock.$supportsERC165(this.target)).to.be.false;
+    });
+
+    it('does not support mock interface via supportsInterface', async function () {
+      expect(await this.mock.$supportsInterface(this.target, DUMMY_ID)).to.be.false;
+    });
+
+    it('does not support mock interface via supportsAllInterfaces', async function () {
+      expect(await this.mock.$supportsAllInterfaces(this.target, [DUMMY_ID])).to.be.false;
+    });
+
+    it('does not support mock interface via getSupportedInterfaces', async function () {
+      expect(await this.mock.$getSupportedInterfaces(this.target, [DUMMY_ID])).to.deep.equal([false]);
+    });
+
+    it('does not support mock interface via supportsERC165InterfaceUnchecked', async function () {
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, DUMMY_ID)).to.be.true;
+    });
+  });
+
+  describe('ERC165 not supported', function () {
+    beforeEach(async function () {
+      this.target = await ethers.deployContract('ERC165NotSupported');
+    });
+
+    it('does not support ERC165', async function () {
+      expect(await this.mock.$supportsERC165(this.target)).to.be.false;
+    });
+
+    it('does not support mock interface via supportsInterface', async function () {
+      expect(await this.mock.$supportsInterface(this.target, DUMMY_ID)).to.be.false;
+    });
+
+    it('does not support mock interface via supportsAllInterfaces', async function () {
+      expect(await this.mock.$supportsAllInterfaces(this.target, [DUMMY_ID])).to.be.false;
+    });
+
+    it('does not support mock interface via getSupportedInterfaces', async function () {
+      expect(await this.mock.$getSupportedInterfaces(this.target, [DUMMY_ID])).to.deep.equal([false]);
+    });
+
+    it('does not support mock interface via supportsERC165InterfaceUnchecked', async function () {
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, DUMMY_ID)).to.be.false;
+    });
+  });
+
+  describe('ERC165 supported', function () {
+    beforeEach(async function () {
+      this.target = await ethers.deployContract('ERC165InterfacesSupported', [[]]);
+    });
+
+    it('supports ERC165', async function () {
+      expect(await this.mock.$supportsERC165(this.target)).to.be.true;
+    });
+
+    it('does not support mock interface via supportsInterface', async function () {
+      expect(await this.mock.$supportsInterface(this.target, DUMMY_ID)).to.be.false;
+    });
+
+    it('does not support mock interface via supportsAllInterfaces', async function () {
+      expect(await this.mock.$supportsAllInterfaces(this.target, [DUMMY_ID])).to.be.false;
+    });
+
+    it('does not support mock interface via getSupportedInterfaces', async function () {
+      expect(await this.mock.$getSupportedInterfaces(this.target, [DUMMY_ID])).to.deep.equal([false]);
+    });
+
+    it('does not support mock interface via supportsERC165InterfaceUnchecked', async function () {
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, DUMMY_ID)).to.be.false;
+    });
+  });
+
+  describe('ERC165 and single interface supported', function () {
+    beforeEach(async function () {
+      this.target = await ethers.deployContract('ERC165InterfacesSupported', [[DUMMY_ID]]);
+    });
+
+    it('supports ERC165', async function () {
+      expect(await this.mock.$supportsERC165(this.target)).to.be.true;
+    });
+
+    it('supports mock interface via supportsInterface', async function () {
+      expect(await this.mock.$supportsInterface(this.target, DUMMY_ID)).to.be.true;
+    });
+
+    it('supports mock interface via supportsAllInterfaces', async function () {
+      expect(await this.mock.$supportsAllInterfaces(this.target, [DUMMY_ID])).to.be.true;
+    });
+
+    it('supports mock interface via getSupportedInterfaces', async function () {
+      expect(await this.mock.$getSupportedInterfaces(this.target, [DUMMY_ID])).to.deep.equal([true]);
+    });
+
+    it('supports mock interface via supportsERC165InterfaceUnchecked', async function () {
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, DUMMY_ID)).to.be.true;
+    });
+  });
+
+  describe('ERC165 and many interfaces supported', function () {
+    const supportedInterfaces = [DUMMY_ID, DUMMY_ID_2, DUMMY_ID_3];
+    beforeEach(async function () {
+      this.target = await ethers.deployContract('ERC165InterfacesSupported', [supportedInterfaces]);
+    });
+
+    it('supports ERC165', async function () {
+      expect(await this.mock.$supportsERC165(this.target)).to.be.true;
+    });
+
+    it('supports each interfaceId via supportsInterface', async function () {
+      for (const interfaceId of supportedInterfaces) {
+        expect(await this.mock.$supportsInterface(this.target, interfaceId)).to.be.true;
+      }
+    });
+
+    it('supports all interfaceIds via supportsAllInterfaces', async function () {
+      expect(await this.mock.$supportsAllInterfaces(this.target, supportedInterfaces)).to.be.true;
+    });
+
+    it('supports none of the interfaces queried via supportsAllInterfaces', async function () {
+      const interfaceIdsToTest = [DUMMY_UNSUPPORTED_ID, DUMMY_UNSUPPORTED_ID_2];
+
+      expect(await this.mock.$supportsAllInterfaces(this.target, interfaceIdsToTest)).to.be.false;
+    });
+
+    it('supports not all of the interfaces queried via supportsAllInterfaces', async function () {
+      const interfaceIdsToTest = [...supportedInterfaces, DUMMY_UNSUPPORTED_ID];
+      expect(await this.mock.$supportsAllInterfaces(this.target, interfaceIdsToTest)).to.be.false;
+    });
+
+    it('supports all interfaceIds via getSupportedInterfaces', async function () {
+      expect(await this.mock.$getSupportedInterfaces(this.target, supportedInterfaces)).to.deep.equal(
+        supportedInterfaces.map(i => supportedInterfaces.includes(i)),
+      );
+    });
+
+    it('supports none of the interfaces queried via getSupportedInterfaces', async function () {
+      const interfaceIdsToTest = [DUMMY_UNSUPPORTED_ID, DUMMY_UNSUPPORTED_ID_2];
+
+      expect(await this.mock.$getSupportedInterfaces(this.target, interfaceIdsToTest)).to.deep.equal(
+        interfaceIdsToTest.map(i => supportedInterfaces.includes(i)),
+      );
+    });
+
+    it('supports not all of the interfaces queried via getSupportedInterfaces', async function () {
+      const interfaceIdsToTest = [...supportedInterfaces, DUMMY_UNSUPPORTED_ID];
+
+      expect(await this.mock.$getSupportedInterfaces(this.target, interfaceIdsToTest)).to.deep.equal(
+        interfaceIdsToTest.map(i => supportedInterfaces.includes(i)),
+      );
+    });
+
+    it('supports each interfaceId via supportsERC165InterfaceUnchecked', async function () {
+      for (const interfaceId of supportedInterfaces) {
+        expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, interfaceId)).to.be.true;
+      }
+    });
+  });
+
+  describe('account address does not support ERC165', function () {
+    it('does not support ERC165', async function () {
+      expect(await this.mock.$supportsERC165(DUMMY_ACCOUNT)).to.be.false;
+    });
+
+    it('does not support mock interface via supportsInterface', async function () {
+      expect(await this.mock.$supportsInterface(DUMMY_ACCOUNT, DUMMY_ID)).to.be.false;
+    });
+
+    it('does not support mock interface via supportsAllInterfaces', async function () {
+      expect(await this.mock.$supportsAllInterfaces(DUMMY_ACCOUNT, [DUMMY_ID])).to.be.false;
+    });
+
+    it('does not support mock interface via getSupportedInterfaces', async function () {
+      expect(await this.mock.$getSupportedInterfaces(DUMMY_ACCOUNT, [DUMMY_ID])).to.deep.equal([false]);
+    });
+
+    it('does not support mock interface via supportsERC165InterfaceUnchecked', async function () {
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(DUMMY_ACCOUNT, DUMMY_ID)).to.be.false;
+    });
+  });
+
+  it('Return bomb resistance', async function () {
+    this.target = await ethers.deployContract('ERC165ReturnBombMock');
+
+    const { gasUsed: gasUsed1 } = await this.mock.$supportsInterface.send(this.target, DUMMY_ID).then(tx => tx.wait());
+    expect(gasUsed1).to.be.lessThan(120_000n); // 3*30k + 21k + some margin
+
+    const { gasUsed: gasUsed2 } = await this.mock.$getSupportedInterfaces
+      .send(this.target, [DUMMY_ID, DUMMY_ID_2, DUMMY_ID_3, DUMMY_UNSUPPORTED_ID, DUMMY_UNSUPPORTED_ID_2])
+      .then(tx => tx.wait());
+
+    expect(gasUsed2).to.be.lessThan(250_000n); // (2+5)*30k + 21k + some margin
+  });
+});

lib_openzeppelin_contracts/test/utils/introspection/SupportsInterface.behavior.js

@@ -0,0 +1,145 @@
+const { expect } = require('chai');
+const { interfaceId } = require('../../helpers/methods');
+const { mapValues } = require('../../helpers/iterate');
+
+const INVALID_ID = '0xffffffff';
+const SIGNATURES = {
+  ERC165: ['supportsInterface(bytes4)'],
+  ERC721: [
+    'balanceOf(address)',
+    'ownerOf(uint256)',
+    'approve(address,uint256)',
+    'getApproved(uint256)',
+    'setApprovalForAll(address,bool)',
+    'isApprovedForAll(address,address)',
+    'transferFrom(address,address,uint256)',
+    'safeTransferFrom(address,address,uint256)',
+    'safeTransferFrom(address,address,uint256,bytes)',
+  ],
+  ERC721Enumerable: ['totalSupply()', 'tokenOfOwnerByIndex(address,uint256)', 'tokenByIndex(uint256)'],
+  ERC721Metadata: ['name()', 'symbol()', 'tokenURI(uint256)'],
+  ERC1155: [
+    'balanceOf(address,uint256)',
+    'balanceOfBatch(address[],uint256[])',
+    'setApprovalForAll(address,bool)',
+    'isApprovedForAll(address,address)',
+    'safeTransferFrom(address,address,uint256,uint256,bytes)',
+    'safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)',
+  ],
+  ERC1155MetadataURI: ['uri(uint256)'],
+  ERC1155Receiver: [
+    'onERC1155Received(address,address,uint256,uint256,bytes)',
+    'onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)',
+  ],
+  ERC1363: [
+    'transferAndCall(address,uint256)',
+    'transferAndCall(address,uint256,bytes)',
+    'transferFromAndCall(address,address,uint256)',
+    'transferFromAndCall(address,address,uint256,bytes)',
+    'approveAndCall(address,uint256)',
+    'approveAndCall(address,uint256,bytes)',
+  ],
+  AccessControl: [
+    'hasRole(bytes32,address)',
+    'getRoleAdmin(bytes32)',
+    'grantRole(bytes32,address)',
+    'revokeRole(bytes32,address)',
+    'renounceRole(bytes32,address)',
+  ],
+  AccessControlEnumerable: ['getRoleMember(bytes32,uint256)', 'getRoleMemberCount(bytes32)'],
+  AccessControlDefaultAdminRules: [
+    'defaultAdminDelay()',
+    'pendingDefaultAdminDelay()',
+    'defaultAdmin()',
+    'pendingDefaultAdmin()',
+    'defaultAdminDelayIncreaseWait()',
+    'changeDefaultAdminDelay(uint48)',
+    'rollbackDefaultAdminDelay()',
+    'beginDefaultAdminTransfer(address)',
+    'acceptDefaultAdminTransfer()',
+    'cancelDefaultAdminTransfer()',
+  ],
+  Governor: [
+    'name()',
+    'version()',
+    'COUNTING_MODE()',
+    'hashProposal(address[],uint256[],bytes[],bytes32)',
+    'state(uint256)',
+    'proposalThreshold()',
+    'proposalSnapshot(uint256)',
+    'proposalDeadline(uint256)',
+    'proposalProposer(uint256)',
+    'proposalEta(uint256)',
+    'proposalNeedsQueuing(uint256)',
+    'votingDelay()',
+    'votingPeriod()',
+    'quorum(uint256)',
+    'getVotes(address,uint256)',
+    'getVotesWithParams(address,uint256,bytes)',
+    'hasVoted(uint256,address)',
+    'propose(address[],uint256[],bytes[],string)',
+    'queue(address[],uint256[],bytes[],bytes32)',
+    'execute(address[],uint256[],bytes[],bytes32)',
+    'cancel(address[],uint256[],bytes[],bytes32)',
+    'castVote(uint256,uint8)',
+    'castVoteWithReason(uint256,uint8,string)',
+    'castVoteWithReasonAndParams(uint256,uint8,string,bytes)',
+    'castVoteBySig(uint256,uint8,address,bytes)',
+    'castVoteWithReasonAndParamsBySig(uint256,uint8,address,string,bytes,bytes)',
+  ],
+  ERC2981: ['royaltyInfo(uint256,uint256)'],
+};
+
+const INTERFACE_IDS = mapValues(SIGNATURES, interfaceId);
+
+function shouldSupportInterfaces(interfaces = []) {
+  interfaces.unshift('ERC165');
+
+  describe('ERC165', function () {
+    beforeEach(function () {
+      this.contractUnderTest = this.mock || this.token;
+    });
+
+    describe('when the interfaceId is supported', function () {
+      it('uses less than 30k gas', async function () {
+        for (const k of interfaces) {
+          const interface = INTERFACE_IDS[k] ?? k;
+          expect(await this.contractUnderTest.supportsInterface.estimateGas(interface)).to.lte(30_000n);
+        }
+      });
+
+      it('returns true', async function () {
+        for (const k of interfaces) {
+          const interfaceId = INTERFACE_IDS[k] ?? k;
+          expect(await this.contractUnderTest.supportsInterface(interfaceId), `does not support ${k}`).to.be.true;
+        }
+      });
+    });
+
+    describe('when the interfaceId is not supported', function () {
+      it('uses less than 30k', async function () {
+        expect(await this.contractUnderTest.supportsInterface.estimateGas(INVALID_ID)).to.lte(30_000n);
+      });
+
+      it('returns false', async function () {
+        expect(await this.contractUnderTest.supportsInterface(INVALID_ID), `supports ${INVALID_ID}`).to.be.false;
+      });
+    });
+
+    it('all interface functions are in ABI', async function () {
+      for (const k of interfaces) {
+        // skip interfaces for which we don't have a function list
+        if (SIGNATURES[k] === undefined) continue;
+
+        // Check the presence of each function in the contract's interface
+        for (const fnSig of SIGNATURES[k]) {
+          expect(this.contractUnderTest.interface.hasFunction(fnSig), `did not find ${fnSig}`).to.be.true;
+        }
+      }
+    });
+  });
+}
+
+module.exports = {
+  shouldSupportInterfaces,
+};