NoBey/openzeppelin-contracts
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate ERC165 tests (#4794)

Browse Source
This commit is contained in:
Hadrien Croubois
2023-12-19 02:28:16 +01:00
committed by GitHub
parent c3cd70811b
commit 5bca2119ca
4 changed files with 109 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
test/helpers/methods.js
View File

@ -1,5 +1,14 @@
const { ethers } = require('hardhat'); 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 = { module.exports = {
selector: signature => ethers.FunctionFragment.from(signature).selector, selector,
interfaceId,
}; };

11
test/utils/introspection/ERC165.test.js
View File

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

215
test/utils/introspection/ERC165Checker.test.js
View File

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

26
test/utils/introspection/SupportsInterface.behavior.js
View File

@ -1,6 +1,6 @@
const { ethers } = require('ethers');
const { expect } = require('chai'); 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 INVALID_ID = '0xffffffff';
const SIGNATURES = { const SIGNATURES = {
@ -81,15 +81,7 @@ const SIGNATURES = {
ERC2981: ['royaltyInfo(uint256,uint256)'], ERC2981: ['royaltyInfo(uint256,uint256)'],
}; };
const INTERFACE_IDS = Object.fromEntries( const INTERFACE_IDS = mapValues(SIGNATURES, interfaceId);
Object.entries(SIGNATURES).map(([name, signatures]) => [
name,
ethers.toBeHex(
signatures.reduce((id, fnSig) => id ^ BigInt(selector(fnSig)), 0n),
4,
),
]),
);
function shouldSupportInterfaces(interfaces = []) { function shouldSupportInterfaces(interfaces = []) {
describe('ERC165', function () { describe('ERC165', function () {
@ -101,25 +93,25 @@ function shouldSupportInterfaces(interfaces = []) {
it('uses less than 30k gas', async function () { it('uses less than 30k gas', async function () {
for (const k of interfaces) { for (const k of interfaces) {
const interface = INTERFACE_IDS[k] ?? k; 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 () { it('returns true', async function () {
for (const k of interfaces) { for (const k of interfaces) {
const interfaceId = INTERFACE_IDS[k] ?? k; 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 () { describe('when the interfaceId is not supported', function () {
it('uses less than 30k', async 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 () { 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) { for (const k of interfaces) {
// skip interfaces for which we don't have a function list // skip interfaces for which we don't have a function list
if (SIGNATURES[k] === undefined) continue; if (SIGNATURES[k] === undefined) continue;
// Check the presence of each function in the contract's interface
for (const fnSig of SIGNATURES[k]) { for (const fnSig of SIGNATURES[k]) {
// TODO: Remove Truffle case when ethersjs migration is done // TODO: Remove Truffle case when ethersjs migration is done
if (this.contractUnderTest.abi) { 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;
} }
} }
}); });