Migrate ERC165 tests (#4794)

test/helpers/methods.js

@@ -1,5 +1,14 @@
 const { ethers } = require('hardhat');
 
+const selector = signature => ethers.FunctionFragment.from(signature).selector;
+
+const interfaceId = signatures =>
+  ethers.toBeHex(
+    signatures.reduce((acc, signature) => acc ^ ethers.toBigInt(selector(signature)), 0n),
+    4,
+  );
+
 module.exports = {
-  selector: signature => ethers.FunctionFragment.from(signature).selector,
+  selector,
+  interfaceId,
 };

test/utils/introspection/ERC165.test.js

@@ -1,10 +1,17 @@
+const { ethers } = require('hardhat');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
 const { shouldSupportInterfaces } = require('./SupportsInterface.behavior');
 
-const ERC165 = artifacts.require('$ERC165');
+async function fixture() {
+  return {
+    mock: await ethers.deployContract('$ERC165'),
+  };
+}
 
 contract('ERC165', function () {
   beforeEach(async function () {
-    this.mock = await ERC165.new();
+    Object.assign(this, await loadFixture(fixture));
   });
 
   shouldSupportInterfaces(['ERC165']);

test/utils/introspection/ERC165Checker.test.js

@@ -1,13 +1,6 @@
-require('@openzeppelin/test-helpers');
-
+const { ethers } = require('hardhat');
 const { expect } = require('chai');
-
-const ERC165Checker = artifacts.require('$ERC165Checker');
-const ERC165MissingData = artifacts.require('ERC165MissingData');
-const ERC165MaliciousData = artifacts.require('ERC165MaliciousData');
-const ERC165NotSupported = artifacts.require('ERC165NotSupported');
-const ERC165InterfacesSupported = artifacts.require('ERC165InterfacesSupported');
-const ERC165ReturnBombMock = artifacts.require('ERC165ReturnBombMock');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
 
 const DUMMY_ID = '0xdeadbeef';
 const DUMMY_ID_2 = '0xcafebabe';
@@ -16,285 +9,237 @@ const DUMMY_UNSUPPORTED_ID = '0xbaddcafe';
 const DUMMY_UNSUPPORTED_ID_2 = '0xbaadcafe';
 const DUMMY_ACCOUNT = '0x1111111111111111111111111111111111111111';
 
-contract('ERC165Checker', function () {
+async function fixture() {
+  return { mock: await ethers.deployContract('$ERC165Checker') };
+}
+
+describe('ERC165Checker', function () {
   beforeEach(async function () {
-    this.mock = await ERC165Checker.new();
+    Object.assign(this, await loadFixture(fixture));
   });
 
-  context('ERC165 missing return data', function () {
-    beforeEach(async function () {
-      this.target = await ERC165MissingData.new();
+  describe('ERC165 missing return data', function () {
+    before(async function () {
+      this.target = await ethers.deployContract('ERC165MissingData');
     });
 
     it('does not support ERC165', async function () {
-      const supported = await this.mock.$supportsERC165(this.target.address);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsERC165(this.target)).to.be.false;
     });
 
     it('does not support mock interface via supportsInterface', async function () {
-      const supported = await this.mock.$supportsInterface(this.target.address, DUMMY_ID);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsInterface(this.target, DUMMY_ID)).to.be.false;
     });
 
     it('does not support mock interface via supportsAllInterfaces', async function () {
-      const supported = await this.mock.$supportsAllInterfaces(this.target.address, [DUMMY_ID]);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsAllInterfaces(this.target, [DUMMY_ID])).to.be.false;
     });
 
     it('does not support mock interface via getSupportedInterfaces', async function () {
-      const supported = await this.mock.$getSupportedInterfaces(this.target.address, [DUMMY_ID]);
-      expect(supported.length).to.equal(1);
-      expect(supported[0]).to.equal(false);
+      expect(await this.mock.$getSupportedInterfaces(this.target, [DUMMY_ID])).to.deep.equal([false]);
     });
 
     it('does not support mock interface via supportsERC165InterfaceUnchecked', async function () {
-      const supported = await this.mock.$supportsERC165InterfaceUnchecked(this.target.address, DUMMY_ID);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, DUMMY_ID)).to.be.false;
     });
   });
 
-  context('ERC165 malicious return data', function () {
+  describe('ERC165 malicious return data', function () {
     beforeEach(async function () {
-      this.target = await ERC165MaliciousData.new();
+      this.target = await ethers.deployContract('ERC165MaliciousData');
     });
 
     it('does not support ERC165', async function () {
-      const supported = await this.mock.$supportsERC165(this.target.address);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsERC165(this.target)).to.be.false;
     });
 
     it('does not support mock interface via supportsInterface', async function () {
-      const supported = await this.mock.$supportsInterface(this.target.address, DUMMY_ID);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsInterface(this.target, DUMMY_ID)).to.be.false;
     });
 
     it('does not support mock interface via supportsAllInterfaces', async function () {
-      const supported = await this.mock.$supportsAllInterfaces(this.target.address, [DUMMY_ID]);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsAllInterfaces(this.target, [DUMMY_ID])).to.be.false;
     });
 
     it('does not support mock interface via getSupportedInterfaces', async function () {
-      const supported = await this.mock.$getSupportedInterfaces(this.target.address, [DUMMY_ID]);
-      expect(supported.length).to.equal(1);
-      expect(supported[0]).to.equal(false);
+      expect(await this.mock.$getSupportedInterfaces(this.target, [DUMMY_ID])).to.deep.equal([false]);
     });
 
     it('does not support mock interface via supportsERC165InterfaceUnchecked', async function () {
-      const supported = await this.mock.$supportsERC165InterfaceUnchecked(this.target.address, DUMMY_ID);
-      expect(supported).to.equal(true);
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, DUMMY_ID)).to.be.true;
     });
   });
 
-  context('ERC165 not supported', function () {
+  describe('ERC165 not supported', function () {
     beforeEach(async function () {
-      this.target = await ERC165NotSupported.new();
+      this.target = await ethers.deployContract('ERC165NotSupported');
     });
 
     it('does not support ERC165', async function () {
-      const supported = await this.mock.$supportsERC165(this.target.address);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsERC165(this.target)).to.be.false;
     });
 
     it('does not support mock interface via supportsInterface', async function () {
-      const supported = await this.mock.$supportsInterface(this.target.address, DUMMY_ID);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsInterface(this.target, DUMMY_ID)).to.be.false;
     });
 
     it('does not support mock interface via supportsAllInterfaces', async function () {
-      const supported = await this.mock.$supportsAllInterfaces(this.target.address, [DUMMY_ID]);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsAllInterfaces(this.target, [DUMMY_ID])).to.be.false;
     });
 
     it('does not support mock interface via getSupportedInterfaces', async function () {
-      const supported = await this.mock.$getSupportedInterfaces(this.target.address, [DUMMY_ID]);
-      expect(supported.length).to.equal(1);
-      expect(supported[0]).to.equal(false);
+      expect(await this.mock.$getSupportedInterfaces(this.target, [DUMMY_ID])).to.deep.equal([false]);
     });
 
     it('does not support mock interface via supportsERC165InterfaceUnchecked', async function () {
-      const supported = await this.mock.$supportsERC165InterfaceUnchecked(this.target.address, DUMMY_ID);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, DUMMY_ID)).to.be.false;
     });
   });
 
