@diwantanushh/rapiddex-contracts 1.0.0

package/lib/openzeppelin-contracts-master/test/utils/draft-InteroperableAddress.t.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {Test} from "forge-std/Test.sol";
+import {InteroperableAddress} from "../../contracts/utils/draft-InteroperableAddress.sol";
+
+contract InteroperableAddressTest is Test {
+    using InteroperableAddress for bytes;
+
+    function testFormatParse(bytes2 chainType, bytes calldata chainReference, bytes calldata addr) public view {
+        vm.assume(chainReference.length > 0 || addr.length > 0);
+        {
+            (bytes2 chainType_, bytes memory chainReference_, bytes memory addr_) = InteroperableAddress
+                .formatV1(chainType, chainReference, addr)
+                .parseV1();
+            assertEq(chainType, chainType_);
+            assertEq(chainReference, chainReference_);
+            assertEq(addr, addr_);
+        }
+        {
+            (bool success, bytes2 chainType_, bytes memory chainReference_, bytes memory addr_) = InteroperableAddress
+                .formatV1(chainType, chainReference, addr)
+                .tryParseV1();
+            assertTrue(success);
+            assertEq(chainType, chainType_);
+            assertEq(chainReference, chainReference_);
+            assertEq(addr, addr_);
+        }
+        {
+            (bytes2 chainType_, bytes memory chainReference_, bytes memory addr_) = this.parseV1Calldata(
+                InteroperableAddress.formatV1(chainType, chainReference, addr)
+            );
+            assertEq(chainType, chainType_);
+            assertEq(chainReference, chainReference_);
+            assertEq(addr, addr_);
+        }
+        {
+            (bool success, bytes2 chainType_, bytes memory chainReference_, bytes memory addr_) = this
+                .tryParseV1Calldata(InteroperableAddress.formatV1(chainType, chainReference, addr));
+            assertTrue(success);
+            assertEq(chainType, chainType_);
+            assertEq(chainReference, chainReference_);
+            assertEq(addr, addr_);
+        }
+    }
+
+    function testFormatParseEVM(uint256 chainid, address addr) public view {
+        {
+            (uint256 chainid_, address addr_) = InteroperableAddress.formatEvmV1(chainid, addr).parseEvmV1();
+            assertEq(chainid, chainid_);
+            assertEq(addr, addr_);
+        }
+        {
+            (bool success, uint256 chainid_, address addr_) = InteroperableAddress
+                .formatEvmV1(chainid, addr)
+                .tryParseEvmV1();
+            assertTrue(success);
+            assertEq(chainid, chainid_);
+            assertEq(addr, addr_);
+        }
+        {
+            (uint256 chainid_, address addr_) = this.parseEvmV1Calldata(
+                InteroperableAddress.formatEvmV1(chainid, addr)
+            );
+            assertEq(chainid, chainid_);
+            assertEq(addr, addr_);
+        }
+        {
+            (bool success, uint256 chainid_, address addr_) = this.tryParseEvmV1Calldata(
+                InteroperableAddress.formatEvmV1(chainid, addr)
+            );
+            assertTrue(success);
+            assertEq(chainid, chainid_);
+            assertEq(addr, addr_);
+        }
+    }
+
+    function parseV1Calldata(
+        bytes calldata self
+    ) external pure returns (bytes2 chainType, bytes calldata chainReference, bytes calldata addr) {
+        return self.parseV1Calldata();
+    }
+
+    function tryParseV1Calldata(
+        bytes calldata self
+    ) external pure returns (bool success, bytes2 chainType, bytes calldata chainReference, bytes calldata addr) {
+        return self.tryParseV1Calldata();
+    }
+
+    function parseEvmV1Calldata(bytes calldata self) external pure returns (uint256 chainid, address addr) {
+        return self.parseEvmV1Calldata();
+    }
+
+    function tryParseEvmV1Calldata(
+        bytes calldata self
+    ) external pure returns (bool success, uint256 chainid, address addr) {
+        return self.tryParseEvmV1Calldata();
+    }
+}

package/lib/openzeppelin-contracts-master/test/utils/draft-InteroperableAddress.test.js

