polkamarkets-js 3.1.11 → 3.3.0

package/lib/openzeppelin-contracts-upgradeable/test/governance/TimelockController.test.js

@@ -1,118 +1,110 @@
-const { BN, constants, expectEvent, expectRevert, time } = require('@openzeppelin/test-helpers');
-const { ZERO_ADDRESS, ZERO_BYTES32 } = constants;
-
+const { ethers } = require('hardhat');
 const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic');
 
-const {
-  shouldSupportInterfaces,
-} = require('../utils/introspection/SupportsInterface.behavior');
-
-const TimelockController = artifacts.require('TimelockController');
-const CallReceiverMock = artifacts.require('CallReceiverMock');
-const Implementation2 = artifacts.require('Implementation2');
-const ERC721Mock = artifacts.require('ERC721Mock');
-const ERC1155Mock = artifacts.require('ERC1155Mock');
+const { GovernorHelper } = require('../helpers/governance');
+const { OperationState } = require('../helpers/enums');
+const time = require('../helpers/time');
 
-const MINDELAY = time.duration.days(1);
+const { shouldSupportInterfaces } = require('../utils/introspection/SupportsInterface.behavior');
 
 const salt = '0x025e7b0be353a74631ad648c667493c0e1cd31caa4cc2d3520fdc171ea0cc726'; // a random value
 