-  context('ERC165 supported', function () {
+  describe('ERC165 supported', function () {
     beforeEach(async function () {
-      this.target = await ERC165InterfacesSupported.new([]);
+      this.target = await ethers.deployContract('ERC165InterfacesSupported', [[]]);
     });
 
     it('supports ERC165', async function () {
-      const supported = await this.mock.$supportsERC165(this.target.address);
-      expect(supported).to.equal(true);
+      expect(await this.mock.$supportsERC165(this.target)).to.be.true;
     });
 
     it('does not support mock interface via supportsInterface', async function () {
-      const supported = await this.mock.$supportsInterface(this.target.address, DUMMY_ID);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsInterface(this.target, DUMMY_ID)).to.be.false;
     });
 
     it('does not support mock interface via supportsAllInterfaces', async function () {
-      const supported = await this.mock.$supportsAllInterfaces(this.target.address, [DUMMY_ID]);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsAllInterfaces(this.target, [DUMMY_ID])).to.be.false;
     });
 
     it('does not support mock interface via getSupportedInterfaces', async function () {
-      const supported = await this.mock.$getSupportedInterfaces(this.target.address, [DUMMY_ID]);
-      expect(supported.length).to.equal(1);
-      expect(supported[0]).to.equal(false);
+      expect(await this.mock.$getSupportedInterfaces(this.target, [DUMMY_ID])).to.deep.equal([false]);
     });
 
     it('does not support mock interface via supportsERC165InterfaceUnchecked', async function () {
-      const supported = await this.mock.$supportsERC165InterfaceUnchecked(this.target.address, DUMMY_ID);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, DUMMY_ID)).to.be.false;
     });
   });
 
