diff --git a/test/utils/Address.test.js b/test/utils/Address.test.js
index 57453abd5..6186d18a7 100644
--- a/test/utils/Address.test.js
+++ b/test/utils/Address.test.js
@@ -1,333 +1,279 @@
-const { balance, constants, ether, expectRevert, send, expectEvent } = require('@openzeppelin/test-helpers');
+const { ethers } = require('hardhat');
 const { expect } = require('chai');
-const { expectRevertCustomError } = require('../helpers/customError');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic');
 
-const Address = artifacts.require('$Address');
-const EtherReceiver = artifacts.require('EtherReceiverMock');
-const CallReceiverMock = artifacts.require('CallReceiverMock');
+const coder = ethers.AbiCoder.defaultAbiCoder();
 
-contract('Address', function (accounts) {
-  const [recipient, other] = accounts;
+async function fixture() {
+  const [recipient, other] = await ethers.getSigners();
 
+  const mock = await ethers.deployContract('$Address');
+  const target = await ethers.deployContract('CallReceiverMock');
+  const targetEther = await ethers.deployContract('EtherReceiverMock');
+
+  return { recipient, other, mock, target, targetEther };
+}
+
+describe('Address', function () {
   beforeEach(async function () {
-    this.mock = await Address.new();
+    Object.assign(this, await loadFixture(fixture));
   });
 
   describe('sendValue', function () {
-    beforeEach(async function () {
-      this.recipientTracker = await balance.tracker(recipient);
-    });
-
-    context('when sender contract has no funds', function () {
+    describe('when sender contract has no funds', function () {
       it('sends 0 wei', async function () {
-        await this.mock.$sendValue(other, 0);
-
-        expect(await this.recipientTracker.delta()).to.be.bignumber.equal('0');
+        await expect(this.mock.$sendValue(this.other, 0)).to.changeEtherBalance(this.recipient, 0);
       });
 
       it('reverts when sending non-zero amounts', async function () {
-        await expectRevertCustomError(this.mock.$sendValue(other, 1), 'AddressInsufficientBalance', [
-          this.mock.address,
-        ]);
+        await expect(this.mock.$sendValue(this.other, 1))
+          .to.be.revertedWithCustomError(this.mock, 'AddressInsufficientBalance')
+          .withArgs(this.mock.target);
       });
     });
 
-    context('when sender contract has funds', function () {
-      const funds = ether('1');
-      beforeEach(async function () {
-        await send.ether(other, this.mock.address, funds);
-      });
+    describe('when sender contract has funds', function () {
+      const funds = ethers.parseEther('1');
 
-      it('sends 0 wei', async function () {
-        await this.mock.$sendValue(recipient, 0);
-        expect(await this.recipientTracker.delta()).to.be.bignumber.equal('0');
+      beforeEach(async function () {
+        await this.other.sendTransaction({ to: this.mock, value: funds });
       });
 
-      it('sends non-zero amounts', async function () {
-        await this.mock.$sendValue(recipient, funds.subn(1));
-        expect(await this.recipientTracker.delta()).to.be.bignumber.equal(funds.subn(1));
-      });
+      describe('with EOA recipient', function () {
+        it('sends 0 wei', async function () {
+          await expect(this.mock.$sendValue(this.recipient, 0)).to.changeEtherBalance(this.recipient.address, 0);
+        });
 
-      it('sends the whole balance', async function () {
-        await this.mock.$sendValue(recipient, funds);
-        expect(await this.recipientTracker.delta()).to.be.bignumber.equal(funds);
-        expect(await balance.current(this.mock.address)).to.be.bignumber.equal('0');
-      });
+        it('sends non-zero amounts', async function () {
+          await expect(this.mock.$sendValue(this.recipient, funds - 1n)).to.changeEtherBalance(
+            this.recipient,
+            funds - 1n,
+          );
+        });
 
-      it('reverts when sending more than the balance', async function () {
-        await expectRevertCustomError(this.mock.$sendValue(recipient, funds.addn(1)), 'AddressInsufficientBalance', [
-          this.mock.address,
-        ]);
-      });
+        it('sends the whole balance', async function () {
+          await expect(this.mock.$sendValue(this.recipient, funds)).to.changeEtherBalance(this.recipient, funds);
+          expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
+        });
 
-      context('with contract recipient', function () {
-        beforeEach(async function () {
-          this.target = await EtherReceiver.new();
+        it('reverts when sending more than the balance', async function () {
+          await expect(this.mock.$sendValue(this.recipient, funds + 1n))
+            .to.be.revertedWithCustomError(this.mock, 'AddressInsufficientBalance')
+            .withArgs(this.mock.target);
         });
+      });
 
+      describe('with contract recipient', function () {
         it('sends funds', async function () {
-          const tracker = await balance.tracker(this.target.address);
-
-          await this.target.setAcceptEther(true);
-          await this.mock.$sendValue(this.target.address, funds);
-
-          expect(await tracker.delta()).to.be.bignumber.equal(funds);
+          await this.targetEther.setAcceptEther(true);
+          await expect(this.mock.$sendValue(this.targetEther, funds)).to.changeEtherBalance(this.targetEther, funds);
         });
 
         it('reverts on recipient revert', async function () {
-          await this.target.setAcceptEther(false);
-          await expectRevertCustomError(this.mock.$sendValue(this.target.address, funds), 'FailedInnerCall', []);
+          await this.targetEther.setAcceptEther(false);
+          await expect(this.mock.$sendValue(this.targetEther, funds)).to.be.revertedWithCustomError(
+            this.mock,
+            'FailedInnerCall',
+          );
         });
       });
     });
   });
 
   describe('functionCall', function () {
-    beforeEach(async function () {
-      this.target = await CallReceiverMock.new();
-    });
-
-    context('with valid contract receiver', function () {
+    describe('with valid contract receiver', function () {
       it('calls the requested function', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
+        const call = this.target.interface.encodeFunctionData('mockFunction');
 
-        const receipt = await this.mock.$functionCall(this.target.address, abiEncodedCall);
-
-        expectEvent(receipt, 'return$functionCall', {
-          ret0: web3.eth.abi.encodeParameters(['string'], ['0x1234']),
-        });
-        await expectEvent.inTransaction(receipt.tx, CallReceiverMock, 'MockFunctionCalled');
+        await expect(this.mock.$functionCall(this.target, call))
+          .to.emit(this.target, 'MockFunctionCalled')
+          .to.emit(this.mock, 'return$functionCall')
+          .withArgs(coder.encode(['string'], ['0x1234']));
       });
 
       it('calls the requested empty return function', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunctionEmptyReturn().encodeABI();
+        const call = this.target.interface.encodeFunctionData('mockFunctionEmptyReturn');
 
-        const receipt = await this.mock.$functionCall(this.target.address, abiEncodedCall);
-
-        await expectEvent.inTransaction(receipt.tx, CallReceiverMock, 'MockFunctionCalled');
+        await expect(this.mock.$functionCall(this.target, call)).to.emit(this.target, 'MockFunctionCalled');
       });
 
       it('reverts when the called function reverts with no reason', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunctionRevertsNoReason().encodeABI();
+        const call = this.target.interface.encodeFunctionData('mockFunctionRevertsNoReason');
 
-        await expectRevertCustomError(
-          this.mock.$functionCall(this.target.address, abiEncodedCall),
+        await expect(this.mock.$functionCall(this.target, call)).to.be.revertedWithCustomError(
+          this.mock,
           'FailedInnerCall',
-          [],
         );
       });
 
       it('reverts when the called function reverts, bubbling up the revert reason', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunctionRevertsReason().encodeABI();
+        const call = this.target.interface.encodeFunctionData('mockFunctionRevertsReason');
 
-        await expectRevert(this.mock.$functionCall(this.target.address, abiEncodedCall), 'CallReceiverMock: reverting');
+        await expect(this.mock.$functionCall(this.target, call)).to.be.revertedWith('CallReceiverMock: reverting');
       });
 
       it('reverts when the called function runs out of gas', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunctionOutOfGas().encodeABI();
+        const call = this.target.interface.encodeFunctionData('mockFunctionOutOfGas');
 
-        await expectRevertCustomError(
-          this.mock.$functionCall(this.target.address, abiEncodedCall, { gas: '120000' }),
+        await expect(this.mock.$functionCall(this.target, call, { gasLimit: 120_000n })).to.be.revertedWithCustomError(
+          this.mock,
           'FailedInnerCall',
-          [],
         );
       });
 
       it('reverts when the called function throws', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunctionThrows().encodeABI();
+        const call = this.target.interface.encodeFunctionData('mockFunctionThrows');
 
-        await expectRevert.unspecified(this.mock.$functionCall(this.target.address, abiEncodedCall));
+        await expect(this.mock.$functionCall(this.target, call)).to.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR);
       });
 
       it('reverts when function does not exist', async function () {
-        const abiEncodedCall = web3.eth.abi.encodeFunctionCall(
-          {
-            name: 'mockFunctionDoesNotExist',
-            type: 'function',
-            inputs: [],
-          },
-          [],
-        );
+        const interface = new ethers.Interface(['function mockFunctionDoesNotExist()']);
+        const call = interface.encodeFunctionData('mockFunctionDoesNotExist');
 
-        await expectRevertCustomError(
-          this.mock.$functionCall(this.target.address, abiEncodedCall),
+        await expect(this.mock.$functionCall(this.target, call)).to.be.revertedWithCustomError(
+          this.mock,
           'FailedInnerCall',
-          [],
         );
       });
     });
 
-    context('with non-contract receiver', function () {
+    describe('with non-contract receiver', function () {
       it('reverts when address is not a contract', async function () {
-        const [recipient] = accounts;
-        const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
+        const call = this.target.interface.encodeFunctionData('mockFunction');
 
-        await expectRevertCustomError(this.mock.$functionCall(recipient, abiEncodedCall), 'AddressEmptyCode', [
-          recipient,
-        ]);
+        await expect(this.mock.$functionCall(this.recipient, call))
+          .to.be.revertedWithCustomError(this.mock, 'AddressEmptyCode')
+          .withArgs(this.recipient.address);
       });
     });
   });
 
   describe('functionCallWithValue', function () {
-    beforeEach(async function () {
-      this.target = await CallReceiverMock.new();
-    });
-
-    context('with zero value', function () {
+    describe('with zero value', function () {
       it('calls the requested function', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
+        const call = this.target.interface.encodeFunctionData('mockFunction');
 
-        const receipt = await this.mock.$functionCallWithValue(this.target.address, abiEncodedCall, 0);
-        expectEvent(receipt, 'return$functionCallWithValue', {
-          ret0: web3.eth.abi.encodeParameters(['string'], ['0x1234']),
-        });
-        await expectEvent.inTransaction(receipt.tx, CallReceiverMock, 'MockFunctionCalled');
+        await expect(this.mock.$functionCallWithValue(this.target, call, 0))
+          .to.emit(this.target, 'MockFunctionCalled')
+          .to.emit(this.mock, 'return$functionCallWithValue')
+          .withArgs(coder.encode(['string'], ['0x1234']));
       });
     });
 
-    context('with non-zero value', function () {
-      const amount = ether('1.2');
+    describe('with non-zero value', function () {
+      const value = ethers.parseEther('1.2');
 
       it('reverts if insufficient sender balance', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
+        const call = this.target.interface.encodeFunctionData('mockFunction');
 
-        await expectRevertCustomError(
-          this.mock.$functionCallWithValue(this.target.address, abiEncodedCall, amount),
-          'AddressInsufficientBalance',
-          [this.mock.address],
-        );
+        await expect(this.mock.$functionCallWithValue(this.target, call, value))
+          .to.be.revertedWithCustomError(this.mock, 'AddressInsufficientBalance')
+          .withArgs(this.mock.target);
       });
 
       it('calls the requested function with existing value', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
+        await this.other.sendTransaction({ to: this.mock, value });
 
-        const tracker = await balance.tracker(this.target.address);
+        const call = this.target.interface.encodeFunctionData('mockFunction');
+        const tx = await this.mock.$functionCallWithValue(this.target, call, value);
 
-        await send.ether(other, this.mock.address, amount);
+        await expect(tx).to.changeEtherBalance(this.target, value);
 
-        const receipt = await this.mock.$functionCallWithValue(this.target.address, abiEncodedCall, amount);
-        expectEvent(receipt, 'return$functionCallWithValue', {
-          ret0: web3.eth.abi.encodeParameters(['string'], ['0x1234']),
-        });
-        await expectEvent.inTransaction(receipt.tx, CallReceiverMock, 'MockFunctionCalled');
-
-        expect(await tracker.delta()).to.be.bignumber.equal(amount);
+        await expect(tx)
+          .to.emit(this.target, 'MockFunctionCalled')
+          .to.emit(this.mock, 'return$functionCallWithValue')
+          .withArgs(coder.encode(['string'], ['0x1234']));
       });
 
       it('calls the requested function with transaction funds', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
-
-        const tracker = await balance.tracker(this.target.address);
+        expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
 
-        expect(await balance.current(this.mock.address)).to.be.bignumber.equal('0');
+        const call = this.target.interface.encodeFunctionData('mockFunction');
+        const tx = await this.mock.connect(this.other).$functionCallWithValue(this.target, call, value, { value });
 
-        const receipt = await this.mock.$functionCallWithValue(this.target.address, abiEncodedCall, amount, {
-          from: other,
-          value: amount,
-        });
-        expectEvent(receipt, 'return$functionCallWithValue', {
-          ret0: web3.eth.abi.encodeParameters(['string'], ['0x1234']),
-        });
-        await expectEvent.inTransaction(receipt.tx, CallReceiverMock, 'MockFunctionCalled');
-
-        expect(await tracker.delta()).to.be.bignumber.equal(amount);
+        await expect(tx).to.changeEtherBalance(this.target, value);
+        await expect(tx)
+          .to.emit(this.target, 'MockFunctionCalled')
+          .to.emit(this.mock, 'return$functionCallWithValue')
+          .withArgs(coder.encode(['string'], ['0x1234']));
       });
 
       it('reverts when calling non-payable functions', async function () {
-        const abiEncodedCall = this.target.contract.methods.mockFunctionNonPayable().encodeABI();
+        await this.other.sendTransaction({ to: this.mock, value });
+
+        const call = this.target.interface.encodeFunctionData('mockFunctionNonPayable');
 
-        await send.ether(other, this.mock.address, amount);
-        await expectRevertCustomError(
-          this.mock.$functionCallWithValue(this.target.address, abiEncodedCall, amount),
+        await expect(this.mock.$functionCallWithValue(this.target, call, value)).to.be.revertedWithCustomError(
+          this.mock,
           'FailedInnerCall',
-          [],
         );
       });
     });
   });
 
   describe('functionStaticCall', function () {
-    beforeEach(async function () {
-      this.target = await CallReceiverMock.new();
-    });
-
     it('calls the requested function', async function () {
-      const abiEncodedCall = this.target.contract.methods.mockStaticFunction().encodeABI();
+      const call = this.target.interface.encodeFunctionData('mockStaticFunction');
 
-      expect(await this.mock.$functionStaticCall(this.target.address, abiEncodedCall)).to.be.equal(
-        web3.eth.abi.encodeParameters(['string'], ['0x1234']),
-      );
+      expect(await this.mock.$functionStaticCall(this.target, call)).to.equal(coder.encode(['string'], ['0x1234']));
     });
 
     it('reverts on a non-static function', async function () {
-      const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
+      const call = this.target.interface.encodeFunctionData('mockFunction');
 
-      await expectRevertCustomError(
-        this.mock.$functionStaticCall(this.target.address, abiEncodedCall),
+      await expect(this.mock.$functionStaticCall(this.target, call)).to.be.revertedWithCustomError(
+        this.mock,
         'FailedInnerCall',
-        [],
       );
     });
 
     it('bubbles up revert reason', async function () {
-      const abiEncodedCall = this.target.contract.methods.mockFunctionRevertsReason().encodeABI();
+      const call = this.target.interface.encodeFunctionData('mockFunctionRevertsReason');
 
-      await expectRevert(
-        this.mock.$functionStaticCall(this.target.address, abiEncodedCall),
-        'CallReceiverMock: reverting',
-      );
+      await expect(this.mock.$functionStaticCall(this.target, call)).to.be.revertedWith('CallReceiverMock: reverting');
     });
 
     it('reverts when address is not a contract', async function () {
-      const [recipient] = accounts;
-      const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
+      const call = this.target.interface.encodeFunctionData('mockFunction');
 
-      await expectRevertCustomError(this.mock.$functionStaticCall(recipient, abiEncodedCall), 'AddressEmptyCode', [
-        recipient,
-      ]);
+      await expect(this.mock.$functionStaticCall(this.recipient, call))
+        .to.be.revertedWithCustomError(this.mock, 'AddressEmptyCode')
+        .withArgs(this.recipient.address);
     });
   });
 
   describe('functionDelegateCall', function () {
-    beforeEach(async function () {
-      this.target = await CallReceiverMock.new();
-    });
-
     it('delegate calls the requested function', async function () {
-      // pseudorandom values
-      const slot = '0x93e4c53af435ddf777c3de84bb9a953a777788500e229a468ea1036496ab66a0';
-      const value = '0x6a465d1c49869f71fb65562bcbd7e08c8044074927f0297127203f2a9924ff5b';
+      const slot = ethers.hexlify(ethers.randomBytes(32));
+      const value = ethers.hexlify(ethers.randomBytes(32));
 
-      const abiEncodedCall = this.target.contract.methods.mockFunctionWritesStorage(slot, value).encodeABI();
+      const call = this.target.interface.encodeFunctionData('mockFunctionWritesStorage', [slot, value]);
 
-      expect(await web3.eth.getStorageAt(this.mock.address, slot)).to.be.equal(constants.ZERO_BYTES32);
+      expect(await ethers.provider.getStorage(this.mock, slot)).to.equal(ethers.ZeroHash);
 
-      expectEvent(
-        await this.mock.$functionDelegateCall(this.target.address, abiEncodedCall),
-        'return$functionDelegateCall',
-        { ret0: web3.eth.abi.encodeParameters(['string'], ['0x1234']) },
-      );
+      await expect(await this.mock.$functionDelegateCall(this.target, call))
+        .to.emit(this.mock, 'return$functionDelegateCall')
+        .withArgs(coder.encode(['string'], ['0x1234']));
 
-      expect(await web3.eth.getStorageAt(this.mock.address, slot)).to.be.equal(value);
+      expect(await ethers.provider.getStorage(this.mock, slot)).to.equal(value);
     });
 
     it('bubbles up revert reason', async function () {
-      const abiEncodedCall = this.target.contract.methods.mockFunctionRevertsReason().encodeABI();
+      const call = this.target.interface.encodeFunctionData('mockFunctionRevertsReason');
 
-      await expectRevert(
-        this.mock.$functionDelegateCall(this.target.address, abiEncodedCall),
+      await expect(this.mock.$functionDelegateCall(this.target, call)).to.be.revertedWith(
         'CallReceiverMock: reverting',
       );
     });
 
     it('reverts when address is not a contract', async function () {
-      const [recipient] = accounts;
-      const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
+      const call = this.target.interface.encodeFunctionData('mockFunction');
 
-      await expectRevertCustomError(this.mock.$functionDelegateCall(recipient, abiEncodedCall), 'AddressEmptyCode', [
-        recipient,
-      ]);
+      await expect(this.mock.$functionDelegateCall(this.recipient, call))
+        .to.be.revertedWithCustomError(this.mock, 'AddressEmptyCode')
+        .withArgs(this.recipient.address);
     });
   });