Migrate math tests to ethers.js v6 (#4769)

Co-authored-by: Ernesto García <ernestognw@gmail.com>

test/helpers/enums.js

@@ -2,10 +2,20 @@ function Enum(...options) {
   return Object.fromEntries(options.map((key, i) => [key, web3.utils.toBN(i)]));
 }
 
-module.exports = {
-  Enum,
-  ProposalState: Enum('Pending', 'Active', 'Canceled', 'Defeated', 'Succeeded', 'Queued', 'Expired', 'Executed'),
-  VoteType: Enum('Against', 'For', 'Abstain'),
-  Rounding: Enum('Floor', 'Ceil', 'Trunc', 'Expand'),
-  OperationState: Enum('Unset', 'Waiting', 'Ready', 'Done'),
-};
+function EnumBigInt(...options) {
+  return Object.fromEntries(options.map((key, i) => [key, BigInt(i)]));
+}
+
+// TODO: remove web3, simplify code
+function createExport(Enum) {
+  return {
+    Enum,
+    ProposalState: Enum('Pending', 'Active', 'Canceled', 'Defeated', 'Succeeded', 'Queued', 'Expired', 'Executed'),
+    VoteType: Enum('Against', 'For', 'Abstain'),
+    Rounding: Enum('Floor', 'Ceil', 'Trunc', 'Expand'),
+    OperationState: Enum('Unset', 'Waiting', 'Ready', 'Done'),
+  };
+}
+
+module.exports = createExport(Enum);
+module.exports.bigint = createExport(EnumBigInt);

test/helpers/iterate.js

@@ -1,16 +1,10 @@
 // Map values in an object
 const mapValues = (obj, fn) => Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn(v)]));
 
-// Array of number or bigint
-const max = (...values) => values.slice(1).reduce((x, y) => (x > y ? x : y), values[0]);
-const min = (...values) => values.slice(1).reduce((x, y) => (x < y ? x : y), values[0]);
-
 // Cartesian product of a list of arrays
 const product = (...arrays) => arrays.reduce((a, b) => a.flatMap(ai => b.map(bi => [...ai, bi])), [[]]);
 
 module.exports = {
   mapValues,
-  max,
-  min,
   product,
 };

test/helpers/math.js

@@ -1,12 +1,13 @@
+// Array of number or bigint
+const max = (...values) => values.slice(1).reduce((x, y) => (x > y ? x : y), values.at(0));
+const min = (...values) => values.slice(1).reduce((x, y) => (x < y ? x : y), values.at(0));
+const sum = (...values) => values.slice(1).reduce((x, y) => x + y, values.at(0));
+
 module.exports = {
-  // sum of integer / bignumber
-  sum: (...args) => args.reduce((acc, n) => acc + n, 0),
-  bigintSum: (...args) => args.reduce((acc, n) => acc + n, 0n),
-  BNsum: (...args) => args.reduce((acc, n) => acc.add(n), web3.utils.toBN(0)),
-  // min of integer / bignumber
-  min: (...args) => args.slice(1).reduce((x, y) => (x < y ? x : y), args[0]),
-  BNmin: (...args) => args.slice(1).reduce((x, y) => (x.lt(y) ? x : y), args[0]),
-  // max of integer / bignumber
-  max: (...args) => args.slice(1).reduce((x, y) => (x > y ? x : y), args[0]),
-  BNmax: (...args) => args.slice(1).reduce((x, y) => (x.gt(y) ? x : y), args[0]),
+  // re-export min, max & sum of integer / bignumber
+  min,
+  max,
+  sum,
+  // deprecated: BN version of sum
+  BNsum: (...args) => args.slice(1).reduce((x, y) => x.add(y), args.at(0)),
 };

test/metatx/ERC2771Forwarder.test.js

@@ -4,7 +4,7 @@ const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
 
 const { getDomain } = require('../helpers/eip712');
 const { bigint: time } = require('../helpers/time');
