web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/test/utils/Packing.test.js

@@ -0,0 +1,70 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { forceDeployCode } = require('../helpers/deploy');
+const { product } = require('../helpers/iterate');
+const { SIZES } = require('../../scripts/generate/templates/Packing.opts');
+
+async function fixture() {
+  return { mock: await forceDeployCode('$Packing') };
+}
+
+describe('Packing', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('pack', function () {
+    for (const [size1, size2] of product(SIZES, SIZES).filter(([size1, size2]) => SIZES.includes(size1 + size2))) {
+      const value1 = ethers.hexlify(ethers.randomBytes(size1));
+      const value2 = ethers.hexlify(ethers.randomBytes(size2));
+      const packed = ethers.concat([value1, value2]);
+
+      it(`pack bytes${size1} + bytes${size2} => bytes${size1 + size2}`, async function () {
+        expect(await this.mock[`$pack_${size1}_${size2}`](value1, value2)).to.equal(packed);
+        expect(await this.mock[`$extract_${size1 + size2}_${size1}`](packed, 0)).to.equal(value1);
+        expect(await this.mock[`$extract_${size1 + size2}_${size2}`](packed, size1)).to.equal(value2);
+      });
+    }
+  });
+
+  describe('extract / replace', function () {
+    for (const [size1, size2] of product(SIZES, SIZES).filter(([size1, size2]) => size1 > size2)) {
+      const MAX_OFFSET = size1 - size2;
+      const offset = ethers.toNumber(ethers.randomBytes(1)) % (MAX_OFFSET + 1);
+      const outer = ethers.randomBytes(size1);
+      const value = ethers.randomBytes(size2);
+
+      it(`extract bytes${size2} from bytes${size1}`, async function () {
+        expect(await this.mock[`$extract_${size1}_${size2}`](outer, offset)).to.equal(
+          ethers.hexlify(outer.slice(offset, offset + size2)),
+        );
+
+        await expect(this.mock[`$extract_${size1}_${size2}`](outer, MAX_OFFSET)).to.not.be.revertedWithCustomError(
+          this.mock,
+          'OutOfRangeAccess',
+        );
+
+        await expect(this.mock[`$extract_${size1}_${size2}`](outer, MAX_OFFSET + 1)).to.be.revertedWithCustomError(
+          this.mock,
+          'OutOfRangeAccess',
+        );
+      });
+
+      it(`replace bytes${size2} from bytes${size1}`, async function () {
+        expect(await this.mock[`$replace_${size1}_${size2}`](outer, value, offset)).to.equal(
+          ethers.concat([outer.slice(0, offset), value, outer.slice(offset + size2)]),
+        );
+
+        await expect(
+          this.mock[`$replace_${size1}_${size2}`](outer, value, MAX_OFFSET),
+        ).to.not.be.revertedWithCustomError(this.mock, 'OutOfRangeAccess');
+
+        await expect(
+          this.mock[`$replace_${size1}_${size2}`](outer, value, MAX_OFFSET + 1),
+        ).to.be.revertedWithCustomError(this.mock, 'OutOfRangeAccess');
+      });
+    }
+  });
+});

package/lib/openzeppelin-contracts/test/utils/Panic.test.js

@@ -0,0 +1,37 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic');
+
+async function fixture() {
+  return { mock: await ethers.deployContract('$Panic') };
+}
+
+describe('Panic', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  for (const [name, code] of Object.entries({
+    GENERIC: 0x0,
+    ASSERT: PANIC_CODES.ASSERTION_ERROR,
+    UNDER_OVERFLOW: PANIC_CODES.ARITHMETIC_OVERFLOW,
+    DIVISION_BY_ZERO: PANIC_CODES.DIVISION_BY_ZERO,
+    ENUM_CONVERSION_ERROR: PANIC_CODES.ENUM_CONVERSION_OUT_OF_BOUNDS,
+    STORAGE_ENCODING_ERROR: PANIC_CODES.INCORRECTLY_ENCODED_STORAGE_BYTE_ARRAY,
+    EMPTY_ARRAY_POP: PANIC_CODES.POP_ON_EMPTY_ARRAY,
+    ARRAY_OUT_OF_BOUNDS: PANIC_CODES.ARRAY_ACCESS_OUT_OF_BOUNDS,
+    RESOURCE_ERROR: PANIC_CODES.TOO_MUCH_MEMORY_ALLOCATED,
+    INVALID_INTERNAL_FUNCTION: PANIC_CODES.ZERO_INITIALIZED_VARIABLE,
+  })) {
+    describe(`${name} (${ethers.toBeHex(code)})`, function () {
+      it('exposes panic code as constant', async function () {
+        expect(await this.mock.getFunction(`$${name}`)()).to.equal(code);
+      });
+
+      it('reverts with panic when called', async function () {
+        await expect(this.mock.$panic(code)).to.be.revertedWithPanic(code);
+      });
+    });
+  }
+});