-  context('ERC165 and single interface supported', function () {
+  describe('ERC165 and single interface supported', function () {
     beforeEach(async function () {
-      this.target = await ERC165InterfacesSupported.new([DUMMY_ID]);
+      this.target = await ethers.deployContract('ERC165InterfacesSupported', [[DUMMY_ID]]);
     });
 
     it('supports ERC165', async function () {
-      const supported = await this.mock.$supportsERC165(this.target.address);
-      expect(supported).to.equal(true);
+      expect(await this.mock.$supportsERC165(this.target)).to.be.true;
     });
 
     it('supports mock interface via supportsInterface', async function () {
-      const supported = await this.mock.$supportsInterface(this.target.address, DUMMY_ID);
-      expect(supported).to.equal(true);
+      expect(await this.mock.$supportsInterface(this.target, DUMMY_ID)).to.be.true;
     });
 
     it('supports mock interface via supportsAllInterfaces', async function () {
-      const supported = await this.mock.$supportsAllInterfaces(this.target.address, [DUMMY_ID]);
-      expect(supported).to.equal(true);
+      expect(await this.mock.$supportsAllInterfaces(this.target, [DUMMY_ID])).to.be.true;
     });
 
     it('supports mock interface via getSupportedInterfaces', async function () {
-      const supported = await this.mock.$getSupportedInterfaces(this.target.address, [DUMMY_ID]);
-      expect(supported.length).to.equal(1);
-      expect(supported[0]).to.equal(true);
+      expect(await this.mock.$getSupportedInterfaces(this.target, [DUMMY_ID])).to.deep.equal([true]);
     });
 
     it('supports mock interface via supportsERC165InterfaceUnchecked', async function () {
-      const supported = await this.mock.$supportsERC165InterfaceUnchecked(this.target.address, DUMMY_ID);
-      expect(supported).to.equal(true);
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, DUMMY_ID)).to.be.true;
     });
   });
 