-const { bigintSum: sum } = require('../helpers/math');
+const { sum } = require('../helpers/math');
 
 async function fixture() {
   const [sender, refundReceiver, another, ...accounts] = await ethers.getSigners();

test/token/ERC721/extensions/ERC721Consecutive.test.js

@@ -70,7 +70,8 @@ contract('ERC721Consecutive', function (accounts) {
 
         it('balance & voting power are set', async function () {
           for (const account of accounts) {
-            const balance = sum(...batches.filter(({ receiver }) => receiver === account).map(({ amount }) => amount));
+            const balance =
+              sum(...batches.filter(({ receiver }) => receiver === account).map(({ amount }) => amount)) ?? 0;
 
             expect(await this.token.balanceOf(account)).to.be.bignumber.equal(web3.utils.toBN(balance));
 

test/utils/math/Math.test.js

@@ -1,320 +1,298 @@
-const { BN, constants, expectRevert } = require('@openzeppelin/test-helpers');
+const { ethers } = require('hardhat');
 const { expect } = require('chai');
-const { MAX_UINT256 } = constants;
-const { Rounding } = require('../../helpers/enums.js');
-const { expectRevertCustomError } = require('../../helpers/customError.js');
-
-const Math = artifacts.require('$Math');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic');
+const { min, max } = require('../../helpers/math');
+const {
+  bigint: { Rounding },
+} = require('../../helpers/enums.js');
 
 const RoundingDown = [Rounding.Floor, Rounding.Trunc];
 const RoundingUp = [Rounding.Ceil, Rounding.Expand];
 
-function expectStruct(value, expected) {
-  for (const key in expected) {
-    if (BN.isBN(value[key])) {
-      expect(value[key]).to.be.bignumber.equal(expected[key]);
-    } else {
-      expect(value[key]).to.be.equal(expected[key]);
-    }
-  }
+async function testCommutative(fn, lhs, rhs, expected, ...extra) {
+  expect(await fn(lhs, rhs, ...extra)).to.deep.equal(expected);
+  expect(await fn(rhs, lhs, ...extra)).to.deep.equal(expected);
 }
 
-async function testCommutativeIterable(fn, lhs, rhs, expected, ...extra) {
-  expectStruct(await fn(lhs, rhs, ...extra), expected);
-  expectStruct(await fn(rhs, lhs, ...extra), expected);
-}
+async function fixture() {
+  const mock = await ethers.deployContract('$Math');
 
-contract('Math', function () {
-  const min = new BN('1234');
-  const max = new BN('5678');
-  const MAX_UINT256_SUB1 = MAX_UINT256.sub(new BN('1'));
-  const MAX_UINT256_SUB2 = MAX_UINT256.sub(new BN('2'));
+  // disambiguation, we use the version with explicit rounding
+  mock.$mulDiv = mock['$mulDiv(uint256,uint256,uint256,uint8)'];
+  mock.$sqrt = mock['$sqrt(uint256,uint8)'];
+  mock.$log2 = mock['$log2(uint256,uint8)'];
+  mock.$log10 = mock['$log10(uint256,uint8)'];
+  mock.$log256 = mock['$log256(uint256,uint8)'];
 
+  return { mock };
+}
+
+describe('Math', function () {
   beforeEach(async function () {
-    this.math = await Math.new();
+    Object.assign(this, await loadFixture(fixture));
   });
 
   describe('tryAdd', function () {
     it('adds correctly', async function () {
-      const a = new BN('5678');
-      const b = new BN('1234');
-
-      await testCommutativeIterable(this.math.$tryAdd, a, b, [true, a.add(b)]);
+      const a = 5678n;
+      const b = 1234n;
+      await testCommutative(this.mock.$tryAdd, a, b, [true, a + b]);
     });
 
     it('reverts on addition overflow', async function () {
-      const a = MAX_UINT256;
-      const b = new BN('1');
-
-      await testCommutativeIterable(this.math.$tryAdd, a, b, [false, '0']);
+      const a = ethers.MaxUint256;
+      const b = 1n;
+      await testCommutative(this.mock.$tryAdd, a, b, [false, 0n]);
     });
   });
 
   describe('trySub', function () {
     it('subtracts correctly', async function () {
-      const a = new BN('5678');
-      const b = new BN('1234');
-
-      expectStruct(await this.math.$trySub(a, b), [true, a.sub(b)]);
+      const a = 5678n;
+      const b = 1234n;
+      expect(await this.mock.$trySub(a, b)).to.deep.equal([true, a - b]);
     });
 
     it('reverts if subtraction result would be negative', async function () {
-      const a = new BN('1234');
-      const b = new BN('5678');
-
-      expectStruct(await this.math.$trySub(a, b), [false, '0']);
+      const a = 1234n;
+      const b = 5678n;
+      expect(await this.mock.$trySub(a, b)).to.deep.equal([false, 0n]);
     });
   });
 
   describe('tryMul', function () {
     it('multiplies correctly', async function () {
-      const a = new BN('1234');
-      const b = new BN('5678');
-
-      await testCommutativeIterable(this.math.$tryMul, a, b, [true, a.mul(b)]);
+      const a = 1234n;
+      const b = 5678n;
+      await testCommutative(this.mock.$tryMul, a, b, [true, a * b]);
     });
 
     it('multiplies by zero correctly', async function () {
-      const a = new BN('0');
-      const b = new BN('5678');
-
-      await testCommutativeIterable(this.math.$tryMul, a, b, [true, a.mul(b)]);
+      const a = 0n;
+      const b = 5678n;
+      await testCommutative(this.mock.$tryMul, a, b, [true, a * b]);
     });
 
     it('reverts on multiplication overflow', async function () {
-      const a = MAX_UINT256;
-      const b = new BN('2');
-
-      await testCommutativeIterable(this.math.$tryMul, a, b, [false, '0']);
+      const a = ethers.MaxUint256;
+      const b = 2n;
+      await testCommutative(this.mock.$tryMul, a, b, [false, 0n]);
     });
   });
 
   describe('tryDiv', function () {
     it('divides correctly', async function () {
-      const a = new BN('5678');
-      const b = new BN('5678');
-
-      expectStruct(await this.math.$tryDiv(a, b), [true, a.div(b)]);
+      const a = 5678n;
+      const b = 5678n;
+      expect(await this.mock.$tryDiv(a, b)).to.deep.equal([true, a / b]);
     });
 
     it('divides zero correctly', async function () {
-      const a = new BN('0');
-      const b = new BN('5678');
-
-      expectStruct(await this.math.$tryDiv(a, b), [true, a.div(b)]);
+      const a = 0n;
+      const b = 5678n;
+      expect(await this.mock.$tryDiv(a, b)).to.deep.equal([true, a / b]);
     });
 
     it('returns complete number result on non-even division', async function () {
-      const a = new BN('7000');
-      const b = new BN('5678');
-
-      expectStruct(await this.math.$tryDiv(a, b), [true, a.div(b)]);
+      const a = 7000n;
+      const b = 5678n;
+      expect(await this.mock.$tryDiv(a, b)).to.deep.equal([true, a / b]);
     });
 
     it('reverts on division by zero', async function () {
-      const a = new BN('5678');
-      const b = new BN('0');
-
-      expectStruct(await this.math.$tryDiv(a, b), [false, '0']);
+      const a = 5678n;
+      const b = 0n;
+      expect(await this.mock.$tryDiv(a, b)).to.deep.equal([false, 0n]);
     });
   });
 
   describe('tryMod', function () {
-    describe('modulos correctly', async function () {
+    describe('modulos correctly', function () {
       it('when the dividend is smaller than the divisor', async function () {
-        const a = new BN('284');
-        const b = new BN('5678');
-
-        expectStruct(await this.math.$tryMod(a, b), [true, a.mod(b)]);
+        const a = 284n;
+        const b = 5678n;
+        expect(await this.mock.$tryMod(a, b)).to.deep.equal([true, a % b]);
       });
 
       it('when the dividend is equal to the divisor', async function () {
-        const a = new BN('5678');
-        const b = new BN('5678');
-
-        expectStruct(await this.math.$tryMod(a, b), [true, a.mod(b)]);
+        const a = 5678n;
+        const b = 5678n;
+        expect(await this.mock.$tryMod(a, b)).to.deep.equal([true, a % b]);
       });
 
       it('when the dividend is larger than the divisor', async function () {
-        const a = new BN('7000');
-        const b = new BN('5678');
-
-        expectStruct(await this.math.$tryMod(a, b), [true, a.mod(b)]);
+        const a = 7000n;
+        const b = 5678n;
+        expect(await this.mock.$tryMod(a, b)).to.deep.equal([true, a % b]);
       });
 
       it('when the dividend is a multiple of the divisor', async function () {
-        const a = new BN('17034'); // 17034 == 5678 * 3
-        const b = new BN('5678');
-
-        expectStruct(await this.math.$tryMod(a, b), [true, a.mod(b)]);
+        const a = 17034n; // 17034 == 5678 * 3
+        const b = 5678n;
+        expect(await this.mock.$tryMod(a, b)).to.deep.equal([true, a % b]);
       });
     });
 
     it('reverts with a 0 divisor', async function () {
-      const a = new BN('5678');
-      const b = new BN('0');
-
-      expectStruct(await this.math.$tryMod(a, b), [false, '0']);
+      const a = 5678n;
+      const b = 0n;
+      expect(await this.mock.$tryMod(a, b)).to.deep.equal([false, 0n]);
     });
   });
 
   describe('max', function () {
-    it('is correctly detected in first argument position', async function () {
-      expect(await this.math.$max(max, min)).to.be.bignumber.equal(max);
-    });
-
-    it('is correctly detected in second argument position', async function () {
-      expect(await this.math.$max(min, max)).to.be.bignumber.equal(max);
+    it('is correctly detected in both position', async function () {
+      await testCommutative(this.mock.$max, 1234n, 5678n, max(1234n, 5678n));
     });
   });
 
   describe('min', function () {
-    it('is correctly detected in first argument position', async function () {
-      expect(await this.math.$min(min, max)).to.be.bignumber.equal(min);
-    });
-
-    it('is correctly detected in second argument position', async function () {
-      expect(await this.math.$min(max, min)).to.be.bignumber.equal(min);
+    it('is correctly detected in both position', async function () {
+      await testCommutative(this.mock.$min, 1234n, 5678n, min(1234n, 5678n));
     });
   });
 
   describe('average', function () {
-    function bnAverage(a, b) {
-      return a.add(b).divn(2);
-    }
-
     it('is correctly calculated with two odd numbers', async function () {
-      const a = new BN('57417');
-      const b = new BN('95431');
-      expect(await this.math.$average(a, b)).to.be.bignumber.equal(bnAverage(a, b));
+      const a = 57417n;
+      const b = 95431n;
+      expect(await this.mock.$average(a, b)).to.equal((a + b) / 2n);
     });
 
     it('is correctly calculated with two even numbers', async function () {
-      const a = new BN('42304');
-      const b = new BN('84346');
-      expect(await this.math.$average(a, b)).to.be.bignumber.equal(bnAverage(a, b));
+      const a = 42304n;
+      const b = 84346n;
+      expect(await this.mock.$average(a, b)).to.equal((a + b) / 2n);
     });
 
     it('is correctly calculated with one even and one odd number', async function () {
-      const a = new BN('57417');
-      const b = new BN('84346');
-      expect(await this.math.$average(a, b)).to.be.bignumber.equal(bnAverage(a, b));
+      const a = 57417n;
+      const b = 84346n;
+      expect(await this.mock.$average(a, b)).to.equal((a + b) / 2n);
     });
 
     it('is correctly calculated with two max uint256 numbers', async function () {
-      const a = MAX_UINT256;
-      expect(await this.math.$average(a, a)).to.be.bignumber.equal(bnAverage(a, a));
+      const a = ethers.MaxUint256;
+      expect(await this.mock.$average(a, a)).to.equal(a);
     });
   });
 
   describe('ceilDiv', function () {
     it('reverts on zero division', async function () {
-      const a = new BN('2');
-      const b = new BN('0');
+      const a = 2n;
+      const b = 0n;
       // It's unspecified because it's a low level 0 division error
-      await expectRevert.unspecified(this.math.$ceilDiv(a, b));
+      await expect(this.mock.$ceilDiv(a, b)).to.be.revertedWithPanic(PANIC_CODES.DIVISION_BY_ZERO);
     });
 
     it('does not round up a zero result', async function () {
-      const a = new BN('0');
-      const b = new BN('2');
-      expect(await this.math.$ceilDiv(a, b)).to.be.bignumber.equal('0');
+      const a = 0n;
+      const b = 2n;
+      const r = 0n;
+      expect(await this.mock.$ceilDiv(a, b)).to.equal(r);
     });
 
     it('does not round up on exact division', async function () {
-      const a = new BN('10');
-      const b = new BN('5');
-      expect(await this.math.$ceilDiv(a, b)).to.be.bignumber.equal('2');
+      const a = 10n;
+      const b = 5n;
+      const r = 2n;
+      expect(await this.mock.$ceilDiv(a, b)).to.equal(r);
     });
 
     it('rounds up on division with remainders', async function () {
-      const a = new BN('42');
-      const b = new BN('13');
-      expect(await this.math.$ceilDiv(a, b)).to.be.bignumber.equal('4');
+      const a = 42n;
+      const b = 13n;
+      const r = 4n;
+      expect(await this.mock.$ceilDiv(a, b)).to.equal(r);
     });
 
     it('does not overflow', async function () {
-      const b = new BN('2');
-      const result = new BN('1').shln(255);
-      expect(await this.math.$ceilDiv(MAX_UINT256, b)).to.be.bignumber.equal(result);
+      const a = ethers.MaxUint256;
+      const b = 2n;
+      const r = 1n << 255n;
+      expect(await this.mock.$ceilDiv(a, b)).to.equal(r);
     });
 
     it('correctly computes max uint256 divided by 1', async function () {
-      const b = new BN('1');
-      expect(await this.math.$ceilDiv(MAX_UINT256, b)).to.be.bignumber.equal(MAX_UINT256);
+      const a = ethers.MaxUint256;
+      const b = 1n;
+      const r = ethers.MaxUint256;
+      expect(await this.mock.$ceilDiv(a, b)).to.equal(r);
     });
   });
 
   describe('muldiv', function () {
     it('divide by 0', async function () {
-      await expectRevert.unspecified(this.math.$mulDiv(1, 1, 0, Rounding.Floor));
+      const a = 1n;
+      const b = 1n;
+      const c = 0n;
+      await expect(this.mock.$mulDiv(a, b, c, Rounding.Floor)).to.be.revertedWithPanic(PANIC_CODES.DIVISION_BY_ZERO);
     });
 
     it('reverts with result higher than 2 ^ 256', async function () {
-      await expectRevertCustomError(this.math.$mulDiv(5, MAX_UINT256, 2, Rounding.Floor), 'MathOverflowedMulDiv', []);
+      const a = 5n;
+      const b = ethers.MaxUint256;
+      const c = 2n;
+      await expect(this.mock.$mulDiv(a, b, c, Rounding.Floor)).to.be.revertedWithCustomError(
+        this.mock,
+        'MathOverflowedMulDiv',
+      );
     });
 
-    describe('does round down', async function () {
+    describe('does round down', function () {
       it('small values', async function () {
         for (const rounding of RoundingDown) {
-          expect(await this.math.$mulDiv('3', '4', '5', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$mulDiv('3', '5', '5', rounding)).to.be.bignumber.equal('3');
+          expect(await this.mock.$mulDiv(3n, 4n, 5n, rounding)).to.equal(2n);
+          expect(await this.mock.$mulDiv(3n, 5n, 5n, rounding)).to.equal(3n);
         }
       });
 
       it('large values', async function () {
         for (const rounding of RoundingDown) {
-          expect(await this.math.$mulDiv(new BN('42'), MAX_UINT256_SUB1, MAX_UINT256, rounding)).to.be.bignumber.equal(
-            new BN('41'),
-          );
+          expect(await this.mock.$mulDiv(42n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding)).to.equal(41n);
 
-          expect(await this.math.$mulDiv(new BN('17'), MAX_UINT256, MAX_UINT256, rounding)).to.be.bignumber.equal(
-            new BN('17'),
-          );
+          expect(await this.mock.$mulDiv(17n, ethers.MaxUint256, ethers.MaxUint256, rounding)).to.equal(17n);
 
           expect(
-            await this.math.$mulDiv(MAX_UINT256_SUB1, MAX_UINT256_SUB1, MAX_UINT256, rounding),
-          ).to.be.bignumber.equal(MAX_UINT256_SUB2);
+            await this.mock.$mulDiv(ethers.MaxUint256 - 1n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding),
+          ).to.equal(ethers.MaxUint256 - 2n);
 
-          expect(await this.math.$mulDiv(MAX_UINT256, MAX_UINT256_SUB1, MAX_UINT256, rounding)).to.be.bignumber.equal(
-            MAX_UINT256_SUB1,
-          );
+          expect(
+            await this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding),
+          ).to.equal(ethers.MaxUint256 - 1n);
 
-          expect(await this.math.$mulDiv(MAX_UINT256, MAX_UINT256, MAX_UINT256, rounding)).to.be.bignumber.equal(
-            MAX_UINT256,
+          expect(await this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256, ethers.MaxUint256, rounding)).to.equal(
+            ethers.MaxUint256,
           );
         }
       });
     });
 
-    describe('does round up', async function () {
+    describe('does round up', function () {
       it('small values', async function () {
         for (const rounding of RoundingUp) {
-          expect(await this.math.$mulDiv('3', '4', '5', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.$mulDiv('3', '5', '5', rounding)).to.be.bignumber.equal('3');
+          expect(await this.mock.$mulDiv(3n, 4n, 5n, rounding)).to.equal(3n);
+          expect(await this.mock.$mulDiv(3n, 5n, 5n, rounding)).to.equal(3n);
         }
       });
 
       it('large values', async function () {
         for (const rounding of RoundingUp) {
-          expect(await this.math.$mulDiv(new BN('42'), MAX_UINT256_SUB1, MAX_UINT256, rounding)).to.be.bignumber.equal(
-            new BN('42'),
-          );
+          expect(await this.mock.$mulDiv(42n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding)).to.equal(42n);
 
-          expect(await this.math.$mulDiv(new BN('17'), MAX_UINT256, MAX_UINT256, rounding)).to.be.bignumber.equal(
-            new BN('17'),
-          );
+          expect(await this.mock.$mulDiv(17n, ethers.MaxUint256, ethers.MaxUint256, rounding)).to.equal(17n);
 
           expect(
-            await this.math.$mulDiv(MAX_UINT256_SUB1, MAX_UINT256_SUB1, MAX_UINT256, rounding),
-          ).to.be.bignumber.equal(MAX_UINT256_SUB1);
+            await this.mock.$mulDiv(ethers.MaxUint256 - 1n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding),
+          ).to.equal(ethers.MaxUint256 - 1n);
 
-          expect(await this.math.$mulDiv(MAX_UINT256, MAX_UINT256_SUB1, MAX_UINT256, rounding)).to.be.bignumber.equal(
-            MAX_UINT256_SUB1,
-          );
+          expect(
+            await this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding),
+          ).to.equal(ethers.MaxUint256 - 1n);
 
-          expect(await this.math.$mulDiv(MAX_UINT256, MAX_UINT256, MAX_UINT256, rounding)).to.be.bignumber.equal(
-            MAX_UINT256,
+          expect(await this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256, ethers.MaxUint256, rounding)).to.equal(
+            ethers.MaxUint256,
           );
         }
       });
@@ -324,39 +302,35 @@ contract('Math', function () {
   describe('sqrt', function () {
     it('rounds down', async function () {
       for (const rounding of RoundingDown) {
-        expect(await this.math.$sqrt('0', rounding)).to.be.bignumber.equal('0');
-        expect(await this.math.$sqrt('1', rounding)).to.be.bignumber.equal('1');
-        expect(await this.math.$sqrt('2', rounding)).to.be.bignumber.equal('1');
-        expect(await this.math.$sqrt('3', rounding)).to.be.bignumber.equal('1');
-        expect(await this.math.$sqrt('4', rounding)).to.be.bignumber.equal('2');
-        expect(await this.math.$sqrt('144', rounding)).to.be.bignumber.equal('12');
-        expect(await this.math.$sqrt('999999', rounding)).to.be.bignumber.equal('999');
-        expect(await this.math.$sqrt('1000000', rounding)).to.be.bignumber.equal('1000');
-        expect(await this.math.$sqrt('1000001', rounding)).to.be.bignumber.equal('1000');
-        expect(await this.math.$sqrt('1002000', rounding)).to.be.bignumber.equal('1000');
-        expect(await this.math.$sqrt('1002001', rounding)).to.be.bignumber.equal('1001');
-        expect(await this.math.$sqrt(MAX_UINT256, rounding)).to.be.bignumber.equal(
-          '340282366920938463463374607431768211455',
-        );
+        expect(await this.mock.$sqrt(0n, rounding)).to.equal(0n);
+        expect(await this.mock.$sqrt(1n, rounding)).to.equal(1n);
+        expect(await this.mock.$sqrt(2n, rounding)).to.equal(1n);
+        expect(await this.mock.$sqrt(3n, rounding)).to.equal(1n);
+        expect(await this.mock.$sqrt(4n, rounding)).to.equal(2n);
+        expect(await this.mock.$sqrt(144n, rounding)).to.equal(12n);
+        expect(await this.mock.$sqrt(999999n, rounding)).to.equal(999n);
+        expect(await this.mock.$sqrt(1000000n, rounding)).to.equal(1000n);
+        expect(await this.mock.$sqrt(1000001n, rounding)).to.equal(1000n);
+        expect(await this.mock.$sqrt(1002000n, rounding)).to.equal(1000n);
+        expect(await this.mock.$sqrt(1002001n, rounding)).to.equal(1001n);
+        expect(await this.mock.$sqrt(ethers.MaxUint256, rounding)).to.equal(340282366920938463463374607431768211455n);
       }
     });
 
     it('rounds up', async function () {
       for (const rounding of RoundingUp) {
-        expect(await this.math.$sqrt('0', rounding)).to.be.bignumber.equal('0');
-        expect(await this.math.$sqrt('1', rounding)).to.be.bignumber.equal('1');
-        expect(await this.math.$sqrt('2', rounding)).to.be.bignumber.equal('2');
-        expect(await this.math.$sqrt('3', rounding)).to.be.bignumber.equal('2');
-        expect(await this.math.$sqrt('4', rounding)).to.be.bignumber.equal('2');
-        expect(await this.math.$sqrt('144', rounding)).to.be.bignumber.equal('12');
-        expect(await this.math.$sqrt('999999', rounding)).to.be.bignumber.equal('1000');
-        expect(await this.math.$sqrt('1000000', rounding)).to.be.bignumber.equal('1000');
-        expect(await this.math.$sqrt('1000001', rounding)).to.be.bignumber.equal('1001');
-        expect(await this.math.$sqrt('1002000', rounding)).to.be.bignumber.equal('1001');
-        expect(await this.math.$sqrt('1002001', rounding)).to.be.bignumber.equal('1001');
-        expect(await this.math.$sqrt(MAX_UINT256, rounding)).to.be.bignumber.equal(
-          '340282366920938463463374607431768211456',
-        );
+        expect(await this.mock.$sqrt(0n, rounding)).to.equal(0n);
+        expect(await this.mock.$sqrt(1n, rounding)).to.equal(1n);
+        expect(await this.mock.$sqrt(2n, rounding)).to.equal(2n);
+        expect(await this.mock.$sqrt(3n, rounding)).to.equal(2n);
+        expect(await this.mock.$sqrt(4n, rounding)).to.equal(2n);
+        expect(await this.mock.$sqrt(144n, rounding)).to.equal(12n);
+        expect(await this.mock.$sqrt(999999n, rounding)).to.equal(1000n);
+        expect(await this.mock.$sqrt(1000000n, rounding)).to.equal(1000n);
+        expect(await this.mock.$sqrt(1000001n, rounding)).to.equal(1001n);
+        expect(await this.mock.$sqrt(1002000n, rounding)).to.equal(1001n);
+        expect(await this.mock.$sqrt(1002001n, rounding)).to.equal(1001n);
+        expect(await this.mock.$sqrt(ethers.MaxUint256, rounding)).to.equal(340282366920938463463374607431768211456n);
       }
     });
   });
@@ -365,33 +339,33 @@ contract('Math', function () {
     describe('log2', function () {
       it('rounds down', async function () {
         for (const rounding of RoundingDown) {
-          expect(await this.math.methods['$log2(uint256,uint8)']('0', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.methods['$log2(uint256,uint8)']('1', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.methods['$log2(uint256,uint8)']('2', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.methods['$log2(uint256,uint8)']('3', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.methods['$log2(uint256,uint8)']('4', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.methods['$log2(uint256,uint8)']('5', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.methods['$log2(uint256,uint8)']('6', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.methods['$log2(uint256,uint8)']('7', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.methods['$log2(uint256,uint8)']('8', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.methods['$log2(uint256,uint8)']('9', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.methods['$log2(uint256,uint8)'](MAX_UINT256, rounding)).to.be.bignumber.equal('255');
+          expect(await this.mock.$log2(0n, rounding)).to.equal(0n);
+          expect(await this.mock.$log2(1n, rounding)).to.equal(0n);
+          expect(await this.mock.$log2(2n, rounding)).to.equal(1n);
+          expect(await this.mock.$log2(3n, rounding)).to.equal(1n);
+          expect(await this.mock.$log2(4n, rounding)).to.equal(2n);
+          expect(await this.mock.$log2(5n, rounding)).to.equal(2n);
+          expect(await this.mock.$log2(6n, rounding)).to.equal(2n);
+          expect(await this.mock.$log2(7n, rounding)).to.equal(2n);
+          expect(await this.mock.$log2(8n, rounding)).to.equal(3n);
+          expect(await this.mock.$log2(9n, rounding)).to.equal(3n);
+          expect(await this.mock.$log2(ethers.MaxUint256, rounding)).to.equal(255n);
         }
       });
 
       it('rounds up', async function () {
         for (const rounding of RoundingUp) {
-          expect(await this.math.methods['$log2(uint256,uint8)']('0', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.methods['$log2(uint256,uint8)']('1', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.methods['$log2(uint256,uint8)']('2', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.methods['$log2(uint256,uint8)']('3', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.methods['$log2(uint256,uint8)']('4', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.methods['$log2(uint256,uint8)']('5', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.methods['$log2(uint256,uint8)']('6', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.methods['$log2(uint256,uint8)']('7', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.methods['$log2(uint256,uint8)']('8', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.methods['$log2(uint256,uint8)']('9', rounding)).to.be.bignumber.equal('4');
-          expect(await this.math.methods['$log2(uint256,uint8)'](MAX_UINT256, rounding)).to.be.bignumber.equal('256');
+          expect(await this.mock.$log2(0n, rounding)).to.equal(0n);
+          expect(await this.mock.$log2(1n, rounding)).to.equal(0n);
+          expect(await this.mock.$log2(2n, rounding)).to.equal(1n);
+          expect(await this.mock.$log2(3n, rounding)).to.equal(2n);
+          expect(await this.mock.$log2(4n, rounding)).to.equal(2n);
+          expect(await this.mock.$log2(5n, rounding)).to.equal(3n);
+          expect(await this.mock.$log2(6n, rounding)).to.equal(3n);
+          expect(await this.mock.$log2(7n, rounding)).to.equal(3n);
+          expect(await this.mock.$log2(8n, rounding)).to.equal(3n);
+          expect(await this.mock.$log2(9n, rounding)).to.equal(4n);
+          expect(await this.mock.$log2(ethers.MaxUint256, rounding)).to.equal(256n);
         }
       });
     });
@@ -399,37 +373,37 @@ contract('Math', function () {
     describe('log10', function () {
       it('rounds down', async function () {
         for (const rounding of RoundingDown) {
-          expect(await this.math.$log10('0', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log10('1', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log10('2', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log10('9', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log10('10', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log10('11', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log10('99', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log10('100', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log10('101', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log10('999', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log10('1000', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.$log10('1001', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.$log10(MAX_UINT256, rounding)).to.be.bignumber.equal('77');
+          expect(await this.mock.$log10(0n, rounding)).to.equal(0n);
+          expect(await this.mock.$log10(1n, rounding)).to.equal(0n);
+          expect(await this.mock.$log10(2n, rounding)).to.equal(0n);
+          expect(await this.mock.$log10(9n, rounding)).to.equal(0n);
+          expect(await this.mock.$log10(10n, rounding)).to.equal(1n);
+          expect(await this.mock.$log10(11n, rounding)).to.equal(1n);
+          expect(await this.mock.$log10(99n, rounding)).to.equal(1n);
+          expect(await this.mock.$log10(100n, rounding)).to.equal(2n);
+          expect(await this.mock.$log10(101n, rounding)).to.equal(2n);
+          expect(await this.mock.$log10(999n, rounding)).to.equal(2n);
+          expect(await this.mock.$log10(1000n, rounding)).to.equal(3n);
+          expect(await this.mock.$log10(1001n, rounding)).to.equal(3n);
+          expect(await this.mock.$log10(ethers.MaxUint256, rounding)).to.equal(77n);
         }
       });
 
       it('rounds up', async function () {
         for (const rounding of RoundingUp) {
-          expect(await this.math.$log10('0', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log10('1', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log10('2', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log10('9', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log10('10', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log10('11', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log10('99', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log10('100', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log10('101', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.$log10('999', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.$log10('1000', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.$log10('1001', rounding)).to.be.bignumber.equal('4');
-          expect(await this.math.$log10(MAX_UINT256, rounding)).to.be.bignumber.equal('78');
+          expect(await this.mock.$log10(0n, rounding)).to.equal(0n);
+          expect(await this.mock.$log10(1n, rounding)).to.equal(0n);
+          expect(await this.mock.$log10(2n, rounding)).to.equal(1n);
+          expect(await this.mock.$log10(9n, rounding)).to.equal(1n);
+          expect(await this.mock.$log10(10n, rounding)).to.equal(1n);
+          expect(await this.mock.$log10(11n, rounding)).to.equal(2n);
+          expect(await this.mock.$log10(99n, rounding)).to.equal(2n);
+          expect(await this.mock.$log10(100n, rounding)).to.equal(2n);
+          expect(await this.mock.$log10(101n, rounding)).to.equal(3n);
+          expect(await this.mock.$log10(999n, rounding)).to.equal(3n);
+          expect(await this.mock.$log10(1000n, rounding)).to.equal(3n);
+          expect(await this.mock.$log10(1001n, rounding)).to.equal(4n);
+          expect(await this.mock.$log10(ethers.MaxUint256, rounding)).to.equal(78n);
         }
       });
     });
@@ -437,31 +411,31 @@ contract('Math', function () {
     describe('log256', function () {
       it('rounds down', async function () {
         for (const rounding of RoundingDown) {
-          expect(await this.math.$log256('0', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log256('1', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log256('2', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log256('255', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log256('256', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log256('257', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log256('65535', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log256('65536', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log256('65537', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log256(MAX_UINT256, rounding)).to.be.bignumber.equal('31');
+          expect(await this.mock.$log256(0n, rounding)).to.equal(0n);
+          expect(await this.mock.$log256(1n, rounding)).to.equal(0n);
+          expect(await this.mock.$log256(2n, rounding)).to.equal(0n);
+          expect(await this.mock.$log256(255n, rounding)).to.equal(0n);
+          expect(await this.mock.$log256(256n, rounding)).to.equal(1n);
+          expect(await this.mock.$log256(257n, rounding)).to.equal(1n);
+          expect(await this.mock.$log256(65535n, rounding)).to.equal(1n);
+          expect(await this.mock.$log256(65536n, rounding)).to.equal(2n);
+          expect(await this.mock.$log256(65537n, rounding)).to.equal(2n);
+          expect(await this.mock.$log256(ethers.MaxUint256, rounding)).to.equal(31n);
         }
       });
 
       it('rounds up', async function () {
         for (const rounding of RoundingUp) {
-          expect(await this.math.$log256('0', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log256('1', rounding)).to.be.bignumber.equal('0');
-          expect(await this.math.$log256('2', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log256('255', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log256('256', rounding)).to.be.bignumber.equal('1');
-          expect(await this.math.$log256('257', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log256('65535', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log256('65536', rounding)).to.be.bignumber.equal('2');
-          expect(await this.math.$log256('65537', rounding)).to.be.bignumber.equal('3');
-          expect(await this.math.$log256(MAX_UINT256, rounding)).to.be.bignumber.equal('32');
+          expect(await this.mock.$log256(0n, rounding)).to.equal(0n);
+          expect(await this.mock.$log256(1n, rounding)).to.equal(0n);
+          expect(await this.mock.$log256(2n, rounding)).to.equal(1n);
+          expect(await this.mock.$log256(255n, rounding)).to.equal(1n);
+          expect(await this.mock.$log256(256n, rounding)).to.equal(1n);
+          expect(await this.mock.$log256(257n, rounding)).to.equal(2n);
+          expect(await this.mock.$log256(65535n, rounding)).to.equal(2n);
+          expect(await this.mock.$log256(65536n, rounding)).to.equal(2n);
+          expect(await this.mock.$log256(65537n, rounding)).to.equal(3n);
+          expect(await this.mock.$log256(ethers.MaxUint256, rounding)).to.equal(32n);
         }
       });
     });

test/utils/math/SafeCast.test.js

@@ -1,161 +1,148 @@
-const { BN } = require('@openzeppelin/test-helpers');
+const { ethers } = require('hardhat');
 const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
 const { range } = require('../../../scripts/helpers');
-const { expectRevertCustomError } = require('../../helpers/customError');
 
-const SafeCast = artifacts.require('$SafeCast');
+async function fixture() {
+  const mock = await ethers.deployContract('$SafeCast');
+  return { mock };
+}
 
-contract('SafeCast', async function () {
+contract('SafeCast', function () {
   beforeEach(async function () {
-    this.safeCast = await SafeCast.new();
+    Object.assign(this, await loadFixture(fixture));
   });
 
-  function testToUint(bits) {
-    describe(`toUint${bits}`, () => {
-      const maxValue = new BN('2').pow(new BN(bits)).subn(1);
+  for (const bits of range(8, 256, 8).map(ethers.toBigInt)) {
+    const maxValue = 2n ** bits - 1n;
 
+    describe(`toUint${bits}`, () => {
       it('downcasts 0', async function () {
-        expect(await this.safeCast[`$toUint${bits}`](0)).to.be.bignumber.equal('0');
+        expect(await this.mock[`$toUint${bits}`](0n)).is.equal(0n);
       });
 
       it('downcasts 1', async function () {
-        expect(await this.safeCast[`$toUint${bits}`](1)).to.be.bignumber.equal('1');
+        expect(await this.mock[`$toUint${bits}`](1n)).is.equal(1n);
       });
 
       it(`downcasts 2^${bits} - 1 (${maxValue})`, async function () {
-        expect(await this.safeCast[`$toUint${bits}`](maxValue)).to.be.bignumber.equal(maxValue);
+        expect(await this.mock[`$toUint${bits}`](maxValue)).is.equal(maxValue);
       });
 
-      it(`reverts when downcasting 2^${bits} (${maxValue.addn(1)})`, async function () {
-        await expectRevertCustomError(
-          this.safeCast[`$toUint${bits}`](maxValue.addn(1)),
-          `SafeCastOverflowedUintDowncast`,
-          [bits, maxValue.addn(1)],
-        );
+      it(`reverts when downcasting 2^${bits} (${maxValue + 1n})`, async function () {
+        await expect(this.mock[`$toUint${bits}`](maxValue + 1n))
+          .to.be.revertedWithCustomError(this.mock, 'SafeCastOverflowedUintDowncast')
+          .withArgs(bits, maxValue + 1n);
       });
 
-      it(`reverts when downcasting 2^${bits} + 1 (${maxValue.addn(2)})`, async function () {
-        await expectRevertCustomError(
-          this.safeCast[`$toUint${bits}`](maxValue.addn(2)),
-          `SafeCastOverflowedUintDowncast`,
-          [bits, maxValue.addn(2)],
-        );
+      it(`reverts when downcasting 2^${bits} + 1 (${maxValue + 2n})`, async function () {
+        await expect(this.mock[`$toUint${bits}`](maxValue + 2n))
+          .to.be.revertedWithCustomError(this.mock, 'SafeCastOverflowedUintDowncast')
+          .withArgs(bits, maxValue + 2n);
       });
     });
   }
 
-  range(8, 256, 8).forEach(bits => testToUint(bits));
-
   describe('toUint256', () => {
-    const maxInt256 = new BN('2').pow(new BN(255)).subn(1);
-    const minInt256 = new BN('2').pow(new BN(255)).neg();
-
     it('casts 0', async function () {
-      expect(await this.safeCast.$toUint256(0)).to.be.bignumber.equal('0');
+      expect(await this.mock.$toUint256(0n)).is.equal(0n);
     });
 
     it('casts 1', async function () {
-      expect(await this.safeCast.$toUint256(1)).to.be.bignumber.equal('1');
+      expect(await this.mock.$toUint256(1n)).is.equal(1n);
     });
 
-    it(`casts INT256_MAX (${maxInt256})`, async function () {
-      expect(await this.safeCast.$toUint256(maxInt256)).to.be.bignumber.equal(maxInt256);
+    it(`casts INT256_MAX (${ethers.MaxInt256})`, async function () {
+      expect(await this.mock.$toUint256(ethers.MaxInt256)).is.equal(ethers.MaxInt256);
     });
 
     it('reverts when casting -1', async function () {
-      await expectRevertCustomError(this.safeCast.$toUint256(-1), `SafeCastOverflowedIntToUint`, [-1]);
+      await expect(this.mock.$toUint256(-1n))
+        .to.be.revertedWithCustomError(this.mock, 'SafeCastOverflowedIntToUint')
+        .withArgs(-1n);
     });
 
-    it(`reverts when casting INT256_MIN (${minInt256})`, async function () {
-      await expectRevertCustomError(this.safeCast.$toUint256(minInt256), `SafeCastOverflowedIntToUint`, [minInt256]);
+    it(`reverts when casting INT256_MIN (${ethers.MinInt256})`, async function () {
+      await expect(this.mock.$toUint256(ethers.MinInt256))
+        .to.be.revertedWithCustomError(this.mock, 'SafeCastOverflowedIntToUint')
+        .withArgs(ethers.MinInt256);
     });
   });
 
-  function testToInt(bits) {
-    describe(`toInt${bits}`, () => {
-      const minValue = new BN('-2').pow(new BN(bits - 1));
-      const maxValue = new BN('2').pow(new BN(bits - 1)).subn(1);
+  for (const bits of range(8, 256, 8).map(ethers.toBigInt)) {
+    const minValue = -(2n ** (bits - 1n));
+    const maxValue = 2n ** (bits - 1n) - 1n;
 
+    describe(`toInt${bits}`, () => {
       it('downcasts 0', async function () {
-        expect(await this.safeCast[`$toInt${bits}`](0)).to.be.bignumber.equal('0');
+        expect(await this.mock[`$toInt${bits}`](0n)).is.equal(0n);
       });
 
       it('downcasts 1', async function () {
-        expect(await this.safeCast[`$toInt${bits}`](1)).to.be.bignumber.equal('1');
+        expect(await this.mock[`$toInt${bits}`](1n)).is.equal(1n);
       });
 
       it('downcasts -1', async function () {
-        expect(await this.safeCast[`$toInt${bits}`](-1)).to.be.bignumber.equal('-1');
+        expect(await this.mock[`$toInt${bits}`](-1n)).is.equal(-1n);
       });
 
-      it(`downcasts -2^${bits - 1} (${minValue})`, async function () {
-        expect(await this.safeCast[`$toInt${bits}`](minValue)).to.be.bignumber.equal(minValue);
+      it(`downcasts -2^${bits - 1n} (${minValue})`, async function () {
+        expect(await this.mock[`$toInt${bits}`](minValue)).is.equal(minValue);
       });
 
-      it(`downcasts 2^${bits - 1} - 1 (${maxValue})`, async function () {
-        expect(await this.safeCast[`$toInt${bits}`](maxValue)).to.be.bignumber.equal(maxValue);
+      it(`downcasts 2^${bits - 1n} - 1 (${maxValue})`, async function () {
+        expect(await this.mock[`$toInt${bits}`](maxValue)).is.equal(maxValue);
       });
 
-      it(`reverts when downcasting -2^${bits - 1} - 1 (${minValue.subn(1)})`, async function () {
-        await expectRevertCustomError(
-          this.safeCast[`$toInt${bits}`](minValue.subn(1)),
-          `SafeCastOverflowedIntDowncast`,
-          [bits, minValue.subn(1)],
-        );
+      it(`reverts when downcasting -2^${bits - 1n} - 1 (${minValue - 1n})`, async function () {
+        await expect(this.mock[`$toInt${bits}`](minValue - 1n))
+          .to.be.revertedWithCustomError(this.mock, 'SafeCastOverflowedIntDowncast')
+          .withArgs(bits, minValue - 1n);
       });
 
-      it(`reverts when downcasting -2^${bits - 1} - 2 (${minValue.subn(2)})`, async function () {
-        await expectRevertCustomError(
-          this.safeCast[`$toInt${bits}`](minValue.subn(2)),
-          `SafeCastOverflowedIntDowncast`,
-          [bits, minValue.subn(2)],
-        );
+      it(`reverts when downcasting -2^${bits - 1n} - 2 (${minValue - 2n})`, async function () {
+        await expect(this.mock[`$toInt${bits}`](minValue - 2n))
+          .to.be.revertedWithCustomError(this.mock, 'SafeCastOverflowedIntDowncast')
+          .withArgs(bits, minValue - 2n);
       });
 
-      it(`reverts when downcasting 2^${bits - 1} (${maxValue.addn(1)})`, async function () {
-        await expectRevertCustomError(
-          this.safeCast[`$toInt${bits}`](maxValue.addn(1)),
-          `SafeCastOverflowedIntDowncast`,
-          [bits, maxValue.addn(1)],
-        );
+      it(`reverts when downcasting 2^${bits - 1n} (${maxValue + 1n})`, async function () {
+        await expect(this.mock[`$toInt${bits}`](maxValue + 1n))
+          .to.be.revertedWithCustomError(this.mock, 'SafeCastOverflowedIntDowncast')
+          .withArgs(bits, maxValue + 1n);
       });
 
-      it(`reverts when downcasting 2^${bits - 1} + 1 (${maxValue.addn(2)})`, async function () {
-        await expectRevertCustomError(
-          this.safeCast[`$toInt${bits}`](maxValue.addn(2)),
-          `SafeCastOverflowedIntDowncast`,
-          [bits, maxValue.addn(2)],
-        );
+      it(`reverts when downcasting 2^${bits - 1n} + 1 (${maxValue + 2n})`, async function () {
+        await expect(this.mock[`$toInt${bits}`](maxValue + 2n))
+          .to.be.revertedWithCustomError(this.mock, 'SafeCastOverflowedIntDowncast')
+          .withArgs(bits, maxValue + 2n);
       });
     });
   }
 
-  range(8, 256, 8).forEach(bits => testToInt(bits));
-
   describe('toInt256', () => {
-    const maxUint256 = new BN('2').pow(new BN(256)).subn(1);
-    const maxInt256 = new BN('2').pow(new BN(255)).subn(1);
-
     it('casts 0', async function () {
-      expect(await this.safeCast.$toInt256(0)).to.be.bignumber.equal('0');
+      expect(await this.mock.$toInt256(0)).is.equal(0n);
     });
 
     it('casts 1', async function () {
-      expect(await this.safeCast.$toInt256(1)).to.be.bignumber.equal('1');
+      expect(await this.mock.$toInt256(1)).is.equal(1n);
     });
 
-    it(`casts INT256_MAX (${maxInt256})`, async function () {
-      expect(await this.safeCast.$toInt256(maxInt256)).to.be.bignumber.equal(maxInt256);
+    it(`casts INT256_MAX (${ethers.MaxInt256})`, async function () {
+      expect(await this.mock.$toInt256(ethers.MaxInt256)).is.equal(ethers.MaxInt256);
     });
 
-    it(`reverts when casting INT256_MAX + 1 (${maxInt256.addn(1)})`, async function () {
-      await expectRevertCustomError(this.safeCast.$toInt256(maxInt256.addn(1)), 'SafeCastOverflowedUintToInt', [
-        maxInt256.addn(1),
-      ]);
+    it(`reverts when casting INT256_MAX + 1 (${ethers.MaxInt256 + 1n})`, async function () {
+      await expect(this.mock.$toInt256(ethers.MaxInt256 + 1n))
+        .to.be.revertedWithCustomError(this.mock, 'SafeCastOverflowedUintToInt')
+        .withArgs(ethers.MaxInt256 + 1n);
     });
 
-    it(`reverts when casting UINT256_MAX (${maxUint256})`, async function () {
-      await expectRevertCustomError(this.safeCast.$toInt256(maxUint256), 'SafeCastOverflowedUintToInt', [maxUint256]);
+    it(`reverts when casting UINT256_MAX (${ethers.MaxUint256})`, async function () {
+      await expect(this.mock.$toInt256(ethers.MaxUint256))
+        .to.be.revertedWithCustomError(this.mock, 'SafeCastOverflowedUintToInt')
+        .withArgs(ethers.MaxUint256);
     });
   });
 });

test/utils/math/SignedMath.test.js

@@ -1,94 +1,51 @@
-const { BN, constants } = require('@openzeppelin/test-helpers');
+const { ethers } = require('hardhat');
 const { expect } = require('chai');
-const { MIN_INT256, MAX_INT256 } = constants;
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { min, max } = require('../../helpers/math');
 
-const SignedMath = artifacts.require('$SignedMath');
+async function testCommutative(fn, lhs, rhs, expected, ...extra) {
+  expect(await fn(lhs, rhs, ...extra)).to.deep.equal(expected);
+  expect(await fn(rhs, lhs, ...extra)).to.deep.equal(expected);
+}
 
-contract('SignedMath', function () {
-  const min = new BN('-1234');
-  const max = new BN('5678');
+async function fixture() {
+  const mock = await ethers.deployContract('$SignedMath');
+  return { mock };
+}
 
+contract('SignedMath', function () {
   beforeEach(async function () {
-    this.math = await SignedMath.new();
+    Object.assign(this, await loadFixture(fixture));
   });
 
   describe('max', function () {
-    it('is correctly detected in first argument position', async function () {
-      expect(await this.math.$max(max, min)).to.be.bignumber.equal(max);
-    });
-
-    it('is correctly detected in second argument position', async function () {
-      expect(await this.math.$max(min, max)).to.be.bignumber.equal(max);
+    it('is correctly detected in both position', async function () {
+      await testCommutative(this.mock.$max, -1234n, 5678n, max(-1234n, 5678n));
     });
   });
 
   describe('min', function () {
-    it('is correctly detected in first argument position', async function () {
-      expect(await this.math.$min(min, max)).to.be.bignumber.equal(min);
-    });
-
-    it('is correctly detected in second argument position', async function () {
-      expect(await this.math.$min(max, min)).to.be.bignumber.equal(min);
+    it('is correctly detected in both position', async function () {
+      await testCommutative(this.mock.$min, -1234n, 5678n, min(-1234n, 5678n));
     });
   });
 
   describe('average', function () {
-    function bnAverage(a, b) {
-      return a.add(b).divn(2);
-    }
-
     it('is correctly calculated with various input', async function () {
-      const valuesX = [
-        new BN('0'),
-        new BN('3'),
-        new BN('-3'),
-        new BN('4'),
-        new BN('-4'),
-        new BN('57417'),
-        new BN('-57417'),
-        new BN('42304'),
-        new BN('-42304'),
-        MIN_INT256,
-        MAX_INT256,
-      ];
-
-      const valuesY = [
-        new BN('0'),
-        new BN('5'),
-        new BN('-5'),
-        new BN('2'),
-        new BN('-2'),
-        new BN('57417'),
-        new BN('-57417'),
-        new BN('42304'),
-        new BN('-42304'),
-        MIN_INT256,
-        MAX_INT256,
-      ];
-
-      for (const x of valuesX) {
-        for (const y of valuesY) {
-          expect(await this.math.$average(x, y)).to.be.bignumber.equal(
-            bnAverage(x, y),
-            `Bad result for average(${x}, ${y})`,
-          );
+      for (const x of [ethers.MinInt256, -57417n, -42304n, -4n, -3n, 0n, 3n, 4n, 42304n, 57417n, ethers.MaxInt256]) {
+        for (const y of [ethers.MinInt256, -57417n, -42304n, -5n, -2n, 0n, 2n, 5n, 42304n, 57417n, ethers.MaxInt256]) {
+          expect(await this.mock.$average(x, y)).to.equal((x + y) / 2n);
         }
       }
     });
   });
 
   describe('abs', function () {
-    for (const n of [
-      MIN_INT256,
-      MIN_INT256.addn(1),
-      new BN('-1'),
-      new BN('0'),
-      new BN('1'),
-      MAX_INT256.subn(1),
-      MAX_INT256,
-    ]) {
+    const abs = x => (x < 0n ? -x : x);
+
+    for (const n of [ethers.MinInt256, ethers.MinInt256 + 1n, -1n, 0n, 1n, ethers.MaxInt256 - 1n, ethers.MaxInt256]) {
       it(`correctly computes the absolute value of ${n}`, async function () {
-        expect(await this.math.$abs(n)).to.be.bignumber.equal(n.abs());
+        expect(await this.mock.$abs(n)).to.equal(abs(n));
       });
     }
   });

test/utils/types/Time.test.js

@@ -2,7 +2,8 @@ require('@openzeppelin/test-helpers');
 
 const { expect } = require('chai');
 const { clock } = require('../../helpers/time');
-const { product, max } = require('../../helpers/iterate');
+const { product } = require('../../helpers/iterate');
+const { max } = require('../../helpers/math');
 
 const Time = artifacts.require('$Time');