@@ -0,0 +1,217 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { addressCoder, nameCoder } = require('interoperable-addresses');
+const { CAIP350, chainTypeCoder } = require('interoperable-addresses/dist/CAIP350');
+
+const { getLocalChain } = require('../helpers/chains');
+const { generators } = require('../helpers/random');
+
+async function fixture() {
+  const mock = await ethers.deployContract('$InteroperableAddress');
+  return { mock };
+}
+
+describe('ERC7390', function () {
+  before(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  it('formatEvmV1 address on the local chain', async function () {
+    const { reference: chainid, toErc7930 } = await getLocalChain();
+    await expect(
+      this.mock.$formatEvmV1(ethers.Typed.uint256(chainid), ethers.Typed.address(this.mock)),
+    ).to.eventually.equal(toErc7930(this.mock));
+  });
+
+  it('formatV1 fails if both reference and address are empty', async function () {
+    await expect(this.mock.$formatV1('0x0000', '0x', '0x')).to.be.revertedWithCustomError(
+      this.mock,
+      'InteroperableAddressEmptyReferenceAndAddress',
+    );
+  });
+
+  describe('reference examples', function () {
+    for (const { title, name } of [
+      {
+        title: 'Example 1: Ethereum mainnet address',
+        name: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045@eip155:1#4CA88C9C',
+      },
+      {
+        title: 'Example 2: Solana mainnet address',
+        name: 'MJKqp326RZCHnAAbew9MDdui3iCKWco7fsK9sVuZTX2@solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d#88835C11',
+      },
+      {
+        title: 'Example 3: EVM address without chainid',
+        name: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045@eip155#B26DB7CB',
+      },
+      {
+        title: 'Example 4: Solana mainnet network, no address',
+        name: '@solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d#2EB18670',
+      },
+      {
+        title: 'Example 5: Arbitrum One address',
+        name: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045@eip155:42161#D2E02854',
+      },
+      {
+        title: 'Example 6: Ethereum mainnet, no address',
+        name: '@eip155:1#F54D4FBF',
+      },
+    ]) {
+      const { chainType, reference, address } = nameCoder.decode(name, true);
+      const binary = addressCoder.encode({ chainType, reference, address });
+
+      it(title, async function () {
+        const expected = [
+          chainTypeCoder.decode(chainType),
+          CAIP350[chainType].reference.decode(reference),
+          CAIP350[chainType].address.decode(address),
+        ].map(ethers.hexlify);
+
+        await expect(this.mock.$parseV1(binary)).to.eventually.deep.equal(expected);
+        await expect(this.mock.$parseV1Calldata(binary)).to.eventually.deep.equal(expected);
+        await expect(this.mock.$tryParseV1(binary)).to.eventually.deep.equal([true, ...expected]);
+        await expect(this.mock.$tryParseV1Calldata(binary)).to.eventually.deep.equal([true, ...expected]);
+        await expect(this.mock.$formatV1(...expected)).to.eventually.equal(binary);
+
+        if (chainType == 'eip155') {
+          await expect(this.mock.$parseEvmV1(binary)).to.eventually.deep.equal([
+            reference ?? 0n,
+            address ?? ethers.ZeroAddress,
+          ]);
+          await expect(this.mock.$parseEvmV1Calldata(binary)).to.eventually.deep.equal([
+            reference ?? 0n,
+            address ?? ethers.ZeroAddress,
+          ]);
+          await expect(this.mock.$tryParseEvmV1(binary)).to.eventually.deep.equal([
+            true,
+            reference ?? 0n,
+            address ?? ethers.ZeroAddress,
+          ]);
+          await expect(this.mock.$tryParseEvmV1Calldata(binary)).to.eventually.deep.equal([
+            true,
+            reference ?? 0n,
+            address ?? ethers.ZeroAddress,
+          ]);
+
+          if (!address) {
+            await expect(this.mock.$formatEvmV1(ethers.Typed.uint256(reference))).to.eventually.equal(
+              binary.toLowerCase(),
+            );
+          } else if (!reference) {
+            await expect(this.mock.$formatEvmV1(ethers.Typed.address(address))).to.eventually.equal(
+              binary.toLowerCase(),
+            );
+          } else {
+            await expect(
+              this.mock.$formatEvmV1(ethers.Typed.uint256(reference), ethers.Typed.address(address)),
+            ).to.eventually.equal(binary.toLowerCase());
+          }
+        }
+      });
+    }
+  });
+
+  describe('invalid format', function () {
+    for (const [title, binary] of Object.entries({
+      // version 2 + some data
+      'unsupported version': '0x00020000010100',
+      // version + ref: missing chainReferenceLength and addressLength
+      'too short (case 1)': '0x00010042',
+      // version + ref + chainReference: missing addressLength
+      'too short (case 2)': '0x000100420101',
+      // version + ref + chainReference + addressLength + part of the address: missing 2 bytes of the address
+      'too short (case 3)': '0x00010042010114d8da6bf26964af9d7eed9e03e53415d37aa9',
+      // empty chain reference and address
+      'empty chain reference and address': '0x000100420000',
+    })) {
+      it(title, async function () {
+        await expect(this.mock.$parseV1(binary))
+          .to.be.revertedWithCustomError(this.mock, 'InteroperableAddressParsingError')
+          .withArgs(binary);
+        await expect(this.mock.$parseV1Calldata(binary))
+          .to.be.revertedWithCustomError(this.mock, 'InteroperableAddressParsingError')
+          .withArgs(binary);
+        await expect(this.mock.$parseEvmV1(binary))
+          .to.be.revertedWithCustomError(this.mock, 'InteroperableAddressParsingError')
+          .withArgs(binary);
+        await expect(this.mock.$parseEvmV1Calldata(binary))
+          .to.be.revertedWithCustomError(this.mock, 'InteroperableAddressParsingError')
+          .withArgs(binary);
+        await expect(this.mock.$tryParseV1(binary)).to.eventually.deep.equal([false, '0x0000', '0x', '0x']);
+        await expect(this.mock.$tryParseV1Calldata(binary)).to.eventually.deep.equal([false, '0x0000', '0x', '0x']);
+        await expect(this.mock.$tryParseEvmV1(binary)).to.eventually.deep.equal([false, 0n, ethers.ZeroAddress]);
+        await expect(this.mock.$tryParseEvmV1Calldata(binary)).to.eventually.deep.equal([
+          false,
+          0n,
+          ethers.ZeroAddress,
+        ]);
+      });
+    }
+
+    for (const [title, binary] of Object.entries({
+      'not an evm format: chainid too long':
+        '0x00010000212dc7f03c13ad47809e88339107c33a612043d704c1c9693a74996e7f9c6bee8f2314d8da6bf26964af9d7eed9e03e53415d37aa96045',
+      'not an evm format: address in not 20 bytes': '0x00010000010112d8da6bf26964af9d7eed9e03e53415d37aa9',
+    })) {
+      it(title, async function () {
+        await expect(this.mock.$parseEvmV1(binary))
+          .to.be.revertedWithCustomError(this.mock, 'InteroperableAddressParsingError')
+          .withArgs(binary);
+        await expect(this.mock.$parseEvmV1Calldata(binary))
+          .to.be.revertedWithCustomError(this.mock, 'InteroperableAddressParsingError')
+          .withArgs(binary);
+        await expect(this.mock.$tryParseEvmV1(binary)).to.eventually.deep.equal([false, 0n, ethers.ZeroAddress]);
+        await expect(this.mock.$tryParseEvmV1Calldata(binary)).to.eventually.deep.equal([
+          false,
+          0n,
+          ethers.ZeroAddress,
+        ]);
+      });
+    }
+  });
+
+  describe('handles large references and addresses', function () {
+    it('large', async function () {
+      const chainType = '0x0000';
+      const reference = generators.bytes(142);
+      const address = generators.bytes(142);
+
+      const binary = addressCoder.encode({ chainType, reference, address });
+
+      // Generic parse
+      await expect(this.mock.$tryParseV1(binary)).to.eventually.deep.equal([true, chainType, reference, address]);
+      await expect(this.mock.$tryParseV1Calldata(binary)).to.eventually.deep.equal([
+        true,
+        chainType,
+        reference,
+        address,
+      ]);
+
+      // EVM parse - too long to be a valid evm format
+      await expect(this.mock.$tryParseEvmV1(binary)).to.eventually.deep.equal([false, 0n, ethers.ZeroAddress]);
+      await expect(this.mock.$tryParseEvmV1Calldata(binary)).to.eventually.deep.equal([false, 0n, ethers.ZeroAddress]);
+    });
+
+    it('very large', async function () {
+      const chainType = '0x0000';
+      const reference = generators.bytes(255);
+      const address = generators.bytes(255);
+
+      const binary = addressCoder.encode({ chainType, reference, address });
+
+      // Generic parse
+      await expect(this.mock.$tryParseV1(binary)).to.eventually.deep.equal([true, chainType, reference, address]);
+      await expect(this.mock.$tryParseV1Calldata(binary)).to.eventually.deep.equal([
+        true,
+        chainType,
+        reference,
+        address,
+      ]);
+
+      // EVM parse - too long to be a valid evm format
+      await expect(this.mock.$tryParseEvmV1(binary)).to.eventually.deep.equal([false, 0n, ethers.ZeroAddress]);
+      await expect(this.mock.$tryParseEvmV1Calldata(binary)).to.eventually.deep.equal([false, 0n, ethers.ZeroAddress]);
+    });
+  });
+});

package/lib/openzeppelin-contracts-master/test/utils/introspection/ERC165.test.js

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

package/lib/openzeppelin-contracts-master/test/utils/introspection/ERC165Checker.test.js

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