-function genOperation (target, value, data, predecessor, salt) {
-  const id = web3.utils.keccak256(web3.eth.abi.encodeParameters([
-    'address',
-    'uint256',
-    'bytes',
-    'uint256',
-    'bytes32',
-  ], [
-    target,
-    value,
-    data,
-    predecessor,
-    salt,
-  ]));
+const MINDELAY = time.duration.days(1);
+const DEFAULT_ADMIN_ROLE = ethers.ZeroHash;
+const PROPOSER_ROLE = ethers.id('PROPOSER_ROLE');
+const EXECUTOR_ROLE = ethers.id('EXECUTOR_ROLE');
+const CANCELLER_ROLE = ethers.id('CANCELLER_ROLE');
+
+const getAddress = obj => obj.address ?? obj.target ?? obj;
+
+function genOperation(target, value, data, predecessor, salt) {
+  const id = ethers.keccak256(
+    ethers.AbiCoder.defaultAbiCoder().encode(
+      ['address', 'uint256', 'bytes', 'uint256', 'bytes32'],
+      [getAddress(target), value, data, predecessor, salt],
+    ),
+  );
   return { id, target, value, data, predecessor, salt };
 }
 
-function genOperationBatch (targets, values, payloads, predecessor, salt) {
-  const id = web3.utils.keccak256(web3.eth.abi.encodeParameters([
-    'address[]',
-    'uint256[]',
-    'bytes[]',
-    'uint256',
-    'bytes32',
-  ], [
-    targets,
-    values,
-    payloads,
-    predecessor,
-    salt,
-  ]));
+function genOperationBatch(targets, values, payloads, predecessor, salt) {
+  const id = ethers.keccak256(
+    ethers.AbiCoder.defaultAbiCoder().encode(
+      ['address[]', 'uint256[]', 'bytes[]', 'uint256', 'bytes32'],
+      [targets.map(getAddress), values, payloads, predecessor, salt],
+    ),
+  );
   return { id, targets, values, payloads, predecessor, salt };
 }
 
-contract('TimelockController', function (accounts) {
-  const [ , admin, proposer, canceller, executor, other ] = accounts;
-
-  const TIMELOCK_ADMIN_ROLE = web3.utils.soliditySha3('TIMELOCK_ADMIN_ROLE');
-  const PROPOSER_ROLE = web3.utils.soliditySha3('PROPOSER_ROLE');
-  const EXECUTOR_ROLE = web3.utils.soliditySha3('EXECUTOR_ROLE');
-  const CANCELLER_ROLE = web3.utils.soliditySha3('CANCELLER_ROLE');
+async function fixture() {
+  const [admin, proposer, canceller, executor, other] = await ethers.getSigners();
+
+  const mock = await ethers.deployContract('TimelockController', [MINDELAY, [proposer], [executor], admin]);
+  const callreceivermock = await ethers.deployContract('CallReceiverMock');
+  const implementation2 = await ethers.deployContract('Implementation2');
+
+  expect(await mock.hasRole(CANCELLER_ROLE, proposer)).to.be.true;
+  await mock.connect(admin).revokeRole(CANCELLER_ROLE, proposer);
+  await mock.connect(admin).grantRole(CANCELLER_ROLE, canceller);
+
+  return {
+    admin,
+    proposer,
+    canceller,
+    executor,
+    other,
+    mock,
+    callreceivermock,
+    implementation2,
+  };
+}
 
+describe('TimelockController', function () {
   beforeEach(async function () {
-    // Deploy new timelock
-    this.mock = await TimelockController.new(
-      MINDELAY,
-      [ proposer ],
-      [ executor ],
-      admin,
-    );
-
-    expect(await this.mock.hasRole(CANCELLER_ROLE, proposer)).to.be.equal(true);
-    await this.mock.revokeRole(CANCELLER_ROLE, proposer, { from: admin });
-    await this.mock.grantRole(CANCELLER_ROLE, canceller, { from: admin });
-
-    // Mocks
-    this.callreceivermock = await CallReceiverMock.new({ from: admin });
-    this.implementation2 = await Implementation2.new({ from: admin });
+    Object.assign(this, await loadFixture(fixture));
   });
 
-  shouldSupportInterfaces([
-    'ERC1155Receiver',
-  ]);
+  shouldSupportInterfaces(['ERC1155Receiver']);
 
   it('initial state', async function () {
-    expect(await this.mock.getMinDelay()).to.be.bignumber.equal(MINDELAY);
-
-    expect(await this.mock.TIMELOCK_ADMIN_ROLE()).to.be.equal(TIMELOCK_ADMIN_ROLE);
-    expect(await this.mock.PROPOSER_ROLE()).to.be.equal(PROPOSER_ROLE);
-    expect(await this.mock.EXECUTOR_ROLE()).to.be.equal(EXECUTOR_ROLE);
-    expect(await this.mock.CANCELLER_ROLE()).to.be.equal(CANCELLER_ROLE);
-
-    expect(await Promise.all([ PROPOSER_ROLE, CANCELLER_ROLE, EXECUTOR_ROLE ].map(role =>
-      this.mock.hasRole(role, proposer),
-    ))).to.be.deep.equal([ true, false, false ]);
-
-    expect(await Promise.all([ PROPOSER_ROLE, CANCELLER_ROLE, EXECUTOR_ROLE ].map(role =>
-      this.mock.hasRole(role, canceller),
-    ))).to.be.deep.equal([ false, true, false ]);
-
-    expect(await Promise.all([ PROPOSER_ROLE, CANCELLER_ROLE, EXECUTOR_ROLE ].map(role =>
-      this.mock.hasRole(role, executor),
-    ))).to.be.deep.equal([ false, false, true ]);
+    expect(await this.mock.getMinDelay()).to.equal(MINDELAY);
+
+    expect(await this.mock.DEFAULT_ADMIN_ROLE()).to.equal(DEFAULT_ADMIN_ROLE);
+    expect(await this.mock.PROPOSER_ROLE()).to.equal(PROPOSER_ROLE);
+    expect(await this.mock.EXECUTOR_ROLE()).to.equal(EXECUTOR_ROLE);
+    expect(await this.mock.CANCELLER_ROLE()).to.equal(CANCELLER_ROLE);
+
+    expect(
+      await Promise.all(
+        [PROPOSER_ROLE, CANCELLER_ROLE, EXECUTOR_ROLE].map(role => this.mock.hasRole(role, this.proposer)),
+      ),
+    ).to.deep.equal([true, false, false]);
+
+    expect(
+      await Promise.all(
+        [PROPOSER_ROLE, CANCELLER_ROLE, EXECUTOR_ROLE].map(role => this.mock.hasRole(role, this.canceller)),
+      ),
+    ).to.deep.equal([false, true, false]);
+
+    expect(
+      await Promise.all(
+        [PROPOSER_ROLE, CANCELLER_ROLE, EXECUTOR_ROLE].map(role => this.mock.hasRole(role, this.executor)),
+      ),
+    ).to.deep.equal([false, false, true]);
   });
 
   it('optional admin', async function () {
-    const mock = await TimelockController.new(
+    const mock = await ethers.deployContract('TimelockController', [
       MINDELAY,
-      [ proposer ],
-      [ executor ],
-      ZERO_ADDRESS,
-      { from: other },
-    );
-
-    expect(await mock.hasRole(TIMELOCK_ADMIN_ROLE, admin)).to.be.equal(false);
-    expect(await mock.hasRole(TIMELOCK_ADMIN_ROLE, other)).to.be.equal(false);
+      [this.proposer],
+      [this.executor],
+      ethers.ZeroAddress,
+    ]);
+    expect(await mock.hasRole(DEFAULT_ADMIN_ROLE, this.admin)).to.be.false;
+    expect(await mock.hasRole(DEFAULT_ADMIN_ROLE, mock.target)).to.be.true;
   });
 
   describe('methods', function () {
@@ -125,13 +117,15 @@ contract('TimelockController', function (accounts) {
           '0xba41db3be0a9929145cfe480bd0f1f003689104d275ae912099f925df424ef94',
           '0x60d9109846ab510ed75c15f979ae366a8a2ace11d34ba9788c13ac296db50e6e',
         );
-        expect(await this.mock.hashOperation(
-          this.operation.target,
-          this.operation.value,
-          this.operation.data,
-          this.operation.predecessor,
-          this.operation.salt,
-        )).to.be.equal(this.operation.id);
+        expect(
+          await this.mock.hashOperation(
+            this.operation.target,
+            this.operation.value,
+            this.operation.data,
+            this.operation.predecessor,
+            this.operation.salt,
+          ),
+        ).to.equal(this.operation.id);
       });
 
       it('hashOperationBatch', async function () {
@@ -142,13 +136,15 @@ contract('TimelockController', function (accounts) {
           '0xce8f45069cc71d25f71ba05062de1a3974f9849b004de64a70998bca9d29c2e7',
           '0x8952d74c110f72bfe5accdf828c74d53a7dfb71235dfa8a1e8c75d8576b372ff',
         );
-        expect(await this.mock.hashOperationBatch(
-          this.operation.targets,
-          this.operation.values,
-          this.operation.payloads,
-          this.operation.predecessor,
-          this.operation.salt,
-        )).to.be.equal(this.operation.id);
+        expect(
+          await this.mock.hashOperationBatch(
+            this.operation.targets,
+            this.operation.values,
+            this.operation.payloads,
+            this.operation.predecessor,
+            this.operation.salt,
+          ),
+        ).to.equal(this.operation.id);
       });
     });
     describe('simple', function () {
@@ -156,92 +152,119 @@ contract('TimelockController', function (accounts) {
         beforeEach(async function () {
           this.operation = genOperation(
             '0x31754f590B97fD975Eb86938f18Cc304E264D2F2',
-            0,
+            0n,
             '0x3bf92ccc',
-            ZERO_BYTES32,
+            ethers.ZeroHash,
             salt,
           );
         });
 
         it('proposer can schedule', async function () {
-          const receipt = await this.mock.schedule(
-            this.operation.target,
-            this.operation.value,
-            this.operation.data,
-            this.operation.predecessor,
-            this.operation.salt,
-            MINDELAY,
-            { from: proposer },
-          );
-          expectEvent(receipt, 'CallScheduled', {
-            id: this.operation.id,
-            index: web3.utils.toBN(0),
-            target: this.operation.target,
-            value: web3.utils.toBN(this.operation.value),
-            data: this.operation.data,
-            predecessor: this.operation.predecessor,
-            delay: MINDELAY,
-          });
-
-          const block = await web3.eth.getBlock(receipt.receipt.blockHash);
-
-          expect(await this.mock.getTimestamp(this.operation.id))
-            .to.be.bignumber.equal(web3.utils.toBN(block.timestamp).add(MINDELAY));
-        });
-
-        it('prevent overwriting active operation', async function () {
-          await this.mock.schedule(
-            this.operation.target,
-            this.operation.value,
-            this.operation.data,
-            this.operation.predecessor,
-            this.operation.salt,
-            MINDELAY,
-            { from: proposer },
-          );
-
-          await expectRevert(
-            this.mock.schedule(
+          const tx = await this.mock
+            .connect(this.proposer)
+            .schedule(
               this.operation.target,
               this.operation.value,
               this.operation.data,
               this.operation.predecessor,
               this.operation.salt,
               MINDELAY,
-              { from: proposer },
-            ),
-            'TimelockController: operation already scheduled',
-          );
-        });
+            );
 
-        it('prevent non-proposer from committing', async function () {
-          await expectRevert(
-            this.mock.schedule(
+          await expect(tx)
+            .to.emit(this.mock, 'CallScheduled')
+            .withArgs(
+              this.operation.id,
+              0n,
               this.operation.target,
               this.operation.value,
               this.operation.data,
               this.operation.predecessor,
-              this.operation.salt,
               MINDELAY,
-              { from: other },
-            ),
-            `AccessControl: account ${other.toLowerCase()} is missing role ${PROPOSER_ROLE}`,
+            )
+            .to.emit(this.mock, 'CallSalt')
+            .withArgs(this.operation.id, this.operation.salt);
+
+          expect(await this.mock.getTimestamp(this.operation.id)).to.equal(
+            (await time.clockFromReceipt.timestamp(tx)) + MINDELAY,
           );
         });
 
-        it('enforce minimum delay', async function () {
-          await expectRevert(
-            this.mock.schedule(
+        it('prevent overwriting active operation', async function () {
+          await this.mock
+            .connect(this.proposer)
+            .schedule(
               this.operation.target,
               this.operation.value,
               this.operation.data,
               this.operation.predecessor,
               this.operation.salt,
-              MINDELAY - 1,
-              { from: proposer },
-            ),
-            'TimelockController: insufficient delay',
-          );
+              MINDELAY,
+            );
+
+          await expect(
+            this.mock
+              .connect(this.proposer)
+              .schedule(
+                this.operation.target,
+                this.operation.value,
+                this.operation.data,
+                this.operation.predecessor,
+                this.operation.salt,
+                MINDELAY,
+              ),
+          )
+            .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+            .withArgs(this.operation.id, GovernorHelper.proposalStatesToBitMap(OperationState.Unset));
+        });
+
+        it('prevent non-proposer from committing', async function () {
+          await expect(
+            this.mock
+              .connect(this.other)
+              .schedule(
+                this.operation.target,
+                this.operation.value,
+                this.operation.data,
+                this.operation.predecessor,
+                this.operation.salt,
+                MINDELAY,
+              ),
+          )
+            .to.be.revertedWithCustomError(this.mock, 'AccessControlUnauthorizedAccount')
+            .withArgs(this.other, PROPOSER_ROLE);
+        });
+
+        it('enforce minimum delay', async function () {
+          await expect(
+            this.mock
+              .connect(this.proposer)
+              .schedule(
+                this.operation.target,
+                this.operation.value,
+                this.operation.data,
+                this.operation.predecessor,
+                this.operation.salt,
+                MINDELAY - 1n,
+              ),
+          )
+            .to.be.revertedWithCustomError(this.mock, 'TimelockInsufficientDelay')
+            .withArgs(MINDELAY - 1n, MINDELAY);
+        });
+
+        it('schedule operation with salt zero', async function () {
+          await expect(
+            this.mock
+              .connect(this.proposer)
+              .schedule(
+                this.operation.target,
+                this.operation.value,
+                this.operation.data,
+                this.operation.predecessor,
+                ethers.ZeroHash,
+                MINDELAY,
+              ),
+          ).to.not.emit(this.mock, 'CallSalt');
         });
       });
 
@@ -249,107 +272,193 @@ contract('TimelockController', function (accounts) {
         beforeEach(async function () {
           this.operation = genOperation(
             '0xAe22104DCD970750610E6FE15E623468A98b15f7',
-            0,
+            0n,
             '0x13e414de',
-            ZERO_BYTES32,
+            ethers.ZeroHash,
             '0xc1059ed2dc130227aa1d1d539ac94c641306905c020436c636e19e3fab56fc7f',
           );
         });
 
         it('revert if operation is not scheduled', async function () {
-          await expectRevert(
-            this.mock.execute(
-              this.operation.target,
-              this.operation.value,
-              this.operation.data,
-              this.operation.predecessor,
-              this.operation.salt,
-              { from: executor },
-            ),
-            'TimelockController: operation is not ready',
-          );
+          await expect(
+            this.mock
+              .connect(this.executor)
+              .execute(
+                this.operation.target,
+                this.operation.value,
+                this.operation.data,
+                this.operation.predecessor,
+                this.operation.salt,
+              ),
+          )
+            .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+            .withArgs(this.operation.id, GovernorHelper.proposalStatesToBitMap(OperationState.Ready));
         });
 
         describe('with scheduled operation', function () {
           beforeEach(async function () {
-            ({ receipt: this.receipt, logs: this.logs } = await this.mock.schedule(
-              this.operation.target,
-              this.operation.value,
-              this.operation.data,
-              this.operation.predecessor,
-              this.operation.salt,
-              MINDELAY,
-              { from: proposer },
-            ));
-          });
-
-          it('revert if execution comes too early 1/2', async function () {
-            await expectRevert(
-              this.mock.execute(
+            await this.mock
+              .connect(this.proposer)
+              .schedule(
                 this.operation.target,
                 this.operation.value,
                 this.operation.data,
                 this.operation.predecessor,
                 this.operation.salt,
-                { from: executor },
-              ),
-              'TimelockController: operation is not ready',
-            );
+                MINDELAY,
+              );
+          });
+
+          it('revert if execution comes too early 1/2', async function () {
+            await expect(
+              this.mock
+                .connect(this.executor)
+                .execute(
+                  this.operation.target,
+                  this.operation.value,
+                  this.operation.data,
+                  this.operation.predecessor,
+                  this.operation.salt,
+                ),
+            )
+              .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+              .withArgs(this.operation.id, GovernorHelper.proposalStatesToBitMap(OperationState.Ready));
           });
 
           it('revert if execution comes too early 2/2', async function () {
-            const timestamp = await this.mock.getTimestamp(this.operation.id);
-            await time.increaseTo(timestamp - 5); // -1 is too tight, test sometime fails
+            // -1 is too tight, test sometime fails
+            await this.mock.getTimestamp(this.operation.id).then(clock => time.increaseTo.timestamp(clock - 5n));
 
-            await expectRevert(
-              this.mock.execute(
-                this.operation.target,
-                this.operation.value,
-                this.operation.data,
-                this.operation.predecessor,
-                this.operation.salt,
-                { from: executor },
-              ),
-              'TimelockController: operation is not ready',
-            );
+            await expect(
+              this.mock
+                .connect(this.executor)
+                .execute(
+                  this.operation.target,
+                  this.operation.value,
+                  this.operation.data,
+                  this.operation.predecessor,
+                  this.operation.salt,
+                ),
+            )
+              .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+              .withArgs(this.operation.id, GovernorHelper.proposalStatesToBitMap(OperationState.Ready));
           });
 
           describe('on time', function () {
             beforeEach(async function () {
-              const timestamp = await this.mock.getTimestamp(this.operation.id);
-              await time.increaseTo(timestamp);
+              await this.mock.getTimestamp(this.operation.id).then(time.increaseTo.timestamp);
             });
 
             it('executor can reveal', async function () {
-              const receipt = await this.mock.execute(
-                this.operation.target,
-                this.operation.value,
-                this.operation.data,
-                this.operation.predecessor,
-                this.operation.salt,
-                { from: executor },
-              );
-              expectEvent(receipt, 'CallExecuted', {
-                id: this.operation.id,
-                index: web3.utils.toBN(0),
-                target: this.operation.target,
-                value: web3.utils.toBN(this.operation.value),
-                data: this.operation.data,
-              });
+              await expect(
+                this.mock
+                  .connect(this.executor)
+                  .execute(
+                    this.operation.target,
+                    this.operation.value,
+                    this.operation.data,
+                    this.operation.predecessor,
+                    this.operation.salt,
+                  ),
+              )
+                .to.emit(this.mock, 'CallExecuted')
+                .withArgs(this.operation.id, 0n, this.operation.target, this.operation.value, this.operation.data);
             });
 
             it('prevent non-executor from revealing', async function () {
-              await expectRevert(
-                this.mock.execute(
-                  this.operation.target,
-                  this.operation.value,
-                  this.operation.data,
-                  this.operation.predecessor,
-                  this.operation.salt,
-                  { from: other },
-                ),
-                `AccessControl: account ${other.toLowerCase()} is missing role ${EXECUTOR_ROLE}`,
+              await expect(
+                this.mock
+                  .connect(this.other)
+                  .execute(
+                    this.operation.target,
+                    this.operation.value,
+                    this.operation.data,
+                    this.operation.predecessor,
+                    this.operation.salt,
+                  ),
+              )
+                .to.be.revertedWithCustomError(this.mock, 'AccessControlUnauthorizedAccount')
+                .withArgs(this.other, EXECUTOR_ROLE);
+            });
+
+            it('prevents reentrancy execution', async function () {
+              // Create operation
+              const reentrant = await ethers.deployContract('$TimelockReentrant');
+              const reentrantOperation = genOperation(
+                reentrant,
+                0n,
+                reentrant.interface.encodeFunctionData('reenter'),
+                ethers.ZeroHash,
+                salt,
               );
+
+              // Schedule so it can be executed
+              await this.mock
+                .connect(this.proposer)
+                .schedule(
+                  reentrantOperation.target,
+                  reentrantOperation.value,
+                  reentrantOperation.data,
+                  reentrantOperation.predecessor,
+                  reentrantOperation.salt,
+                  MINDELAY,
+                );
+
+              // Advance on time to make the operation executable
+              await this.mock.getTimestamp(reentrantOperation.id).then(time.increaseTo.timestamp);
+
+              // Grant executor role to the reentrant contract
+              await this.mock.connect(this.admin).grantRole(EXECUTOR_ROLE, reentrant);
+
+              // Prepare reenter
+              const data = this.mock.interface.encodeFunctionData('execute', [
+                getAddress(reentrantOperation.target),
+                reentrantOperation.value,
+                reentrantOperation.data,
+                reentrantOperation.predecessor,
+                reentrantOperation.salt,
+              ]);
+              await reentrant.enableRentrancy(this.mock, data);
+
+              // Expect to fail
+              await expect(
+                this.mock
+                  .connect(this.executor)
+                  .execute(
+                    reentrantOperation.target,
+                    reentrantOperation.value,
+                    reentrantOperation.data,
+                    reentrantOperation.predecessor,
+                    reentrantOperation.salt,
+                  ),
+              )
+                .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+                .withArgs(reentrantOperation.id, GovernorHelper.proposalStatesToBitMap(OperationState.Ready));
+
+              // Disable reentrancy
+              await reentrant.disableReentrancy();
+              const nonReentrantOperation = reentrantOperation; // Not anymore
+
+              // Try again successfully
+              await expect(
+                this.mock
+                  .connect(this.executor)
+                  .execute(
+                    nonReentrantOperation.target,
+                    nonReentrantOperation.value,
+                    nonReentrantOperation.data,
+                    nonReentrantOperation.predecessor,
+                    nonReentrantOperation.salt,
+                  ),
+              )
+                .to.emit(this.mock, 'CallExecuted')
+                .withArgs(
+                  nonReentrantOperation.id,
+                  0n,
+                  getAddress(nonReentrantOperation),
+                  nonReentrantOperation.value,
+                  nonReentrantOperation.data,
+                );
             });
           });
         });
@@ -361,124 +470,139 @@ contract('TimelockController', function (accounts) {
         beforeEach(async function () {
           this.operation = genOperationBatch(
             Array(8).fill('0xEd912250835c812D4516BBD80BdaEA1bB63a293C'),
-            Array(8).fill(0),
+            Array(8).fill(0n),
             Array(8).fill('0x2fcb7a88'),
-            ZERO_BYTES32,
+            ethers.ZeroHash,
             '0x6cf9d042ade5de78bed9ffd075eb4b2a4f6b1736932c2dc8af517d6e066f51f5',
           );
         });
 
         it('proposer can schedule', async function () {
-          const receipt = await this.mock.scheduleBatch(
-            this.operation.targets,
-            this.operation.values,
-            this.operation.payloads,
-            this.operation.predecessor,
-            this.operation.salt,
-            MINDELAY,
-            { from: proposer },
-          );
+          const tx = this.mock
+            .connect(this.proposer)
+            .scheduleBatch(
+              this.operation.targets,
+              this.operation.values,
+              this.operation.payloads,
+              this.operation.predecessor,
+              this.operation.salt,
+              MINDELAY,
+            );
           for (const i in this.operation.targets) {
-            expectEvent(receipt, 'CallScheduled', {
-              id: this.operation.id,
-              index: web3.utils.toBN(i),
-              target: this.operation.targets[i],
-              value: web3.utils.toBN(this.operation.values[i]),
-              data: this.operation.payloads[i],
-              predecessor: this.operation.predecessor,
-              delay: MINDELAY,
-            });
+            await expect(tx)
+              .to.emit(this.mock, 'CallScheduled')
+              .withArgs(
+                this.operation.id,
+                i,
+                getAddress(this.operation.targets[i]),
+                this.operation.values[i],
+                this.operation.payloads[i],
+                this.operation.predecessor,
+                MINDELAY,
+              )
+              .to.emit(this.mock, 'CallSalt')
+              .withArgs(this.operation.id, this.operation.salt);
           }
 
-          const block = await web3.eth.getBlock(receipt.receipt.blockHash);
-
-          expect(await this.mock.getTimestamp(this.operation.id))
-            .to.be.bignumber.equal(web3.utils.toBN(block.timestamp).add(MINDELAY));
+          expect(await this.mock.getTimestamp(this.operation.id)).to.equal(
+            (await time.clockFromReceipt.timestamp(tx)) + MINDELAY,
+          );
         });
 
         it('prevent overwriting active operation', async function () {
-          await this.mock.scheduleBatch(
-            this.operation.targets,
-            this.operation.values,
-            this.operation.payloads,
-            this.operation.predecessor,
-            this.operation.salt,
-            MINDELAY,
-            { from: proposer },
-          );
-
-          await expectRevert(
-            this.mock.scheduleBatch(
+          await this.mock
+            .connect(this.proposer)
+            .scheduleBatch(
               this.operation.targets,
               this.operation.values,
               this.operation.payloads,
               this.operation.predecessor,
               this.operation.salt,
               MINDELAY,
-              { from: proposer },
-            ),
-            'TimelockController: operation already scheduled',
-          );
+            );
+
+          await expect(
+            this.mock
+              .connect(this.proposer)
+              .scheduleBatch(
+                this.operation.targets,
+                this.operation.values,
+                this.operation.payloads,
+                this.operation.predecessor,
+                this.operation.salt,
+                MINDELAY,
+              ),
+          )
+            .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+            .withArgs(this.operation.id, GovernorHelper.proposalStatesToBitMap(OperationState.Unset));
         });
 
         it('length of batch parameter must match #1', async function () {
-          await expectRevert(
-            this.mock.scheduleBatch(
-              this.operation.targets,
-              [],
-              this.operation.payloads,
-              this.operation.predecessor,
-              this.operation.salt,
-              MINDELAY,
-              { from: proposer },
-            ),
-            'TimelockController: length mismatch',
-          );
+          await expect(
+            this.mock
+              .connect(this.proposer)
+              .scheduleBatch(
+                this.operation.targets,
+                [],
+                this.operation.payloads,
+                this.operation.predecessor,
+                this.operation.salt,
+                MINDELAY,
+              ),
+          )
+            .to.be.revertedWithCustomError(this.mock, 'TimelockInvalidOperationLength')
+            .withArgs(this.operation.targets.length, this.operation.payloads.length, 0n);
         });
 
         it('length of batch parameter must match #1', async function () {
-          await expectRevert(
-            this.mock.scheduleBatch(
-              this.operation.targets,
-              this.operation.values,
-              [],
-              this.operation.predecessor,
-              this.operation.salt,
-              MINDELAY,
-              { from: proposer },
-            ),
-            'TimelockController: length mismatch',
-          );
+          await expect(
+            this.mock
+              .connect(this.proposer)
+              .scheduleBatch(
+                this.operation.targets,
+                this.operation.values,
+                [],
+                this.operation.predecessor,
+                this.operation.salt,
+                MINDELAY,
+              ),
+          )
+            .to.be.revertedWithCustomError(this.mock, 'TimelockInvalidOperationLength')
+            .withArgs(this.operation.targets.length, 0n, this.operation.payloads.length);
         });
 
         it('prevent non-proposer from committing', async function () {
-          await expectRevert(
-            this.mock.scheduleBatch(
-              this.operation.targets,
-              this.operation.values,
-              this.operation.payloads,
-              this.operation.predecessor,
-              this.operation.salt,
-              MINDELAY,
-              { from: other },
-            ),
-            `AccessControl: account ${other.toLowerCase()} is missing role ${PROPOSER_ROLE}`,
-          );
+          await expect(
+            this.mock
+              .connect(this.other)
+              .scheduleBatch(
+                this.operation.targets,
+                this.operation.values,
+                this.operation.payloads,
+                this.operation.predecessor,
+                this.operation.salt,
+                MINDELAY,
+              ),
+          )
+            .to.be.revertedWithCustomError(this.mock, 'AccessControlUnauthorizedAccount')
+            .withArgs(this.other, PROPOSER_ROLE);
         });
 
         it('enforce minimum delay', async function () {
-          await expectRevert(
-            this.mock.scheduleBatch(
-              this.operation.targets,
-              this.operation.values,
-              this.operation.payloads,
-              this.operation.predecessor,
-              this.operation.salt,
-              MINDELAY - 1,
-              { from: proposer },
-            ),
-            'TimelockController: insufficient delay',
-          );
+          await expect(
+            this.mock
+              .connect(this.proposer)
+              .scheduleBatch(
+                this.operation.targets,
+                this.operation.values,
+                this.operation.payloads,
+                this.operation.predecessor,
+                this.operation.salt,
+                MINDELAY - 1n,
+              ),
+          )
+            .to.be.revertedWithCustomError(this.mock, 'TimelockInsufficientDelay')
+            .withArgs(MINDELAY - 1n, MINDELAY);
         });
       });
 
@@ -486,197 +610,290 @@ contract('TimelockController', function (accounts) {
         beforeEach(async function () {
           this.operation = genOperationBatch(
             Array(8).fill('0x76E53CcEb05131Ef5248553bEBDb8F70536830b1'),
-            Array(8).fill(0),
+            Array(8).fill(0n),
             Array(8).fill('0x58a60f63'),
-            ZERO_BYTES32,
+            ethers.ZeroHash,
             '0x9545eeabc7a7586689191f78a5532443698538e54211b5bd4d7dc0fc0102b5c7',
           );
         });
 
         it('revert if operation is not scheduled', async function () {
-          await expectRevert(
-            this.mock.executeBatch(
-              this.operation.targets,
-              this.operation.values,
-              this.operation.payloads,
-              this.operation.predecessor,
-              this.operation.salt,
-              { from: executor },
-            ),
-            'TimelockController: operation is not ready',
-          );
-        });
-
-        describe('with scheduled operation', function () {
-          beforeEach(async function () {
-            ({ receipt: this.receipt, logs: this.logs } = await this.mock.scheduleBatch(
-              this.operation.targets,
-              this.operation.values,
-              this.operation.payloads,
-              this.operation.predecessor,
-              this.operation.salt,
-              MINDELAY,
-              { from: proposer },
-            ));
-          });
-
-          it('revert if execution comes too early 1/2', async function () {
-            await expectRevert(
-              this.mock.executeBatch(
+          await expect(
+            this.mock
+              .connect(this.executor)
+              .executeBatch(
                 this.operation.targets,
                 this.operation.values,
                 this.operation.payloads,
                 this.operation.predecessor,
                 this.operation.salt,
-                { from: executor },
               ),
-              'TimelockController: operation is not ready',
-            );
-          });
-
-          it('revert if execution comes too early 2/2', async function () {
-            const timestamp = await this.mock.getTimestamp(this.operation.id);
-            await time.increaseTo(timestamp - 5); // -1 is to tight, test sometime fails
-
-            await expectRevert(
-              this.mock.executeBatch(
-                this.operation.targets,
-                this.operation.values,
-                this.operation.payloads,
-                this.operation.predecessor,
-                this.operation.salt,
-                { from: executor },
-              ),
-              'TimelockController: operation is not ready',
-            );
-          });
-
-          describe('on time', function () {
-            beforeEach(async function () {
-              const timestamp = await this.mock.getTimestamp(this.operation.id);
-              await time.increaseTo(timestamp);
-            });
+          )
+            .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+            .withArgs(this.operation.id, GovernorHelper.proposalStatesToBitMap(OperationState.Ready));
+        });
 
-            it('executor can reveal', async function () {
-              const receipt = await this.mock.executeBatch(
+        describe('with scheduled operation', function () {
+          beforeEach(async function () {
+            await this.mock
+              .connect(this.proposer)
+              .scheduleBatch(
                 this.operation.targets,
                 this.operation.values,
                 this.operation.payloads,
                 this.operation.predecessor,
                 this.operation.salt,
-                { from: executor },
+                MINDELAY,
               );
-              for (const i in this.operation.targets) {
-                expectEvent(receipt, 'CallExecuted', {
-                  id: this.operation.id,
-                  index: web3.utils.toBN(i),
-                  target: this.operation.targets[i],
-                  value: web3.utils.toBN(this.operation.values[i]),
-                  data: this.operation.payloads[i],
-                });
-              }
-            });
+          });
 
-            it('prevent non-executor from revealing', async function () {
-              await expectRevert(
-                this.mock.executeBatch(
+          it('revert if execution comes too early 1/2', async function () {
+            await expect(
+              this.mock
+                .connect(this.executor)
+                .executeBatch(
                   this.operation.targets,
                   this.operation.values,
                   this.operation.payloads,
                   this.operation.predecessor,
                   this.operation.salt,
-                  { from: other },
                 ),
-                `AccessControl: account ${other.toLowerCase()} is missing role ${EXECUTOR_ROLE}`,
-              );
-            });
+            )
+              .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+              .withArgs(this.operation.id, GovernorHelper.proposalStatesToBitMap(OperationState.Ready));
+          });
 
-            it('length mismatch #1', async function () {
-              await expectRevert(
-                this.mock.executeBatch(
-                  [],
+          it('revert if execution comes too early 2/2', async function () {
+            // -1 is to tight, test sometime fails
+            await this.mock.getTimestamp(this.operation.id).then(clock => time.increaseTo.timestamp(clock - 5n));
+
+            await expect(
+              this.mock
+                .connect(this.executor)
+                .executeBatch(
+                  this.operation.targets,
                   this.operation.values,
                   this.operation.payloads,
                   this.operation.predecessor,
                   this.operation.salt,
-                  { from: executor },
                 ),
-                'TimelockController: length mismatch',
-              );
+            )
+              .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+              .withArgs(this.operation.id, GovernorHelper.proposalStatesToBitMap(OperationState.Ready));
+          });
+
+          describe('on time', function () {
+            beforeEach(async function () {
+              await this.mock.getTimestamp(this.operation.id).then(time.increaseTo.timestamp);
             });
 
-            it('length mismatch #2', async function () {
-              await expectRevert(
-                this.mock.executeBatch(
+            it('executor can reveal', async function () {
+              const tx = this.mock
+                .connect(this.executor)
+                .executeBatch(
                   this.operation.targets,
-                  [],
+                  this.operation.values,
                   this.operation.payloads,
                   this.operation.predecessor,
                   this.operation.salt,
-                  { from: executor },
-                ),
-                'TimelockController: length mismatch',
-              );
+                );
+              for (const i in this.operation.targets) {
+                await expect(tx)
+                  .to.emit(this.mock, 'CallExecuted')
+                  .withArgs(
+                    this.operation.id,
+                    i,
+                    this.operation.targets[i],
+                    this.operation.values[i],
+                    this.operation.payloads[i],
+                  );
+              }
+            });
+
+            it('prevent non-executor from revealing', async function () {
+              await expect(
+                this.mock
+                  .connect(this.other)
+                  .executeBatch(
+                    this.operation.targets,
+                    this.operation.values,
+                    this.operation.payloads,
+                    this.operation.predecessor,
+                    this.operation.salt,
+                  ),
+              )
+                .to.be.revertedWithCustomError(this.mock, 'AccessControlUnauthorizedAccount')
+                .withArgs(this.other, EXECUTOR_ROLE);
+            });
+
+            it('length mismatch #1', async function () {
+              await expect(
+                this.mock
+                  .connect(this.executor)
+                  .executeBatch(
+                    [],
+                    this.operation.values,
+                    this.operation.payloads,
+                    this.operation.predecessor,
+                    this.operation.salt,
+                  ),
+              )
+                .to.be.revertedWithCustomError(this.mock, 'TimelockInvalidOperationLength')
+                .withArgs(0, this.operation.payloads.length, this.operation.values.length);
+            });
+
+            it('length mismatch #2', async function () {
+              await expect(
+                this.mock
+                  .connect(this.executor)
+                  .executeBatch(
+                    this.operation.targets,
+                    [],
+                    this.operation.payloads,
+                    this.operation.predecessor,
+                    this.operation.salt,
+                  ),
+              )
+                .to.be.revertedWithCustomError(this.mock, 'TimelockInvalidOperationLength')
+                .withArgs(this.operation.targets.length, this.operation.payloads.length, 0n);
             });
 
             it('length mismatch #3', async function () {
-              await expectRevert(
-                this.mock.executeBatch(
-                  this.operation.targets,
-                  this.operation.values,
-                  [],
-                  this.operation.predecessor,
-                  this.operation.salt,
-                  { from: executor },
-                ),
-                'TimelockController: length mismatch',
+              await expect(
+                this.mock
+                  .connect(this.executor)
+                  .executeBatch(
+                    this.operation.targets,
+                    this.operation.values,
+                    [],
+                    this.operation.predecessor,
+                    this.operation.salt,
+                  ),
+              )
+                .to.be.revertedWithCustomError(this.mock, 'TimelockInvalidOperationLength')
+                .withArgs(this.operation.targets.length, 0n, this.operation.values.length);
+            });
+
+            it('prevents reentrancy execution', async function () {
+              // Create operation
+              const reentrant = await ethers.deployContract('$TimelockReentrant');
+              const reentrantBatchOperation = genOperationBatch(
+                [reentrant],
+                [0n],
+                [reentrant.interface.encodeFunctionData('reenter')],
+                ethers.ZeroHash,
+                salt,
               );
+
+              // Schedule so it can be executed
+              await this.mock
+                .connect(this.proposer)
+                .scheduleBatch(
+                  reentrantBatchOperation.targets,
+                  reentrantBatchOperation.values,
+                  reentrantBatchOperation.payloads,
+                  reentrantBatchOperation.predecessor,
+                  reentrantBatchOperation.salt,
+                  MINDELAY,
+                );
+
+              // Advance on time to make the operation executable
+              await this.mock.getTimestamp(reentrantBatchOperation.id).then(time.increaseTo.timestamp);
+
+              // Grant executor role to the reentrant contract
+              await this.mock.connect(this.admin).grantRole(EXECUTOR_ROLE, reentrant);
+
+              // Prepare reenter
+              const data = this.mock.interface.encodeFunctionData('executeBatch', [
+                reentrantBatchOperation.targets.map(getAddress),
+                reentrantBatchOperation.values,
+                reentrantBatchOperation.payloads,
+                reentrantBatchOperation.predecessor,
+                reentrantBatchOperation.salt,
+              ]);
+              await reentrant.enableRentrancy(this.mock, data);
+
+              // Expect to fail
+              await expect(
+                this.mock
+                  .connect(this.executor)
+                  .executeBatch(
+                    reentrantBatchOperation.targets,
+                    reentrantBatchOperation.values,
+                    reentrantBatchOperation.payloads,
+                    reentrantBatchOperation.predecessor,
+                    reentrantBatchOperation.salt,
+                  ),
+              )
+                .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+                .withArgs(reentrantBatchOperation.id, GovernorHelper.proposalStatesToBitMap(OperationState.Ready));
+
+              // Disable reentrancy
+              await reentrant.disableReentrancy();
+              const nonReentrantBatchOperation = reentrantBatchOperation; // Not anymore
+
+              // Try again successfully
+              const tx = this.mock
+                .connect(this.executor)
+                .executeBatch(
+                  nonReentrantBatchOperation.targets,
+                  nonReentrantBatchOperation.values,
+                  nonReentrantBatchOperation.payloads,
+                  nonReentrantBatchOperation.predecessor,
+                  nonReentrantBatchOperation.salt,
+                );
+              for (const i in nonReentrantBatchOperation.targets) {
+                await expect(tx)
+                  .to.emit(this.mock, 'CallExecuted')
+                  .withArgs(
+                    nonReentrantBatchOperation.id,
+                    i,
+                    nonReentrantBatchOperation.targets[i],
+                    nonReentrantBatchOperation.values[i],
+                    nonReentrantBatchOperation.payloads[i],
+                  );
+              }
             });
           });
         });
 
         it('partial execution', async function () {
           const operation = genOperationBatch(
+            [this.callreceivermock, this.callreceivermock, this.callreceivermock],
+            [0n, 0n, 0n],
             [
-              this.callreceivermock.address,
-              this.callreceivermock.address,
-              this.callreceivermock.address,
-            ],
-            [
-              0,
-              0,
-              0,
+              this.callreceivermock.interface.encodeFunctionData('mockFunction'),
+              this.callreceivermock.interface.encodeFunctionData('mockFunctionRevertsNoReason'),
+              this.callreceivermock.interface.encodeFunctionData('mockFunction'),
             ],
-            [
-              this.callreceivermock.contract.methods.mockFunction().encodeABI(),
-              this.callreceivermock.contract.methods.mockFunctionThrows().encodeABI(),
-              this.callreceivermock.contract.methods.mockFunction().encodeABI(),
-            ],
-            ZERO_BYTES32,
+            ethers.ZeroHash,
             '0x8ac04aa0d6d66b8812fb41d39638d37af0a9ab11da507afd65c509f8ed079d3e',
           );
 
-          await this.mock.scheduleBatch(
-            operation.targets,
-            operation.values,
-            operation.payloads,
-            operation.predecessor,
-            operation.salt,
-            MINDELAY,
-            { from: proposer },
-          );
-          await time.increase(MINDELAY);
-          await expectRevert(
-            this.mock.executeBatch(
+          await this.mock
+            .connect(this.proposer)
+            .scheduleBatch(
               operation.targets,
               operation.values,
               operation.payloads,
               operation.predecessor,
               operation.salt,
-              { from: executor },
-            ),
-            'TimelockController: underlying transaction reverted',
-          );
+              MINDELAY,
+            );
+
+          await this.mock.getTimestamp(operation.id).then(time.increaseTo.timestamp);
+
+          await expect(
+            this.mock
+              .connect(this.executor)
+              .executeBatch(
+                operation.targets,
+                operation.values,
+                operation.payloads,
+                operation.predecessor,
+                operation.salt,
+              ),
+          ).to.be.revertedWithCustomError(this.mock, 'FailedCall');
         });
       });
     });
@@ -685,82 +902,78 @@ contract('TimelockController', function (accounts) {
       beforeEach(async function () {
         this.operation = genOperation(
           '0xC6837c44AA376dbe1d2709F13879E040CAb653ca',
-          0,
+          0n,
           '0x296e58dd',
-          ZERO_BYTES32,
+          ethers.ZeroHash,
           '0xa2485763600634800df9fc9646fb2c112cf98649c55f63dd1d9c7d13a64399d9',
         );
-        ({ receipt: this.receipt, logs: this.logs } = await this.mock.schedule(
-          this.operation.target,
-          this.operation.value,
-          this.operation.data,
-          this.operation.predecessor,
-          this.operation.salt,
-          MINDELAY,
-          { from: proposer },
-        ));
+        await this.mock
+          .connect(this.proposer)
+          .schedule(
+            this.operation.target,
+            this.operation.value,
+            this.operation.data,
+            this.operation.predecessor,
+            this.operation.salt,
+            MINDELAY,
+          );
       });
 
       it('canceller can cancel', async function () {
-        const receipt = await this.mock.cancel(this.operation.id, { from: canceller });
-        expectEvent(receipt, 'Cancelled', { id: this.operation.id });
+        await expect(this.mock.connect(this.canceller).cancel(this.operation.id))
+          .to.emit(this.mock, 'Cancelled')
+          .withArgs(this.operation.id);
       });
 
       it('cannot cancel invalid operation', async function () {
-        await expectRevert(
-          this.mock.cancel(constants.ZERO_BYTES32, { from: canceller }),
-          'TimelockController: operation cannot be cancelled',
-        );
+        await expect(this.mock.connect(this.canceller).cancel(ethers.ZeroHash))
+          .to.be.revertedWithCustomError(this.mock, 'TimelockUnexpectedOperationState')
+          .withArgs(
+            ethers.ZeroHash,
+            GovernorHelper.proposalStatesToBitMap([OperationState.Waiting, OperationState.Ready]),
+          );
       });
 
       it('prevent non-canceller from canceling', async function () {
-        await expectRevert(
-          this.mock.cancel(this.operation.id, { from: other }),
-          `AccessControl: account ${other.toLowerCase()} is missing role ${CANCELLER_ROLE}`,
-        );
+        await expect(this.mock.connect(this.other).cancel(this.operation.id))
+          .to.be.revertedWithCustomError(this.mock, 'AccessControlUnauthorizedAccount')
+          .withArgs(this.other, CANCELLER_ROLE);
       });
     });
   });
 
   describe('maintenance', function () {
     it('prevent unauthorized maintenance', async function () {
-      await expectRevert(
-        this.mock.updateDelay(0, { from: other }),
-        'TimelockController: caller must be timelock',
-      );
+      await expect(this.mock.connect(this.other).updateDelay(0n))
+        .to.be.revertedWithCustomError(this.mock, 'TimelockUnauthorizedCaller')
+        .withArgs(this.other);
     });
 
     it('timelock scheduled maintenance', async function () {
       const newDelay = time.duration.hours(6);
       const operation = genOperation(
-        this.mock.address,
-        0,
-        this.mock.contract.methods.updateDelay(newDelay.toString()).encodeABI(),
-        ZERO_BYTES32,
+        this.mock,
+        0n,
+        this.mock.interface.encodeFunctionData('updateDelay', [newDelay]),
+        ethers.ZeroHash,
         '0xf8e775b2c5f4d66fb5c7fa800f35ef518c262b6014b3c0aee6ea21bff157f108',
       );
 
-      await this.mock.schedule(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        MINDELAY,
-        { from: proposer },
-      );
-      await time.increase(MINDELAY);
-      const receipt = await this.mock.execute(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        { from: executor },
-      );
-      expectEvent(receipt, 'MinDelayChange', { newDuration: newDelay.toString(), oldDuration: MINDELAY });
+      await this.mock
+        .connect(this.proposer)
+        .schedule(operation.target, operation.value, operation.data, operation.predecessor, operation.salt, MINDELAY);
+
+      await this.mock.getTimestamp(operation.id).then(time.increaseTo.timestamp);
 
-      expect(await this.mock.getMinDelay()).to.be.bignumber.equal(newDelay);
+      await expect(
+        this.mock
+          .connect(this.executor)
+          .execute(operation.target, operation.value, operation.data, operation.predecessor, operation.salt),
+      )
+        .to.emit(this.mock, 'MinDelayChange')
+        .withArgs(MINDELAY, newDelay);
+
+      expect(await this.mock.getMinDelay()).to.equal(newDelay);
     });
   });
 
@@ -768,70 +981,77 @@ contract('TimelockController', function (accounts) {
     beforeEach(async function () {
       this.operation1 = genOperation(
         '0xdE66bD4c97304200A95aE0AadA32d6d01A867E39',
-        0,
+        0n,
         '0x01dc731a',
-        ZERO_BYTES32,
+        ethers.ZeroHash,
         '0x64e932133c7677402ead2926f86205e2ca4686aebecf5a8077627092b9bb2feb',
       );
       this.operation2 = genOperation(
         '0x3c7944a3F1ee7fc8c5A5134ba7c79D11c3A1FCa3',
-        0,
+        0n,
         '0x8f531849',
         this.operation1.id,
         '0x036e1311cac523f9548e6461e29fb1f8f9196b91910a41711ea22f5de48df07d',
       );
-      await this.mock.schedule(
-        this.operation1.target,
-        this.operation1.value,
-        this.operation1.data,
-        this.operation1.predecessor,
-        this.operation1.salt,
-        MINDELAY,
-        { from: proposer },
-      );
-      await this.mock.schedule(
-        this.operation2.target,
-        this.operation2.value,
-        this.operation2.data,
-        this.operation2.predecessor,
-        this.operation2.salt,
-        MINDELAY,
-        { from: proposer },
-      );
-      await time.increase(MINDELAY);
-    });
-
-    it('cannot execute before dependency', async function () {
-      await expectRevert(
-        this.mock.execute(
+      await this.mock
+        .connect(this.proposer)
+        .schedule(
+          this.operation1.target,
+          this.operation1.value,
+          this.operation1.data,
+          this.operation1.predecessor,
+          this.operation1.salt,
+          MINDELAY,
+        );
+      await this.mock
+        .connect(this.proposer)
+        .schedule(
           this.operation2.target,
           this.operation2.value,
           this.operation2.data,
           this.operation2.predecessor,
           this.operation2.salt,
-          { from: executor },
-        ),
-        'TimelockController: missing dependency',
-      );
+          MINDELAY,
+        );
+
+      await this.mock.getTimestamp(this.operation2.id).then(time.increaseTo.timestamp);
+    });
+
+    it('cannot execute before dependency', async function () {
+      await expect(
+        this.mock
+          .connect(this.executor)
+          .execute(
+            this.operation2.target,
+            this.operation2.value,
+            this.operation2.data,
+            this.operation2.predecessor,
+            this.operation2.salt,
+          ),
+      )
+        .to.be.revertedWithCustomError(this.mock, 'TimelockUnexecutedPredecessor')
+        .withArgs(this.operation1.id);
     });
 
     it('can execute after dependency', async function () {
-      await this.mock.execute(
-        this.operation1.target,
-        this.operation1.value,
-        this.operation1.data,
-        this.operation1.predecessor,
-        this.operation1.salt,
-        { from: executor },
-      );
-      await this.mock.execute(
-        this.operation2.target,
-        this.operation2.value,
-        this.operation2.data,
-        this.operation2.predecessor,
-        this.operation2.salt,
-        { from: executor },
-      );
+      await this.mock
+        .connect(this.executor)
+        .execute(
+          this.operation1.target,
+          this.operation1.value,
+          this.operation1.data,
+          this.operation1.predecessor,
+          this.operation1.salt,
+        );
+      await this.mock
+        .connect(this.executor)
+        .execute(
+          this.operation2.target,
+          this.operation2.value,
+          this.operation2.data,
+          this.operation2.predecessor,
+          this.operation2.salt,
+        );
     });
   });
 
@@ -840,294 +1060,219 @@ contract('TimelockController', function (accounts) {
 
     it('call', async function () {
       const operation = genOperation(
-        this.implementation2.address,
-        0,
-        this.implementation2.contract.methods.setValue(42).encodeABI(),
-        ZERO_BYTES32,
+        this.implementation2,
+        0n,
+        this.implementation2.interface.encodeFunctionData('setValue', [42n]),
+        ethers.ZeroHash,
         '0x8043596363daefc89977b25f9d9b4d06c3910959ef0c4d213557a903e1b555e2',
       );
 
-      await this.mock.schedule(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        MINDELAY,
-        { from: proposer },
-      );
-      await time.increase(MINDELAY);
-      await this.mock.execute(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        { from: executor },
-      );
+      await this.mock
+        .connect(this.proposer)
+        .schedule(operation.target, operation.value, operation.data, operation.predecessor, operation.salt, MINDELAY);
+
+      await this.mock.getTimestamp(operation.id).then(time.increaseTo.timestamp);
+
+      await this.mock
+        .connect(this.executor)
+        .execute(operation.target, operation.value, operation.data, operation.predecessor, operation.salt);
 
-      expect(await this.implementation2.getValue()).to.be.bignumber.equal(web3.utils.toBN(42));
+      expect(await this.implementation2.getValue()).to.equal(42n);
     });
 
     it('call reverting', async function () {
       const operation = genOperation(
-        this.callreceivermock.address,
-        0,
-        this.callreceivermock.contract.methods.mockFunctionRevertsNoReason().encodeABI(),
-        ZERO_BYTES32,
+        this.callreceivermock,
+        0n,
+        this.callreceivermock.interface.encodeFunctionData('mockFunctionRevertsNoReason'),
+        ethers.ZeroHash,
         '0xb1b1b276fdf1a28d1e00537ea73b04d56639128b08063c1a2f70a52e38cba693',
       );
 
-      await this.mock.schedule(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        MINDELAY,
-        { from: proposer },
-      );
-      await time.increase(MINDELAY);
-      await expectRevert(
-        this.mock.execute(
-          operation.target,
-          operation.value,
-          operation.data,
-          operation.predecessor,
-          operation.salt,
-          { from: executor },
-        ),
-        'TimelockController: underlying transaction reverted',
-      );
+      await this.mock
+        .connect(this.proposer)
+        .schedule(operation.target, operation.value, operation.data, operation.predecessor, operation.salt, MINDELAY);
+
+      await this.mock.getTimestamp(operation.id).then(time.increaseTo.timestamp);
+
+      await expect(
+        this.mock
+          .connect(this.executor)
+          .execute(operation.target, operation.value, operation.data, operation.predecessor, operation.salt),
+      ).to.be.revertedWithCustomError(this.mock, 'FailedCall');
     });
 
     it('call throw', async function () {
       const operation = genOperation(
-        this.callreceivermock.address,
-        0,
-        this.callreceivermock.contract.methods.mockFunctionThrows().encodeABI(),
-        ZERO_BYTES32,
+        this.callreceivermock,
+        0n,
+        this.callreceivermock.interface.encodeFunctionData('mockFunctionThrows'),
+        ethers.ZeroHash,
         '0xe5ca79f295fc8327ee8a765fe19afb58f4a0cbc5053642bfdd7e73bc68e0fc67',
       );
 
-      await this.mock.schedule(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        MINDELAY,
-        { from: proposer },
-      );
-      await time.increase(MINDELAY);
-      await expectRevert(
-        this.mock.execute(
-          operation.target,
-          operation.value,
-          operation.data,
-          operation.predecessor,
-          operation.salt,
-          { from: executor },
-        ),
-        'TimelockController: underlying transaction reverted',
-      );
+      await this.mock
+        .connect(this.proposer)
+        .schedule(operation.target, operation.value, operation.data, operation.predecessor, operation.salt, MINDELAY);
+
+      await this.mock.getTimestamp(operation.id).then(time.increaseTo.timestamp);
+
+      // Targeted function reverts with a panic code (0x1) + the timelock bubble the panic code
+      await expect(
+        this.mock
+          .connect(this.executor)
+          .execute(operation.target, operation.value, operation.data, operation.predecessor, operation.salt),
+      ).to.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR);
     });
 
     it('call out of gas', async function () {
       const operation = genOperation(
-        this.callreceivermock.address,
-        0,
-        this.callreceivermock.contract.methods.mockFunctionOutOfGas().encodeABI(),
-        ZERO_BYTES32,
+        this.callreceivermock,
+        0n,
+        this.callreceivermock.interface.encodeFunctionData('mockFunctionOutOfGas'),
+        ethers.ZeroHash,
         '0xf3274ce7c394c5b629d5215723563a744b817e1730cca5587c567099a14578fd',
       );
 
-      await this.mock.schedule(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        MINDELAY,
-        { from: proposer },
-      );
-      await time.increase(MINDELAY);
-      await expectRevert(
-        this.mock.execute(
-          operation.target,
-          operation.value,
-          operation.data,
-          operation.predecessor,
-          operation.salt,
-          { from: executor, gas: '70000' },
-        ),
-        'TimelockController: underlying transaction reverted',
-      );
+      await this.mock
+        .connect(this.proposer)
+        .schedule(operation.target, operation.value, operation.data, operation.predecessor, operation.salt, MINDELAY);
+
+      await this.mock.getTimestamp(operation.id).then(time.increaseTo.timestamp);
+
+      await expect(
+        this.mock
+          .connect(this.executor)
+          .execute(operation.target, operation.value, operation.data, operation.predecessor, operation.salt, {
+            gasLimit: '100000',
+          }),
+      ).to.be.revertedWithCustomError(this.mock, 'FailedCall');
     });
 
     it('call payable with eth', async function () {
       const operation = genOperation(
-        this.callreceivermock.address,
+        this.callreceivermock,
         1,
-        this.callreceivermock.contract.methods.mockFunction().encodeABI(),
-        ZERO_BYTES32,
+        this.callreceivermock.interface.encodeFunctionData('mockFunction'),
+        ethers.ZeroHash,
         '0x5ab73cd33477dcd36c1e05e28362719d0ed59a7b9ff14939de63a43073dc1f44',
       );
 
-      await this.mock.schedule(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        MINDELAY,
-        { from: proposer },
-      );
-      await time.increase(MINDELAY);
-
-      expect(await web3.eth.getBalance(this.mock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
-      expect(await web3.eth.getBalance(this.callreceivermock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
-
-      await this.mock.execute(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        { from: executor, value: 1 },
-      );
+      await this.mock
+        .connect(this.proposer)
+        .schedule(operation.target, operation.value, operation.data, operation.predecessor, operation.salt, MINDELAY);
+
+      await this.mock.getTimestamp(operation.id).then(time.increaseTo.timestamp);
+
+      expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
+      expect(await ethers.provider.getBalance(this.callreceivermock)).to.equal(0n);
+
+      await this.mock
+        .connect(this.executor)
+        .execute(operation.target, operation.value, operation.data, operation.predecessor, operation.salt, {
+          value: 1,
+        });
 
-      expect(await web3.eth.getBalance(this.mock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
-      expect(await web3.eth.getBalance(this.callreceivermock.address)).to.be.bignumber.equal(web3.utils.toBN(1));
+      expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
+      expect(await ethers.provider.getBalance(this.callreceivermock)).to.equal(1n);
     });
 
     it('call nonpayable with eth', async function () {
       const operation = genOperation(
-        this.callreceivermock.address,
+        this.callreceivermock,
         1,
-        this.callreceivermock.contract.methods.mockFunctionNonPayable().encodeABI(),
-        ZERO_BYTES32,
+        this.callreceivermock.interface.encodeFunctionData('mockFunctionNonPayable'),
+        ethers.ZeroHash,
         '0xb78edbd920c7867f187e5aa6294ae5a656cfbf0dea1ccdca3751b740d0f2bdf8',
       );
 
-      await this.mock.schedule(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        MINDELAY,
-        { from: proposer },
-      );
-      await time.increase(MINDELAY);
-
-      expect(await web3.eth.getBalance(this.mock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
-      expect(await web3.eth.getBalance(this.callreceivermock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
-
-      await expectRevert(
-        this.mock.execute(
-          operation.target,
-          operation.value,
-          operation.data,
-          operation.predecessor,
-          operation.salt,
-          { from: executor },
-        ),
-        'TimelockController: underlying transaction reverted',
-      );
+      await this.mock
+        .connect(this.proposer)
+        .schedule(operation.target, operation.value, operation.data, operation.predecessor, operation.salt, MINDELAY);
+
+      await this.mock.getTimestamp(operation.id).then(time.increaseTo.timestamp);
 
-      expect(await web3.eth.getBalance(this.mock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
-      expect(await web3.eth.getBalance(this.callreceivermock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
+      expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
+      expect(await ethers.provider.getBalance(this.callreceivermock)).to.equal(0n);
+
+      await expect(
+        this.mock
+          .connect(this.executor)
+          .execute(operation.target, operation.value, operation.data, operation.predecessor, operation.salt),
+      ).to.be.revertedWithCustomError(this.mock, 'FailedCall');
+
+      expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
+      expect(await ethers.provider.getBalance(this.callreceivermock)).to.equal(0n);
     });
 
     it('call reverting with eth', async function () {
       const operation = genOperation(
-        this.callreceivermock.address,
+        this.callreceivermock,
         1,
-        this.callreceivermock.contract.methods.mockFunctionRevertsNoReason().encodeABI(),
-        ZERO_BYTES32,
+        this.callreceivermock.interface.encodeFunctionData('mockFunctionRevertsNoReason'),
+        ethers.ZeroHash,
         '0xdedb4563ef0095db01d81d3f2decf57cf83e4a72aa792af14c43a792b56f4de6',
       );
 
-      await this.mock.schedule(
-        operation.target,
-        operation.value,
-        operation.data,
-        operation.predecessor,
-        operation.salt,
-        MINDELAY,
-        { from: proposer },
-      );
-      await time.increase(MINDELAY);
-
-      expect(await web3.eth.getBalance(this.mock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
-      expect(await web3.eth.getBalance(this.callreceivermock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
-
-      await expectRevert(
-        this.mock.execute(
-          operation.target,
-          operation.value,
-          operation.data,
-          operation.predecessor,
-          operation.salt,
-          { from: executor },
-        ),
-        'TimelockController: underlying transaction reverted',
-      );
+      await this.mock
+        .connect(this.proposer)
+        .schedule(operation.target, operation.value, operation.data, operation.predecessor, operation.salt, MINDELAY);
+
+      await this.mock.getTimestamp(operation.id).then(time.increaseTo.timestamp);
+
+      expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
+      expect(await ethers.provider.getBalance(this.callreceivermock)).to.equal(0n);
 
-      expect(await web3.eth.getBalance(this.mock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
-      expect(await web3.eth.getBalance(this.callreceivermock.address)).to.be.bignumber.equal(web3.utils.toBN(0));
+      await expect(
+        this.mock
+          .connect(this.executor)
+          .execute(operation.target, operation.value, operation.data, operation.predecessor, operation.salt),
+      ).to.be.revertedWithCustomError(this.mock, 'FailedCall');
+
+      expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
+      expect(await ethers.provider.getBalance(this.callreceivermock)).to.equal(0n);
     });
   });
 
   describe('safe receive', function () {
     describe('ERC721', function () {
-      const name = 'Non Fungible Token';
-      const symbol = 'NFT';
-      const tokenId = new BN(1);
+      const tokenId = 1n;
 
       beforeEach(async function () {
-        this.token = await ERC721Mock.new(name, symbol);
-        await this.token.mint(other, tokenId);
+        this.token = await ethers.deployContract('$ERC721', ['Non Fungible Token', 'NFT']);
+        await this.token.$_mint(this.other, tokenId);
       });
 
       it('can receive an ERC721 safeTransfer', async function () {
-        await this.token.safeTransferFrom(other, this.mock.address, tokenId, { from: other });
+        await this.token.connect(this.other).safeTransferFrom(this.other, this.mock, tokenId);
       });
     });
 
     describe('ERC1155', function () {
-      const uri = 'https://token-cdn-domain/{id}.json';
       const tokenIds = {
-        1: new BN(1000),
-        2: new BN(2000),
-        3: new BN(3000),
+        1: 1000n,
+        2: 2000n,
+        3: 3000n,
       };
 
       beforeEach(async function () {
-        this.token = await ERC1155Mock.new(uri);
-        await this.token.mintBatch(other, Object.keys(tokenIds), Object.values(tokenIds), '0x');
+        this.token = await ethers.deployContract('$ERC1155', ['https://token-cdn-domain/{id}.json']);
+        await this.token.$_mintBatch(this.other, Object.keys(tokenIds), Object.values(tokenIds), '0x');
       });
 
       it('can receive ERC1155 safeTransfer', async function () {
-        await this.token.safeTransferFrom(
-          other,
-          this.mock.address,
-          ...Object.entries(tokenIds)[0], // id + amount
+        await this.token.connect(this.other).safeTransferFrom(
+          this.other,
+          this.mock,
+          ...Object.entries(tokenIds)[0n], // id + amount
           '0x',
-          { from: other },
         );
       });
 
       it('can receive ERC1155 safeBatchTransfer', async function () {
-        await this.token.safeBatchTransferFrom(
-          other,
-          this.mock.address,
-          Object.keys(tokenIds),
-          Object.values(tokenIds),
-          '0x',
-          { from: other },
-        );
+        await this.token
+          .connect(this.other)
+          .safeBatchTransferFrom(this.other, this.mock, Object.keys(tokenIds), Object.values(tokenIds), '0x');
       });
     });
   });