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/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 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']);

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 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();
this.target = await ethers.deployContract('ERC165ReturnBombMock');
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 { 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 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
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
});
});

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

@ -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;
}
}
});