package/lib/openzeppelin-contracts/test/utils/Pausable.test.js

@@ -0,0 +1,90 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+async function fixture() {
+  const [pauser] = await ethers.getSigners();
+
+  const mock = await ethers.deployContract('PausableMock');
+
+  return { pauser, mock };
+}
+
+describe('Pausable', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('when unpaused', function () {
+    beforeEach(async function () {
+      expect(await this.mock.paused()).to.be.false;
+    });
+
+    it('can perform normal process in non-pause', async function () {
+      expect(await this.mock.count()).to.equal(0n);
+
+      await this.mock.normalProcess();
+      expect(await this.mock.count()).to.equal(1n);
+    });
+
+    it('cannot take drastic measure in non-pause', async function () {
+      await expect(this.mock.drasticMeasure()).to.be.revertedWithCustomError(this.mock, 'ExpectedPause');
+
+      expect(await this.mock.drasticMeasureTaken()).to.be.false;
+    });
+
+    describe('when paused', function () {
+      beforeEach(async function () {
+        this.tx = await this.mock.pause();
+      });
+
+      it('emits a Paused event', async function () {
+        await expect(this.tx).to.emit(this.mock, 'Paused').withArgs(this.pauser);
+      });
+
+      it('cannot perform normal process in pause', async function () {
+        await expect(this.mock.normalProcess()).to.be.revertedWithCustomError(this.mock, 'EnforcedPause');
+      });
+
+      it('can take a drastic measure in a pause', async function () {
+        await this.mock.drasticMeasure();
+        expect(await this.mock.drasticMeasureTaken()).to.be.true;
+      });
+
+      it('reverts when re-pausing', async function () {
+        await expect(this.mock.pause()).to.be.revertedWithCustomError(this.mock, 'EnforcedPause');
+      });
+
+      describe('unpausing', function () {
+        it('is unpausable by the pauser', async function () {
+          await this.mock.unpause();
+          expect(await this.mock.paused()).to.be.false;
+        });
+
+        describe('when unpaused', function () {
+          beforeEach(async function () {
+            this.tx = await this.mock.unpause();
+          });
+
+          it('emits an Unpaused event', async function () {
+            await expect(this.tx).to.emit(this.mock, 'Unpaused').withArgs(this.pauser);
+          });
+
+          it('should resume allowing normal process', async function () {
+            expect(await this.mock.count()).to.equal(0n);
+            await this.mock.normalProcess();
+            expect(await this.mock.count()).to.equal(1n);
+          });
+
+          it('should prevent drastic measure', async function () {
+            await expect(this.mock.drasticMeasure()).to.be.revertedWithCustomError(this.mock, 'ExpectedPause');
+          });
+
+          it('reverts when re-unpausing', async function () {
+            await expect(this.mock.unpause()).to.be.revertedWithCustomError(this.mock, 'ExpectedPause');
+          });
+        });
+      });
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/utils/RLP.t.sol

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {RLP} from "@openzeppelin/contracts/utils/RLP.sol";
+import {Memory} from "@openzeppelin/contracts/utils/Memory.sol";
+
+contract RLPTest is Test {
+    using RLP for *;
+
+    // Encode -> Decode
+
+    function testEncodeDecodeBool(bool input) external pure {
+        assertEq(input.encode().decodeBool(), input);
+    }
+
+    function testEncodeDecodeAddress(address input) external pure {
+        assertEq(input.encode().decodeAddress(), input);
+    }
+
+    function testEncodeDecodeUint256(uint256 input) external pure {
+        assertEq(input.encode().decodeUint256(), input);
+    }
+
+    function testEncodeDecodeBytes32(bytes32 input) external pure {
+        assertEq(input.encode().decodeBytes32(), input);
+    }
+
+    function testEncodeDecodeBytes(bytes memory input) external pure {
+        assertEq(input.encode().decodeBytes(), input);
+    }
+
+    function testEncodeDecodeString(string memory input) external pure {
+        assertEq(input.encode().decodeString(), input);
+    }
+
+    /// forge-config: default.fuzz.runs = 512
+    function testEncodeDecodeList(bytes[] memory input) external pure {
+        // max length for list decoding by default
+        vm.assume(input.length <= 32);
+
+        bytes[] memory encoded = new bytes[](input.length);
+        for (uint256 i = 0; i < input.length; ++i) {
+            encoded[i] = input[i].encode();
+        }
+
+        // encode list + decode as list of RLP items
+        Memory.Slice[] memory list = encoded.encode().decodeList();
+
+        assertEq(list.length, input.length);
+        for (uint256 i = 0; i < input.length; ++i) {
+            assertEq(list[i].readBytes(), input[i]);
+        }
+    }
+
+    // List encoder
+
+    function testEncodeEmpty() external pure {
+        assertEq(RLP.encoder().encode(), hex"c0");
+    }
+
+    function testEncodeBool(bool input) external pure {
+        bytes[] memory list = new bytes[](1);
+        list[0] = RLP.encode(input);
+
+        assertEq(RLP.encoder().push(input).encode(), RLP.encode(list));
+    }
+
+    function testEncodeAddress(address input) external pure {
+        bytes[] memory list = new bytes[](1);
+        list[0] = RLP.encode(input);
+
+        assertEq(RLP.encoder().push(input).encode(), RLP.encode(list));
+    }
+
+    function testEncodeUint256(uint256 input) external pure {
+        bytes[] memory list = new bytes[](1);
+        list[0] = RLP.encode(input);
+
+        assertEq(RLP.encoder().push(input).encode(), RLP.encode(list));
+    }
+
+    function testEncodeBytes32(bytes32 input) external pure {
+        bytes[] memory list = new bytes[](1);
+        list[0] = RLP.encode(input);
+
+        assertEq(RLP.encoder().push(input).encode(), RLP.encode(list));
+    }
+
+    function testEncodeBytes(bytes memory input) external pure {
+        bytes[] memory list = new bytes[](1);
+        list[0] = RLP.encode(input);
+
+        assertEq(RLP.encoder().push(input).encode(), RLP.encode(list));
+    }
+
+    function testEncodeString(string memory input) external pure {
+        bytes[] memory list = new bytes[](1);
+        list[0] = RLP.encode(input);
+
+        assertEq(RLP.encoder().push(input).encode(), RLP.encode(list));
+    }
+
+    /// forge-config: default.fuzz.runs = 512
+    function testEncodeBytesArray(bytes[] memory input) external pure {
+        bytes[] memory list = new bytes[](1);
+        list[0] = RLP.encode(input);
+
+        assertEq(RLP.encoder().push(input).encode(), RLP.encode(list));
+    }
+
+    function testEncodeEncoder(bytes memory input) external pure {
+        bytes[] memory list = new bytes[](1);
+        list[0] = RLP.encode(input);
+        list[0] = RLP.encode(list);
+
+        assertEq(RLP.encoder().push(RLP.encoder().push(input)).encode(), RLP.encode(list));
+    }
+
+    function testEncodeMultiType(uint256 u, bytes memory b, address a) external pure {
+        bytes[] memory list = new bytes[](3);
+        list[0] = RLP.encode(u);
+        list[1] = RLP.encode(b);
+        list[2] = RLP.encode(a);
+
+        assertEq(RLP.encoder().push(u).push(b).push(a).encode(), RLP.encode(list));
+
+        list[0] = RLP.encode(b);
+        list[1] = RLP.encode(a);
+        list[2] = RLP.encode(u);
+
+        assertEq(RLP.encoder().push(b).push(a).push(u).encode(), RLP.encode(list));
+    }
+
+    function testComputeCreateAddress(address deployer, uint256 nonce) external pure {
+        nonce = bound(nonce, 0, type(uint64).max);
+
+        assertEq(
+            address(uint160(uint256(keccak256(RLP.encoder().push(deployer).push(nonce).encode())))),
+            vm.computeCreateAddress(deployer, nonce)
+        );
+    }
+}

package/lib/openzeppelin-contracts/test/utils/RLP.test.js

@@ -0,0 +1,224 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { MAX_UINT64 } = require('../helpers/constants');
+const { product } = require('../helpers/iterate');
+const { generators } = require('../helpers/random');
+
+async function fixture() {
+  const mock = await ethers.deployContract('$RLP');
+
+  // Resolve function overload ambiguities like in Math.test.js
+  mock.$encode_bool = mock['$encode(bool)'];
+  mock.$encode_address = mock['$encode(address)'];
+  mock.$encode_uint256 = mock['$encode(uint256)'];
+  mock.$encode_bytes32 = mock['$encode(bytes32)'];
+  mock.$encode_bytes = mock['$encode(bytes)'];
+  mock.$encode_string = mock['$encode(string)'];
+  mock.$encode_list = mock['$encode(bytes[])'];
+
+  return { mock };
+}
+
+describe('RLP', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  it('encode/decode booleans', async function () {
+    await expect(this.mock.$encode_bool(false)).to.eventually.equal('0x80'); // 0
+    await expect(this.mock.$encode_bool(true)).to.eventually.equal('0x01'); // 1
+
+    await expect(this.mock.$decodeBool('0x80')).to.eventually.equal(false); // 0
+    await expect(this.mock.$decodeBool('0x01')).to.eventually.equal(true); // 1
+
+    // Non-canonical encodings treated as true
+    await expect(this.mock.$decodeBool('0x02')).to.eventually.equal(true);
+    await expect(this.mock.$decodeBool('0x03')).to.eventually.equal(true);
+    await expect(this.mock.$decodeBool('0x7f')).to.eventually.equal(true);
+  });
+
+  it('encode/decode addresses', async function () {
+    for (const addr of [
+      ethers.ZeroAddress, // zero address
+      '0x0000F90827F1C53a10cb7A02335B175320002935', // address with leading zeros
+      generators.address(), // random address
+    ]) {
+      const expected = ethers.encodeRlp(addr);
+      await expect(this.mock.$encode_address(addr)).to.eventually.equal(expected);
+      await expect(this.mock.$decodeAddress(expected)).to.eventually.equal(addr);
+    }
+
+    await expect(this.mock.$decodeAddress('0x940000000000000000000000000000000000001234')).to.eventually.equal(
+      '0x0000000000000000000000000000000000001234',
+    ); // Canonical encoding (address as 20 bytes with prefix)
+
+    // Single-byte encoding for precompile addresses
+    await expect(this.mock.$decodeAddress('0x01')).to.eventually.equal('0x0000000000000000000000000000000000000001');
+    await expect(this.mock.$decodeAddress('0x940000000000000000000000000000000000000001')).to.eventually.equal(
+      '0x0000000000000000000000000000000000000001',
+    ); // 21-byte encoding
+    await expect(this.mock.$decodeAddress('0x05')).to.eventually.equal('0x0000000000000000000000000000000000000005');
+    await expect(this.mock.$decodeAddress('0x940000000000000000000000000000000000000005')).to.eventually.equal(
+      '0x0000000000000000000000000000000000000005',
+    ); // 21-byte encoding
+    await expect(this.mock.$decodeAddress('0x7f')).to.eventually.equal('0x000000000000000000000000000000000000007f');
+    await expect(this.mock.$decodeAddress('0x94000000000000000000000000000000000000007f')).to.eventually.equal(
+      '0x000000000000000000000000000000000000007f',
+    ); // 21-byte encoding
+  });
+
+  it('encode/decode uint256', async function () {
+    for (const input of [0, 1, 127, 128, 256, 1024, 0xffffff, ethers.MaxUint256]) {
+      const expected = ethers.encodeRlp(ethers.toBeArray(input));
+
+      await expect(this.mock.$encode_uint256(input)).to.eventually.equal(expected);
+      await expect(this.mock.$decodeUint256(expected)).to.eventually.equal(input);
+
+      await expect(this.mock.$decodeUint256('0x88ab54a98ceb1f0ad2')).to.eventually.equal(12345678901234567890n); // Canonical encoding for 12345678901234567890
+      await expect(this.mock.$decodeUint256('0x8900ab54a98ceb1f0ad2')).to.eventually.equal(12345678901234567890n); // Non-canonical encoding with leading zero for the same value
+
+      await expect(this.mock.$decodeUint256('0x80')).to.eventually.equal(0n); // Canonical encoding for 0
+      await expect(this.mock.$decodeUint256('0x820000')).to.eventually.equal(0n); // Non-canonical encoding with leading zero
+      await expect(this.mock.$decodeUint256('0x83000000')).to.eventually.equal(0n); // Non-canonical encoding with two leading zeros
+      await expect(this.mock.$decodeUint256('0x8400000000')).to.eventually.equal(0n); // Non-canonical encoding with three leading zeros
+
+      await expect(this.mock.$decodeUint256('0x8204d2')).to.eventually.equal(1234n); // Canonical
+      await expect(this.mock.$decodeUint256('0x830004d2')).to.eventually.equal(1234n); // With leading zero
+      await expect(this.mock.$decodeUint256('0x84000004d2')).to.eventually.equal(1234n); // With two leading zeros
+    }
+  });
+
+  it('encode/decode bytes32', async function () {
+    for (const input of [
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000001',
+      '0x1000000000000000000000000000000000000000000000000000000000000000',
+      generators.bytes32(),
+    ]) {
+      const encoded = ethers.encodeRlp(input);
+      await expect(this.mock.$encode_bytes32(input)).to.eventually.equal(encoded);
+      await expect(this.mock.$decodeBytes32(encoded)).to.eventually.equal(input);
+    }
+
+    // Compact encoding for 1234
+    await expect(this.mock.$decodeBytes32('0x8204d2')).to.eventually.equal(
+      '0x00000000000000000000000000000000000000000000000000000000000004d2',
+    );
+    // Encoding with one leading zero
+    await expect(this.mock.$decodeBytes32('0x830004d2')).to.eventually.equal(
+      '0x00000000000000000000000000000000000000000000000000000000000004d2',
+    );
+    // Encoding with two leading zeros
+    await expect(this.mock.$decodeBytes32('0x84000004d2')).to.eventually.equal(
+      '0x00000000000000000000000000000000000000000000000000000000000004d2',
+    );
+    // Encoding for the value
+    await expect(this.mock.$decodeBytes32('0x80')).to.eventually.equal(ethers.ZeroHash);
+    // Encoding for two zeros (and nothing else)
+    await expect(this.mock.$decodeBytes32('0x820000')).to.eventually.equal(ethers.ZeroHash);
+  });
+
+  it('encode/decode empty byte', async function () {
+    const input = '0x';
+    const expected = ethers.encodeRlp(input);
+
+    await expect(this.mock.$encode_bytes(input)).to.eventually.equal(expected);
+    await expect(this.mock.$decodeBytes(expected)).to.eventually.equal(input);
+  });
+
+  it('encode/decode single byte < 128', async function () {
+    for (const input of ['0x00', '0x01', '0x7f']) {
+      const expected = ethers.encodeRlp(input);
+
+      await expect(this.mock.$encode_bytes(input)).to.eventually.equal(expected);
+      await expect(this.mock.$decodeBytes(expected)).to.eventually.equal(input);
+    }
+  });
+
+  it('encode/decode single byte >= 128', async function () {
+    for (const input of ['0x80', '0xff']) {
+      const expected = ethers.encodeRlp(input);
+
+      await expect(this.mock.$encode_bytes(input)).to.eventually.equal(expected);
+      await expect(this.mock.$decodeBytes(expected)).to.eventually.equal(input);
+    }
+  });
+
+  it('encode/decode short buffers (1-55 bytes)', async function () {
+    for (const input of [
+      '0xab', // 1 byte
+      '0x1234', // 2 bytes
+      generators.bytes(55), // 55 bytes (maximum for short encoding)
+    ]) {
+      const expected = ethers.encodeRlp(input);
+
+      await expect(this.mock.$encode_bytes(input)).to.eventually.equal(expected);
+      await expect(this.mock.$decodeBytes(expected)).to.eventually.equal(input);
+    }
+  });
+
+  it('encode/decode long buffers (>55 bytes)', async function () {
+    for (const input of [
+      generators.bytes(56), // 56 bytes (minimum for long encoding)
+      generators.bytes(128), // 128 bytes
+    ]) {
+      const expected = ethers.encodeRlp(input);
+
+      await expect(this.mock.$encode_bytes(input)).to.eventually.equal(expected);
+      await expect(this.mock.$decodeBytes(expected)).to.eventually.equal(input);
+    }
+  });
+
+  it('encode/decode strings', async function () {
+    for (const input of [
+      '', // empty string
+      '000000000cat', // string with leading zeros
+      'dog',
+      'Lorem ipsum dolor sit amet, consectetur adipisicing elit',
+    ]) {
+      const expected = ethers.encodeRlp(ethers.toUtf8Bytes(input));
+
+      await expect(this.mock.$encode_string(input)).to.eventually.equal(expected);
+      await expect(this.mock.$decodeString(expected)).to.eventually.equal(input);
+    }
+  });
+
+  it('encodes array (bytes[])', async function () {
+    for (const input of [[], ['0x'], ['0x00'], ['0x17', '0x42'], ['0x17', '0x', '0x42', '0x0123456789abcdef', '0x']]) {
+      await expect(this.mock.$encode_list(input.map(ethers.encodeRlp))).to.eventually.equal(ethers.encodeRlp(input));
+    }
+  });
+
+  const invalidTests = [
+    { name: 'short string with invalid length', input: '0x8100' },
+    { name: 'long string with invalid length prefix', input: '0xb800' },
+    { name: 'list with invalid length', input: '0xc100' },
+    { name: 'truncated long string', input: '0xb838' },
+    { name: 'invalid single byte encoding (non-minimal)', input: '0x8100' },
+  ];
+
+  invalidTests.forEach(({ name, input }) => {
+    it(`rejects ${name}`, async function () {
+      await expect(this.mock.$decodeBytes(input)).to.be.revertedWithCustomError(this.mock, 'RLPInvalidEncoding');
+    });
+  });
+
+  it('RLP encoder predict create addresses', async function () {
+    for (const [from, nonce] of product(
+      [
+        ethers.ZeroAddress, // zero address
+        '0x0000F90827F1C53a10cb7A02335B175320002935', // address with heading zeros
+        generators.address(), // random address
+      ],
+      [0n, 1n, 42n, 65535n, MAX_UINT64],
+    )) {
+      await expect(
+        this.mock
+          .$encode_list([this.mock.$encode_address(from), this.mock.$encode_uint256(nonce)])
+          .then(encoded => ethers.getAddress(ethers.dataSlice(ethers.keccak256(encoded), 12))), // hash the encoded content, take the last 20 bytes and format as (checksummed) address
+      ).to.eventually.equal(ethers.getCreateAddress({ from, nonce }));
+    }
+  });
+});

package/lib/openzeppelin-contracts/test/utils/ReentrancyGuard.test.js

@@ -0,0 +1,58 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+for (const variant of ['', 'Transient']) {
+  describe(`Reentrancy${variant}Guard`, function () {
+    async function fixture() {
+      const name = `Reentrancy${variant}Mock`;
+      const mock = await ethers.deployContract(name);
+      const attacker = await ethers.deployContract('ReentrancyAttack');
+      return { name, mock, attacker };
+    }
+
+    beforeEach(async function () {
+      Object.assign(this, await loadFixture(fixture));
+    });
+
+    it('nonReentrant function can be called', async function () {
+      expect(await this.mock.counter()).to.equal(0n);
+      await this.mock.callback();
+      expect(await this.mock.counter()).to.equal(1n);
+    });
+
+    it('nonReentrantView function can be called', async function () {
+      await this.mock.viewCallback();
+    });
+
+    it('does not allow remote callback to nonReentrant function', async function () {
+      await expect(this.mock.countAndCall(this.attacker)).to.be.revertedWith('ReentrancyAttack: failed call');
+    });
+
+    it('does not allow remote callback to nonReentrantView function', async function () {
+      await expect(this.mock.countAndCallView(this.attacker)).to.be.revertedWith('ReentrancyAttack: failed call');
+    });
+
+    it('_reentrancyGuardEntered should be true when guarded', async function () {
+      await this.mock.guardedCheckEntered();
+    });
+
+    it('_reentrancyGuardEntered should be false when unguarded', async function () {
+      await this.mock.unguardedCheckNotEntered();
+    });
+
+    // The following are more side-effects than intended behavior:
+    // I put them here as documentation, and to monitor any changes
+    // in the side-effects.
+    it('does not allow local recursion', async function () {
+      await expect(this.mock.countLocalRecursive(10n)).to.be.revertedWithCustomError(
+        this.mock,
+        'ReentrancyGuardReentrantCall',
+      );
+    });
+
+    it('does not allow indirect local recursion', async function () {
+      await expect(this.mock.countThisRecursive(10n)).to.be.revertedWith(`${this.name}: failed call`);
+    });
+  });
+}