mirror
/
openzeppelin-contracts
mirror of https://github.com/OpenZeppelin/openzeppelin-contracts
2
1
Fork 1
Code Issues Releases Wiki Activity

Migrate ERC165 tests (#4794)

Browse Source
pull/4805/head
Hadrien Croubois 1 year ago committed by GitHub
parent c3cd70811b
commit 5bca2119ca
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 111 additions and 156 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 11
      test/helpers/methods.js
  2. 11
      test/utils/introspection/ERC165.test.js
  3. 219
      test/utils/introspection/ERC165Checker.test.js
  4. 26
      test/utils/introspection/SupportsInterface.behavior.js

11
test/helpers/methods.js
Unescape View File

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

11
test/utils/introspection/ERC165.test.js
Unescape 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']);

219
test/utils/introspection/ERC165Checker.test.js
Unescape 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();
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
});
});

26
test/utils/introspection/SupportsInterface.behavior.js
Unescape 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;
}
}
});

Write Preview
Loading…
Cancel
Save