-  context('ERC165 and many interfaces supported', function () {
+  describe('ERC165 and many interfaces supported', function () {
+    const supportedInterfaces = [DUMMY_ID, DUMMY_ID_2, DUMMY_ID_3];
     beforeEach(async function () {
-      this.supportedInterfaces = [DUMMY_ID, DUMMY_ID_2, DUMMY_ID_3];
-      this.target = await ERC165InterfacesSupported.new(this.supportedInterfaces);
+      this.target = await ethers.deployContract('ERC165InterfacesSupported', [supportedInterfaces]);
     });
 
     it('supports ERC165', async function () {
-      const supported = await this.mock.$supportsERC165(this.target.address);
-      expect(supported).to.equal(true);
+      expect(await this.mock.$supportsERC165(this.target)).to.be.true;
     });
 
     it('supports each interfaceId via supportsInterface', async function () {
-      for (const interfaceId of this.supportedInterfaces) {
-        const supported = await this.mock.$supportsInterface(this.target.address, interfaceId);
-        expect(supported).to.equal(true);
+      for (const interfaceId of supportedInterfaces) {
+        expect(await this.mock.$supportsInterface(this.target, interfaceId)).to.be.true;
       }
     });
 
     it('supports all interfaceIds via supportsAllInterfaces', async function () {
-      const supported = await this.mock.$supportsAllInterfaces(this.target.address, this.supportedInterfaces);
-      expect(supported).to.equal(true);
+      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];
 
-      const supported = await this.mock.$supportsAllInterfaces(this.target.address, interfaceIdsToTest);
-      expect(supported).to.equal(false);
+      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 = [...this.supportedInterfaces, DUMMY_UNSUPPORTED_ID];
-
-      const supported = await this.mock.$supportsAllInterfaces(this.target.address, interfaceIdsToTest);
-      expect(supported).to.equal(false);
+      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 () {
-      const supported = await this.mock.$getSupportedInterfaces(this.target.address, this.supportedInterfaces);
-      expect(supported.length).to.equal(3);
-      expect(supported[0]).to.equal(true);
-      expect(supported[1]).to.equal(true);
-      expect(supported[2]).to.equal(true);
+      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];
 
-      const supported = await this.mock.$getSupportedInterfaces(this.target.address, interfaceIdsToTest);
-      expect(supported.length).to.equal(2);
-      expect(supported[0]).to.equal(false);
-      expect(supported[1]).to.equal(false);
+      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 = [...this.supportedInterfaces, DUMMY_UNSUPPORTED_ID];
+      const interfaceIdsToTest = [...supportedInterfaces, DUMMY_UNSUPPORTED_ID];
 
-      const supported = await this.mock.$getSupportedInterfaces(this.target.address, interfaceIdsToTest);
-      expect(supported.length).to.equal(4);
-      expect(supported[0]).to.equal(true);
-      expect(supported[1]).to.equal(true);
-      expect(supported[2]).to.equal(true);
-      expect(supported[3]).to.equal(false);
+      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 this.supportedInterfaces) {
-        const supported = await this.mock.$supportsERC165InterfaceUnchecked(this.target.address, interfaceId);
-        expect(supported).to.equal(true);
+      for (const interfaceId of supportedInterfaces) {
+        expect(await this.mock.$supportsERC165InterfaceUnchecked(this.target, interfaceId)).to.be.true;
       }
     });
   });
 
-  context('account address does not support ERC165', function () {
+  describe('account address does not support ERC165', function () {
     it('does not support ERC165', async function () {
-      const supported = await this.mock.$supportsERC165(DUMMY_ACCOUNT);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsERC165(DUMMY_ACCOUNT)).to.be.false;
     });
 
     it('does not support mock interface via supportsInterface', async function () {
-      const supported = await this.mock.$supportsInterface(DUMMY_ACCOUNT, DUMMY_ID);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsInterface(DUMMY_ACCOUNT, DUMMY_ID)).to.be.false;
     });
 
     it('does not support mock interface via supportsAllInterfaces', async function () {
-      const supported = await this.mock.$supportsAllInterfaces(DUMMY_ACCOUNT, [DUMMY_ID]);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsAllInterfaces(DUMMY_ACCOUNT, [DUMMY_ID])).to.be.false;
     });
 
     it('does not support mock interface via getSupportedInterfaces', async function () {
-      const supported = await this.mock.$getSupportedInterfaces(DUMMY_ACCOUNT, [DUMMY_ID]);
-      expect(supported.length).to.equal(1);
-      expect(supported[0]).to.equal(false);
+      expect(await this.mock.$getSupportedInterfaces(DUMMY_ACCOUNT, [DUMMY_ID])).to.deep.equal([false]);
     });
 
     it('does not support mock interface via supportsERC165InterfaceUnchecked', async function () {
-      const supported = await this.mock.$supportsERC165InterfaceUnchecked(DUMMY_ACCOUNT, DUMMY_ID);
-      expect(supported).to.equal(false);
+      expect(await this.mock.$supportsERC165InterfaceUnchecked(DUMMY_ACCOUNT, DUMMY_ID)).to.be.false;
     });
   });
 
   it('Return bomb resistance', async function () {
-    this.target = await ERC165ReturnBombMock.new();
-
-    const tx1 = await this.mock.$supportsInterface.sendTransaction(this.target.address, DUMMY_ID);
-    expect(tx1.receipt.gasUsed).to.be.lessThan(120000); // 3*30k + 21k + some margin
-
-    const tx2 = await this.mock.$getSupportedInterfaces.sendTransaction(this.target.address, [
-      DUMMY_ID,
-      DUMMY_ID_2,
-      DUMMY_ID_3,
-      DUMMY_UNSUPPORTED_ID,
-      DUMMY_UNSUPPORTED_ID_2,
-    ]);
-    expect(tx2.receipt.gasUsed).to.be.lessThan(250000); // (2+5)*30k + 21k + some margin
+    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
   });
 });

