web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/test/proxy/beacon/BeaconProxy.test.js

@@ -0,0 +1,141 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { getAddressInSlot, BeaconSlot } = require('../../helpers/storage');
+
+async function fixture() {
+  const [admin, other] = await ethers.getSigners();
+
+  const v1 = await ethers.deployContract('DummyImplementation');
+  const v2 = await ethers.deployContract('DummyImplementationV2');
+  const factory = await ethers.getContractFactory('BeaconProxy');
+  const beacon = await ethers.deployContract('UpgradeableBeacon', [v1, admin]);
+
+  const newBeaconProxy = (beacon, data, opts = {}) => factory.deploy(beacon, data, opts);
+
+  return { admin, other, factory, beacon, v1, v2, newBeaconProxy };
+}
+
+describe('BeaconProxy', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('bad beacon is not accepted', function () {
+    it('non-contract beacon', async function () {
+      const notBeacon = this.other;
+
+      await expect(this.newBeaconProxy(notBeacon, '0x'))
+        .to.be.revertedWithCustomError(this.factory, 'ERC1967InvalidBeacon')
+        .withArgs(notBeacon);
+    });
+
+    it('non-compliant beacon', async function () {
+      const badBeacon = await ethers.deployContract('BadBeaconNoImpl');
+
+      // BadBeaconNoImpl does not provide `implementation()` and has no fallback.
+      // This causes ERC1967Utils._setBeacon to revert.
+      await expect(this.newBeaconProxy(badBeacon, '0x')).to.be.revertedWithoutReason();
+    });
+
+    it('non-contract implementation', async function () {
+      const badBeacon = await ethers.deployContract('BadBeaconNotContract');
+
+      await expect(this.newBeaconProxy(badBeacon, '0x'))
+        .to.be.revertedWithCustomError(this.factory, 'ERC1967InvalidImplementation')
+        .withArgs(await badBeacon.implementation());
+    });
+  });
+
+  describe('initialization', function () {
+    async function assertInitialized({ value, balance }) {
+      const beaconAddress = await getAddressInSlot(this.proxy, BeaconSlot);
+      expect(beaconAddress).to.equal(this.beacon);
+
+      const dummy = this.v1.attach(this.proxy);
+      expect(await dummy.value()).to.equal(value);
+
+      expect(await ethers.provider.getBalance(this.proxy)).to.equal(balance);
+    }
+
+    it('no initialization', async function () {
+      this.proxy = await this.newBeaconProxy(this.beacon, '0x');
+      await assertInitialized.bind(this)({ value: 0n, balance: 0n });
+    });
+
+    it('non-payable initialization', async function () {
+      const value = 55n;
+      const data = this.v1.interface.encodeFunctionData('initializeNonPayableWithValue', [value]);
+
+      this.proxy = await this.newBeaconProxy(this.beacon, data);
+      await assertInitialized.bind(this)({ value, balance: 0n });
+    });
+
+    it('payable initialization', async function () {
+      const value = 55n;
+      const data = this.v1.interface.encodeFunctionData('initializePayableWithValue', [value]);
+      const balance = 100n;
+
+      this.proxy = await this.newBeaconProxy(this.beacon, data, { value: balance });
+      await assertInitialized.bind(this)({ value, balance });
+    });
+
+    it('reverting initialization due to value', async function () {
+      await expect(this.newBeaconProxy(this.beacon, '0x', { value: 1n })).to.be.revertedWithCustomError(
+        this.factory,
+        'ERC1967NonPayable',
+      );
+    });
+
+    it('reverting initialization function', async function () {
+      const data = this.v1.interface.encodeFunctionData('reverts');
+      await expect(this.newBeaconProxy(this.beacon, data)).to.be.revertedWith('DummyImplementation reverted');
+    });
+  });
+
+  describe('upgrade', function () {
+    it('upgrade a proxy by upgrading its beacon', async function () {
+      const value = 10n;
+      const data = this.v1.interface.encodeFunctionData('initializeNonPayableWithValue', [value]);
+      const proxy = await this.newBeaconProxy(this.beacon, data).then(instance => this.v1.attach(instance));
+
+      // test initial values
+      expect(await proxy.value()).to.equal(value);
+
+      // test initial version
+      expect(await proxy.version()).to.equal('V1');
+
+      // upgrade beacon
+      await this.beacon.connect(this.admin).upgradeTo(this.v2);
+
+      // test upgraded version
+      expect(await proxy.version()).to.equal('V2');
+    });
+
+    it('upgrade 2 proxies by upgrading shared beacon', async function () {
+      const value1 = 10n;
+      const data1 = this.v1.interface.encodeFunctionData('initializeNonPayableWithValue', [value1]);
+      const proxy1 = await this.newBeaconProxy(this.beacon, data1).then(instance => this.v1.attach(instance));
+
+      const value2 = 42n;
+      const data2 = this.v1.interface.encodeFunctionData('initializeNonPayableWithValue', [value2]);
+      const proxy2 = await this.newBeaconProxy(this.beacon, data2).then(instance => this.v1.attach(instance));
+
+      // test initial values
+      expect(await proxy1.value()).to.equal(value1);
+      expect(await proxy2.value()).to.equal(value2);
+
+      // test initial version
+      expect(await proxy1.version()).to.equal('V1');
+      expect(await proxy2.version()).to.equal('V1');
+
+      // upgrade beacon
+      await this.beacon.connect(this.admin).upgradeTo(this.v2);
+
+      // test upgraded version
+      expect(await proxy1.version()).to.equal('V2');
+      expect(await proxy2.version()).to.equal('V2');
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/proxy/beacon/UpgradeableBeacon.test.js

@@ -0,0 +1,55 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+async function fixture() {
+  const [admin, other] = await ethers.getSigners();
+
+  const v1 = await ethers.deployContract('Implementation1');
+  const v2 = await ethers.deployContract('Implementation2');
+  const beacon = await ethers.deployContract('UpgradeableBeacon', [v1, admin]);
+
+  return { admin, other, beacon, v1, v2 };
+}
+
+describe('UpgradeableBeacon', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  it('cannot be created with non-contract implementation', async function () {
+    await expect(ethers.deployContract('UpgradeableBeacon', [this.other, this.admin]))
+      .to.be.revertedWithCustomError(this.beacon, 'BeaconInvalidImplementation')
+      .withArgs(this.other);
+  });
+
+  describe('once deployed', function () {
+    it('emits Upgraded event to the first implementation', async function () {
+      await expect(this.beacon.deploymentTransaction()).to.emit(this.beacon, 'Upgraded').withArgs(this.v1);
+    });
+
+    it('returns implementation', async function () {
+      expect(await this.beacon.implementation()).to.equal(this.v1);
+    });
+
+    it('can be upgraded by the admin', async function () {
+      await expect(this.beacon.connect(this.admin).upgradeTo(this.v2))
+        .to.emit(this.beacon, 'Upgraded')
+        .withArgs(this.v2);
+
+      expect(await this.beacon.implementation()).to.equal(this.v2);
+    });
+
+    it('cannot be upgraded to a non-contract', async function () {
+      await expect(this.beacon.connect(this.admin).upgradeTo(this.other))
+        .to.be.revertedWithCustomError(this.beacon, 'BeaconInvalidImplementation')
+        .withArgs(this.other);
+    });
+
+    it('cannot be upgraded by other account', async function () {
+      await expect(this.beacon.connect(this.other).upgradeTo(this.v2))
+        .to.be.revertedWithCustomError(this.beacon, 'OwnableUnauthorizedAccount')
+        .withArgs(this.other);
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/proxy/transparent/ProxyAdmin.test.js

@@ -0,0 +1,82 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { getAddressInSlot, ImplementationSlot } = require('../../helpers/storage');
+
+async function fixture() {
+  const [admin, other] = await ethers.getSigners();
+
+  const v1 = await ethers.deployContract('DummyImplementation');
+  const v2 = await ethers.deployContract('DummyImplementationV2');
+
+  const proxy = await ethers
+    .deployContract('TransparentUpgradeableProxy', [v1, admin, v1.interface.encodeFunctionData('initializeNonPayable')])
+    .then(instance => ethers.getContractAt('ITransparentUpgradeableProxy', instance));
+
+  const proxyAdmin = await ethers.getContractAt(
+    'ProxyAdmin',
+    ethers.getCreateAddress({ from: proxy.target, nonce: 1n }),
+  );
+
+  return { admin, other, v1, v2, proxy, proxyAdmin };
+}
+
+describe('ProxyAdmin', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  it('has an owner', async function () {
+    expect(await this.proxyAdmin.owner()).to.equal(this.admin);
+  });
+
+  it('has an interface version', async function () {
+    expect(await this.proxyAdmin.UPGRADE_INTERFACE_VERSION()).to.equal('5.0.0');
+  });
+
+  describe('without data', function () {
+    describe('with unauthorized account', function () {
+      it('fails to upgrade', async function () {
+        await expect(this.proxyAdmin.connect(this.other).upgradeAndCall(this.proxy, this.v2, '0x'))
+          .to.be.revertedWithCustomError(this.proxyAdmin, 'OwnableUnauthorizedAccount')
+          .withArgs(this.other);
+      });
+    });
+
+    describe('with authorized account', function () {
+      it('upgrades implementation', async function () {
+        await this.proxyAdmin.connect(this.admin).upgradeAndCall(this.proxy, this.v2, '0x');
+        expect(await getAddressInSlot(this.proxy, ImplementationSlot)).to.equal(this.v2);
+      });
+    });
+  });
+
+  describe('with data', function () {
+    describe('with unauthorized account', function () {
+      it('fails to upgrade', async function () {
+        const data = this.v1.interface.encodeFunctionData('initializeNonPayableWithValue', [1337n]);
+        await expect(this.proxyAdmin.connect(this.other).upgradeAndCall(this.proxy, this.v2, data))
+          .to.be.revertedWithCustomError(this.proxyAdmin, 'OwnableUnauthorizedAccount')
+          .withArgs(this.other);
+      });
+    });
+
+    describe('with authorized account', function () {
+      describe('with invalid callData', function () {
+        it('fails to upgrade', async function () {
+          const data = '0x12345678';
+          await expect(this.proxyAdmin.connect(this.admin).upgradeAndCall(this.proxy, this.v2, data)).to.be.reverted;
+        });
+      });
+
+      describe('with valid callData', function () {
+        it('upgrades implementation', async function () {
+          const data = this.v2.interface.encodeFunctionData('initializeNonPayableWithValue', [1337n]);
+          await this.proxyAdmin.connect(this.admin).upgradeAndCall(this.proxy, this.v2, data);
+          expect(await getAddressInSlot(this.proxy, ImplementationSlot)).to.equal(this.v2);
+        });
+      });
+    });
+  });
+});

package/lib/openzeppelin-contracts/test/proxy/transparent/TransparentUpgradeableProxy.behaviour.js

@@ -0,0 +1,367 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+
+const { impersonate } = require('../../helpers/account');
+const { getAddressInSlot, ImplementationSlot, AdminSlot } = require('../../helpers/storage');
+
+// createProxy, initialOwner, accounts
+module.exports = function shouldBehaveLikeTransparentUpgradeableProxy() {
+  before(async function () {
+    const implementationV0 = await ethers.deployContract('DummyImplementation');
+    const implementationV1 = await ethers.deployContract('DummyImplementation');
+
+    const createProxyWithImpersonatedProxyAdmin = async (logic, initData, opts = undefined) => {
+      const [proxy, tx] = await this.createProxy(logic, initData, opts).then(instance =>
+        Promise.all([ethers.getContractAt('ITransparentUpgradeableProxy', instance), instance.deploymentTransaction()]),
+      );
+
+      const proxyAdmin = await ethers.getContractAt(
+        'ProxyAdmin',
+        ethers.getCreateAddress({ from: proxy.target, nonce: 1n }),
+      );
+      const proxyAdminAsSigner = await proxyAdmin.getAddress().then(impersonate);
+
+      return {
+        instance: logic.attach(proxy.target), // attaching proxy directly works well for everything except for event resolution
+        proxy,
+        proxyAdmin,
+        proxyAdminAsSigner,
+        tx,
+      };
+    };
+
+    Object.assign(this, {
+      implementationV0,
+      implementationV1,
+      createProxyWithImpersonatedProxyAdmin,
+    });
+  });
+
+  beforeEach(async function () {
+    Object.assign(
+      this,
+      await this.createProxyWithImpersonatedProxyAdmin(
+        this.implementationV0,
+        this.implementationV0.interface.encodeFunctionData('initializeNonPayable'),
+      ),
+    );
+  });
+
+  describe('implementation', function () {
+    it('returns the current implementation address', async function () {
+      expect(await getAddressInSlot(this.proxy, ImplementationSlot)).to.equal(this.implementationV0);
+    });
+
+    it('delegates to the implementation', async function () {
+      expect(await this.instance.get()).to.be.true;
+    });
+  });
+
+  describe('proxy admin', function () {
+    it('emits AdminChanged event during construction', async function () {
+      await expect(this.tx).to.emit(this.proxy, 'AdminChanged').withArgs(ethers.ZeroAddress, this.proxyAdmin);
+    });
+
+    it('sets the proxy admin in storage with the correct initial owner', async function () {
+      expect(await getAddressInSlot(this.proxy, AdminSlot)).to.equal(this.proxyAdmin);
+
+      expect(await this.proxyAdmin.owner()).to.equal(this.owner);
+    });
+
+    it('can overwrite the admin by the implementation', async function () {
+      await this.instance.unsafeOverrideAdmin(this.other);
+
+      const ERC1967AdminSlotValue = await getAddressInSlot(this.proxy, AdminSlot);
+      expect(ERC1967AdminSlotValue).to.equal(this.other);
+      expect(ERC1967AdminSlotValue).to.not.equal(this.proxyAdmin);
+
+      // Still allows previous admin to execute admin operations
+      await expect(this.proxy.connect(this.proxyAdminAsSigner).upgradeToAndCall(this.implementationV1, '0x'))
+        .to.emit(this.proxy, 'Upgraded')
+        .withArgs(this.implementationV1);
+    });
+  });
+
+  describe('upgradeToAndCall', function () {
+    describe('without migrations', function () {
+      beforeEach(async function () {
+        this.behavior = await ethers.deployContract('InitializableMock');
+      });
+
+      describe('when the call does not fail', function () {
+        beforeEach(function () {
+          this.initializeData = this.behavior.interface.encodeFunctionData('initializeWithX', [42n]);
+        });
+
+        describe('when the sender is the admin', function () {
+          const value = 10n ** 5n;
+
+          beforeEach(async function () {
+            this.tx = await this.proxy
+              .connect(this.proxyAdminAsSigner)
+              .upgradeToAndCall(this.behavior, this.initializeData, {
+                value,
+              });
+          });
+
+          it('upgrades to the requested implementation', async function () {
+            expect(await getAddressInSlot(this.proxy, ImplementationSlot)).to.equal(this.behavior);
+          });
+
+          it('emits an event', async function () {
+            await expect(this.tx).to.emit(this.proxy, 'Upgraded').withArgs(this.behavior);
+          });
+
+          it('calls the initializer function', async function () {
+            expect(await this.behavior.attach(this.proxy).x()).to.equal(42n);
+          });
+
+          it('sends given value to the proxy', async function () {
+            expect(await ethers.provider.getBalance(this.proxy)).to.equal(value);
+          });
+
+          it('uses the storage of the proxy', async function () {
+            // storage layout should look as follows:
+            //  - 0: Initializable storage ++ initializerRan ++ onlyInitializingRan
+            //  - 1: x
+            expect(await ethers.provider.getStorage(this.proxy, 1n)).to.equal(42n);
+          });
+        });
+
+        describe('when the sender is not the admin', function () {
+          it('reverts', async function () {
+            await expect(this.proxy.connect(this.other).upgradeToAndCall(this.behavior, this.initializeData)).to.be
+              .reverted;
+          });
+        });
+      });
+
+      describe('when the call does fail', function () {
+        beforeEach(function () {
+          this.initializeData = this.behavior.interface.encodeFunctionData('fail');
+        });
+
+        it('reverts', async function () {
+          await expect(this.proxy.connect(this.proxyAdminAsSigner).upgradeToAndCall(this.behavior, this.initializeData))
+            .to.be.reverted;
+        });
+      });
+    });
+
+    describe('with migrations', function () {
+      describe('when the sender is the admin', function () {
+        const value = 10n ** 5n;
+
+        describe('when upgrading to V1', function () {
+          beforeEach(async function () {
+            this.behaviorV1 = await ethers.deployContract('MigratableMockV1');
+            const v1MigrationData = this.behaviorV1.interface.encodeFunctionData('initialize', [42n]);
+
+            this.balancePreviousV1 = await ethers.provider.getBalance(this.proxy);
+            this.tx = await this.proxy
+              .connect(this.proxyAdminAsSigner)
+              .upgradeToAndCall(this.behaviorV1, v1MigrationData, {
+                value,
+              });
+          });
+
+          it('upgrades to the requested version and emits an event', async function () {
+            expect(await getAddressInSlot(this.proxy, ImplementationSlot)).to.equal(this.behaviorV1);
+
+            await expect(this.tx).to.emit(this.proxy, 'Upgraded').withArgs(this.behaviorV1);
+          });
+
+          it("calls the 'initialize' function and sends given value to the proxy", async function () {
+            expect(await this.behaviorV1.attach(this.proxy).x()).to.equal(42n);
+            expect(await ethers.provider.getBalance(this.proxy)).to.equal(this.balancePreviousV1 + value);
+          });
+
+          describe('when upgrading to V2', function () {
+            beforeEach(async function () {
+              this.behaviorV2 = await ethers.deployContract('MigratableMockV2');
+              const v2MigrationData = this.behaviorV2.interface.encodeFunctionData('migrate', [10n, 42n]);
+
+              this.balancePreviousV2 = await ethers.provider.getBalance(this.proxy);
+              this.tx = await this.proxy
+                .connect(this.proxyAdminAsSigner)
+                .upgradeToAndCall(this.behaviorV2, v2MigrationData, {
+                  value,
+                });
+            });
+
+            it('upgrades to the requested version and emits an event', async function () {
+              expect(await getAddressInSlot(this.proxy, ImplementationSlot)).to.equal(this.behaviorV2);
+
+              await expect(this.tx).to.emit(this.proxy, 'Upgraded').withArgs(this.behaviorV2);
+            });
+
+            it("calls the 'migrate' function and sends given value to the proxy", async function () {
+              expect(await this.behaviorV2.attach(this.proxy).x()).to.equal(10n);
+              expect(await this.behaviorV2.attach(this.proxy).y()).to.equal(42n);
+              expect(await ethers.provider.getBalance(this.proxy)).to.equal(this.balancePreviousV2 + value);
+            });
+
+            describe('when upgrading to V3', function () {
+              beforeEach(async function () {
+                this.behaviorV3 = await ethers.deployContract('MigratableMockV3');
+                const v3MigrationData = this.behaviorV3.interface.encodeFunctionData('migrate()');
+
+                this.balancePreviousV3 = await ethers.provider.getBalance(this.proxy);
+                this.tx = await this.proxy
+                  .connect(this.proxyAdminAsSigner)
+                  .upgradeToAndCall(this.behaviorV3, v3MigrationData, {
+                    value,
+                  });
+              });
+
+              it('upgrades to the requested version and emits an event', async function () {
+                expect(await getAddressInSlot(this.proxy, ImplementationSlot)).to.equal(this.behaviorV3);
+
+                await expect(this.tx).to.emit(this.proxy, 'Upgraded').withArgs(this.behaviorV3);
+              });
+
+              it("calls the 'migrate' function and sends given value to the proxy", async function () {
+                expect(await this.behaviorV3.attach(this.proxy).x()).to.equal(42n);
+                expect(await this.behaviorV3.attach(this.proxy).y()).to.equal(10n);
+                expect(await ethers.provider.getBalance(this.proxy)).to.equal(this.balancePreviousV3 + value);
+              });
+            });
+          });
+        });
+      });
+
+      describe('when the sender is not the admin', function () {
+        it('reverts', async function () {
+          const behaviorV1 = await ethers.deployContract('MigratableMockV1');
+          const v1MigrationData = behaviorV1.interface.encodeFunctionData('initialize', [42n]);
+          await expect(this.proxy.connect(this.other).upgradeToAndCall(behaviorV1, v1MigrationData)).to.be.reverted;
+        });
+      });
+    });
+  });
+
+  describe('transparent proxy', function () {
+    beforeEach('creating proxy', async function () {
+      this.clashingImplV0 = await ethers.deployContract('ClashingImplementation');
+      this.clashingImplV1 = await ethers.deployContract('ClashingImplementation');
+
+      Object.assign(
+        this,
+        await this.createProxyWithImpersonatedProxyAdmin(
+          this.clashingImplV0,
+          this.clashingImplV0.interface.encodeFunctionData('delegatedFunction'), // use a pure function with no state change as dummy initializer.
+        ),
+      );
+    });
+
+    it('proxy admin cannot call delegated functions', async function () {
+      const factory = await ethers.getContractFactory('TransparentUpgradeableProxy');
+
+      await expect(this.instance.connect(this.proxyAdminAsSigner).delegatedFunction()).to.be.revertedWithCustomError(
+        factory,
+        'ProxyDeniedAdminAccess',
+      );
+    });
+
+    describe('when function names clash', function () {
+      it('executes the proxy function if the sender is the admin', async function () {
+        await expect(this.proxy.connect(this.proxyAdminAsSigner).upgradeToAndCall(this.clashingImplV1, '0x'))
+          .to.emit(this.proxy, 'Upgraded')
+          .withArgs(this.clashingImplV1);
+      });
+
+      it('delegates the call to implementation when sender is not the admin', async function () {
+        await expect(this.proxy.connect(this.other).upgradeToAndCall(this.clashingImplV1, '0x'))
+          .to.emit(this.instance, 'ClashingImplementationCall')
+          .to.not.emit(this.proxy, 'Upgraded');
+      });
+    });
+  });
+
+  describe('regression', function () {
+    it('should add new function', async function () {
+      const impl1 = await ethers.deployContract('Implementation1');
+      const impl2 = await ethers.deployContract('Implementation2');
+      const { instance, proxy, proxyAdminAsSigner } = await this.createProxyWithImpersonatedProxyAdmin(
+        impl1,
+        impl1.interface.encodeFunctionData('initialize'),
+      );
+
+      await instance.setValue(42n);
+
+      // `getValue` is not available in impl1
+      await expect(impl2.attach(instance).getValue()).to.be.reverted;
+
+      // do upgrade
+      await proxy.connect(proxyAdminAsSigner).upgradeToAndCall(impl2, '0x');
+
+      // `getValue` is available in impl2
+      expect(await impl2.attach(instance).getValue()).to.equal(42n);
+    });
+
+    it('should remove function', async function () {
+      const impl1 = await ethers.deployContract('Implementation1');
+      const impl2 = await ethers.deployContract('Implementation2');
+      const { instance, proxy, proxyAdminAsSigner } = await this.createProxyWithImpersonatedProxyAdmin(
+        impl2,
+        impl2.interface.encodeFunctionData('initialize'),
+      );
+
+      await instance.setValue(42n);
+
+      // `getValue` is available in impl2
+      expect(await impl2.attach(instance).getValue()).to.equal(42n);
+
+      // do downgrade
+      await proxy.connect(proxyAdminAsSigner).upgradeToAndCall(impl1, '0x');
+
+      // `getValue` is not available in impl1
+      await expect(impl2.attach(instance).getValue()).to.be.reverted;
+    });
+
+    it('should change function signature', async function () {
+      const impl1 = await ethers.deployContract('Implementation1');
+      const impl3 = await ethers.deployContract('Implementation3');
+      const { instance, proxy, proxyAdminAsSigner } = await this.createProxyWithImpersonatedProxyAdmin(
+        impl1,
+        impl1.interface.encodeFunctionData('initialize'),
+      );
+
+      await instance.setValue(42n);
+
+      await proxy.connect(proxyAdminAsSigner).upgradeToAndCall(impl3, '0x');
+
+      expect(await impl3.attach(instance).getValue(8n)).to.equal(50n);
+    });
+
+    it('should add fallback function', async function () {
+      const impl1 = await ethers.deployContract('Implementation1');
+      const impl4 = await ethers.deployContract('Implementation4');
+      const { instance, proxy, proxyAdminAsSigner } = await this.createProxyWithImpersonatedProxyAdmin(
+        impl1,
+        impl1.interface.encodeFunctionData('initialize'),
+      );
+
+      await proxy.connect(proxyAdminAsSigner).upgradeToAndCall(impl4, '0x');
+
+      await this.other.sendTransaction({ to: proxy });
+
+      expect(await impl4.attach(instance).getValue()).to.equal(1n);
+    });
+
+    it('should remove fallback function', async function () {
+      const impl2 = await ethers.deployContract('Implementation2');
+      const impl4 = await ethers.deployContract('Implementation4');
+      const { instance, proxy, proxyAdminAsSigner } = await this.createProxyWithImpersonatedProxyAdmin(
+        impl4,
+        impl4.interface.encodeFunctionData('initialize'),
+      );
+
+      await proxy.connect(proxyAdminAsSigner).upgradeToAndCall(impl2, '0x');
+
+      await expect(this.other.sendTransaction({ to: proxy })).to.be.reverted;
+
+      expect(await impl2.attach(instance).getValue()).to.equal(0n);
+    });
+  });
+};

package/lib/openzeppelin-contracts/test/proxy/transparent/TransparentUpgradeableProxy.test.js

@@ -0,0 +1,28 @@
+const { ethers } = require('hardhat');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const shouldBehaveLikeProxy = require('../Proxy.behaviour');
+const shouldBehaveLikeTransparentUpgradeableProxy = require('./TransparentUpgradeableProxy.behaviour');
+
+async function fixture() {
+  const [owner, other, ...accounts] = await ethers.getSigners();
+
+  const implementation = await ethers.deployContract('DummyImplementation');
+
+  const createProxy = function (logic, initData, opts = undefined) {
+    return ethers.deployContract('TransparentUpgradeableProxy', [logic, owner, initData], opts);
+  };
+
+  return { nonContractAddress: owner, owner, other, accounts, implementation, createProxy };
+}
+
+describe('TransparentUpgradeableProxy', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  shouldBehaveLikeProxy();
+
+  // createProxy, owner, otherAccounts
+  shouldBehaveLikeTransparentUpgradeableProxy();
+});