test/utils/introspection/SupportsInterface.behavior.js

@@ -1,6 +1,6 @@
-const { ethers } = require('ethers');
 const { expect } = require('chai');
-const { selector } = require('../../helpers/methods');
+const { selector, interfaceId } = require('../../helpers/methods');
+const { mapValues } = require('../../helpers/iterate');
 
 const INVALID_ID = '0xffffffff';
 const SIGNATURES = {
@@ -81,15 +81,7 @@ const SIGNATURES = {
   ERC2981: ['royaltyInfo(uint256,uint256)'],
 };
 
-const INTERFACE_IDS = Object.fromEntries(
-  Object.entries(SIGNATURES).map(([name, signatures]) => [
-    name,
-    ethers.toBeHex(
-      signatures.reduce((id, fnSig) => id ^ BigInt(selector(fnSig)), 0n),
-      4,
-    ),
-  ]),
-);
+const INTERFACE_IDS = mapValues(SIGNATURES, interfaceId);
 
 function shouldSupportInterfaces(interfaces = []) {
   describe('ERC165', function () {
@@ -101,25 +93,25 @@ function shouldSupportInterfaces(interfaces = []) {
       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.be.lte(30000);
+          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)).to.equal(true, `does not support ${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.be.lte(30000);
+        expect(await this.contractUnderTest.supportsInterface.estimateGas(INVALID_ID)).to.lte(30_000n);
       });
 
       it('returns false', async function () {
-        expect(await this.contractUnderTest.supportsInterface(INVALID_ID)).to.be.equal(false, `supports ${INVALID_ID}`);
+        expect(await this.contractUnderTest.supportsInterface(INVALID_ID), `supports ${INVALID_ID}`).to.be.false;
       });
     });
 
@@ -127,6 +119,8 @@ function shouldSupportInterfaces(interfaces = []) {
       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]) {
           // TODO: Remove Truffle case when ethersjs migration is done
           if (this.contractUnderTest.abi) {
@@ -137,7 +131,7 @@ function shouldSupportInterfaces(interfaces = []) {
             );
           }
 
-          expect(!!this.contractUnderTest.interface.getFunction(fnSig), `did not find ${fnSig}`).to.be.true;
+          expect(this.contractUnderTest.interface.hasFunction(fnSig), `did not find ${fnSig}`).to.be.true;
         }
       }
     });