dexorder

2024-10-17 02:42:28 -04:00
commit 25def69c66
878 changed files with 112489 additions and 0 deletions
--- a/lib_openzeppelin_contracts/test/proxy/utils/Initializable.test.js
+++ b/lib_openzeppelin_contracts/test/proxy/utils/Initializable.test.js
@@ -0,0 +1,216 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { MAX_UINT64 } = require('../../helpers/constants');
+
+describe('Initializable', function () {
+  describe('basic testing without inheritance', function () {
+    beforeEach('deploying', async function () {
+      this.mock = await ethers.deployContract('InitializableMock');
+    });
+
+    describe('before initialize', function () {
+      it('initializer has not run', async function () {
+        expect(await this.mock.initializerRan()).to.be.false;
+      });
+
+      it('_initializing returns false before initialization', async function () {
+        expect(await this.mock.isInitializing()).to.be.false;
+      });
+    });
+
+    describe('after initialize', function () {
+      beforeEach('initializing', async function () {
+        await this.mock.initialize();
+      });
+
+      it('initializer has run', async function () {
+        expect(await this.mock.initializerRan()).to.be.true;
+      });
+
+      it('_initializing returns false after initialization', async function () {
+        expect(await this.mock.isInitializing()).to.be.false;
+      });
+
+      it('initializer does not run again', async function () {
+        await expect(this.mock.initialize()).to.be.revertedWithCustomError(this.mock, 'InvalidInitialization');
+      });
+    });
+
+    describe('nested under an initializer', function () {
+      it('initializer modifier reverts', async function () {
+        await expect(this.mock.initializerNested()).to.be.revertedWithCustomError(this.mock, 'InvalidInitialization');
+      });
+
+      it('onlyInitializing modifier succeeds', async function () {
+        await this.mock.onlyInitializingNested();
+        expect(await this.mock.onlyInitializingRan()).to.be.true;
+      });
+    });
+
+    it('cannot call onlyInitializable function outside the scope of an initializable function', async function () {
+      await expect(this.mock.initializeOnlyInitializing()).to.be.revertedWithCustomError(this.mock, 'NotInitializing');
+    });
+  });
+
+  it('nested initializer can run during construction', async function () {
+    const mock = await ethers.deployContract('ConstructorInitializableMock');
+    expect(await mock.initializerRan()).to.be.true;
+    expect(await mock.onlyInitializingRan()).to.be.true;
+  });
+
+  it('multiple constructor levels can be initializers', async function () {
+    const mock = await ethers.deployContract('ChildConstructorInitializableMock');
+    expect(await mock.initializerRan()).to.be.true;
+    expect(await mock.childInitializerRan()).to.be.true;
+    expect(await mock.onlyInitializingRan()).to.be.true;
+  });
+
+  describe('reinitialization', function () {
+    beforeEach('deploying', async function () {
+      this.mock = await ethers.deployContract('ReinitializerMock');
+    });
+
+    it('can reinitialize', async function () {
+      expect(await this.mock.counter()).to.equal(0n);
+      await this.mock.initialize();
+      expect(await this.mock.counter()).to.equal(1n);
+      await this.mock.reinitialize(2);
+      expect(await this.mock.counter()).to.equal(2n);
+      await this.mock.reinitialize(3);
+      expect(await this.mock.counter()).to.equal(3n);
+    });
+
+    it('can jump multiple steps', async function () {
+      expect(await this.mock.counter()).to.equal(0n);
+      await this.mock.initialize();
+      expect(await this.mock.counter()).to.equal(1n);
+      await this.mock.reinitialize(128);
+      expect(await this.mock.counter()).to.equal(2n);
+    });
+
+    it('cannot nest reinitializers', async function () {
+      expect(await this.mock.counter()).to.equal(0n);
+      await expect(this.mock.nestedReinitialize(2, 2)).to.be.revertedWithCustomError(
+        this.mock,
+        'InvalidInitialization',
+      );
+      await expect(this.mock.nestedReinitialize(2, 3)).to.be.revertedWithCustomError(
+        this.mock,
+        'InvalidInitialization',
+      );
+      await expect(this.mock.nestedReinitialize(3, 2)).to.be.revertedWithCustomError(
+        this.mock,
+        'InvalidInitialization',
+      );
+    });
+
+    it('can chain reinitializers', async function () {
+      expect(await this.mock.counter()).to.equal(0n);
+      await this.mock.chainReinitialize(2, 3);
+      expect(await this.mock.counter()).to.equal(2n);
+    });
+
+    it('_getInitializedVersion returns right version', async function () {
+      await this.mock.initialize();
+      expect(await this.mock.getInitializedVersion()).to.equal(1n);
+      await this.mock.reinitialize(12);
+      expect(await this.mock.getInitializedVersion()).to.equal(12n);
+    });
+
+    describe('contract locking', function () {
+      it('prevents initialization', async function () {
+        await this.mock.disableInitializers();
+        await expect(this.mock.initialize()).to.be.revertedWithCustomError(this.mock, 'InvalidInitialization');
+      });
+
+      it('prevents re-initialization', async function () {
+        await this.mock.disableInitializers();
+        await expect(this.mock.reinitialize(255n)).to.be.revertedWithCustomError(this.mock, 'InvalidInitialization');
+      });
+
+      it('can lock contract after initialization', async function () {
+        await this.mock.initialize();
+        await this.mock.disableInitializers();
+        await expect(this.mock.reinitialize(255n)).to.be.revertedWithCustomError(this.mock, 'InvalidInitialization');
+      });
+    });
+  });
+
+  describe('events', function () {
+    it('constructor initialization emits event', async function () {
+      const mock = await ethers.deployContract('ConstructorInitializableMock');
+      await expect(mock.deploymentTransaction()).to.emit(mock, 'Initialized').withArgs(1n);
+    });
+
+    it('initialization emits event', async function () {
+      const mock = await ethers.deployContract('ReinitializerMock');
+      await expect(mock.initialize()).to.emit(mock, 'Initialized').withArgs(1n);
+    });
+
+    it('reinitialization emits event', async function () {
+      const mock = await ethers.deployContract('ReinitializerMock');
+      await expect(mock.reinitialize(128)).to.emit(mock, 'Initialized').withArgs(128n);
+    });
+
+    it('chained reinitialization emits multiple events', async function () {
+      const mock = await ethers.deployContract('ReinitializerMock');
+
+      await expect(mock.chainReinitialize(2, 3))
+        .to.emit(mock, 'Initialized')
+        .withArgs(2n)
+        .to.emit(mock, 'Initialized')
+        .withArgs(3n);
+    });
+  });
+
+  describe('complex testing with inheritance', function () {
+    const mother = 12n;
+    const gramps = '56';
+    const father = 34n;
+    const child = 78n;
+
+    beforeEach('deploying', async function () {
+      this.mock = await ethers.deployContract('SampleChild');
+      await this.mock.initialize(mother, gramps, father, child);
+    });
+
+    it('initializes human', async function () {
+      expect(await this.mock.isHuman()).to.be.true;
+    });
+
+    it('initializes mother', async function () {
+      expect(await this.mock.mother()).to.equal(mother);
+    });
+
+    it('initializes gramps', async function () {
+      expect(await this.mock.gramps()).to.equal(gramps);
+    });
+
+    it('initializes father', async function () {
+      expect(await this.mock.father()).to.equal(father);
+    });
+
+    it('initializes child', async function () {
+      expect(await this.mock.child()).to.equal(child);
+    });
+  });
+
+  describe('disabling initialization', function () {
+    it('old and new patterns in bad sequence', async function () {
+      const DisableBad1 = await ethers.getContractFactory('DisableBad1');
+      await expect(DisableBad1.deploy()).to.be.revertedWithCustomError(DisableBad1, 'InvalidInitialization');
+
+      const DisableBad2 = await ethers.getContractFactory('DisableBad2');
+      await expect(DisableBad2.deploy()).to.be.revertedWithCustomError(DisableBad2, 'InvalidInitialization');
+    });
+
+    it('old and new patterns in good sequence', async function () {
+      const ok = await ethers.deployContract('DisableOk');
+      await expect(ok.deploymentTransaction())
+        .to.emit(ok, 'Initialized')
+        .withArgs(1n)
+        .to.emit(ok, 'Initialized')
+        .withArgs(MAX_UINT64);
+    });
+  });
+});
--- a/lib_openzeppelin_contracts/test/proxy/utils/UUPSUpgradeable.test.js
+++ b/lib_openzeppelin_contracts/test/proxy/utils/UUPSUpgradeable.test.js
@@ -0,0 +1,120 @@
+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 implInitial = await ethers.deployContract('UUPSUpgradeableMock');
+  const implUpgradeOk = await ethers.deployContract('UUPSUpgradeableMock');
+  const implUpgradeUnsafe = await ethers.deployContract('UUPSUpgradeableUnsafeMock');
+  const implUpgradeNonUUPS = await ethers.deployContract('NonUpgradeableMock');
+  const implUnsupportedUUID = await ethers.deployContract('UUPSUnsupportedProxiableUUID');
+  // Used for testing non ERC1967 compliant proxies (clones are proxies that don't use the ERC1967 implementation slot)
+  const cloneFactory = await ethers.deployContract('$Clones');
+
+  const instance = await ethers
+    .deployContract('ERC1967Proxy', [implInitial, '0x'])
+    .then(proxy => implInitial.attach(proxy.target));
+
+  return {
+    implInitial,
+    implUpgradeOk,
+    implUpgradeUnsafe,
+    implUpgradeNonUUPS,
+    implUnsupportedUUID,
+    cloneFactory,
+    instance,
+  };
+}
+
+describe('UUPSUpgradeable', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  it('has an interface version', async function () {
+    expect(await this.instance.UPGRADE_INTERFACE_VERSION()).to.equal('5.0.0');
+  });
+
+  it('upgrade to upgradeable implementation', async function () {
+    await expect(this.instance.upgradeToAndCall(this.implUpgradeOk, '0x'))
+      .to.emit(this.instance, 'Upgraded')
+      .withArgs(this.implUpgradeOk);
+
+    expect(await getAddressInSlot(this.instance, ImplementationSlot)).to.equal(this.implUpgradeOk);
+  });
+
+  it('upgrade to upgradeable implementation with call', async function () {
+    expect(await this.instance.current()).to.equal(0n);
+
+    await expect(
+      this.instance.upgradeToAndCall(this.implUpgradeOk, this.implUpgradeOk.interface.encodeFunctionData('increment')),
+    )
+      .to.emit(this.instance, 'Upgraded')
+      .withArgs(this.implUpgradeOk);
+
+    expect(await getAddressInSlot(this.instance, ImplementationSlot)).to.equal(this.implUpgradeOk);
+
+    expect(await this.instance.current()).to.equal(1n);
+  });
+
+  it('calling upgradeTo on the implementation reverts', async function () {
+    await expect(this.implInitial.upgradeToAndCall(this.implUpgradeOk, '0x')).to.be.revertedWithCustomError(
+      this.implInitial,
+      'UUPSUnauthorizedCallContext',
+    );
+  });
+
+  it('calling upgradeToAndCall on the implementation reverts', async function () {
+    await expect(
+      this.implInitial.upgradeToAndCall(
+        this.implUpgradeOk,
+        this.implUpgradeOk.interface.encodeFunctionData('increment'),
+      ),
+    ).to.be.revertedWithCustomError(this.implUpgradeOk, 'UUPSUnauthorizedCallContext');
+  });
+
+  it('calling upgradeToAndCall from a contract that is not an ERC1967 proxy (with the right implementation) reverts', async function () {
+    const instance = await this.cloneFactory.$clone
+      .staticCall(this.implUpgradeOk)
+      .then(address => this.implInitial.attach(address));
+    await this.cloneFactory.$clone(this.implUpgradeOk);
+
+    await expect(instance.upgradeToAndCall(this.implUpgradeUnsafe, '0x')).to.be.revertedWithCustomError(
+      instance,
+      'UUPSUnauthorizedCallContext',
+    );
+  });
+
+  it('rejects upgrading to an unsupported UUID', async function () {
+    await expect(this.instance.upgradeToAndCall(this.implUnsupportedUUID, '0x'))
+      .to.be.revertedWithCustomError(this.instance, 'UUPSUnsupportedProxiableUUID')
+      .withArgs(ethers.id('invalid UUID'));
+  });
+
+  it('upgrade to and unsafe upgradeable implementation', async function () {
+    await expect(this.instance.upgradeToAndCall(this.implUpgradeUnsafe, '0x'))
+      .to.emit(this.instance, 'Upgraded')
+      .withArgs(this.implUpgradeUnsafe);
+
+    expect(await getAddressInSlot(this.instance, ImplementationSlot)).to.equal(this.implUpgradeUnsafe);
+  });
+
+  // delegate to a non existing upgradeTo function causes a low level revert
+  it('reject upgrade to non uups implementation', async function () {
+    await expect(this.instance.upgradeToAndCall(this.implUpgradeNonUUPS, '0x'))
+      .to.be.revertedWithCustomError(this.instance, 'ERC1967InvalidImplementation')
+      .withArgs(this.implUpgradeNonUUPS);
+  });
+
+  it('reject proxy address as implementation', async function () {
+    const otherInstance = await ethers
+      .deployContract('ERC1967Proxy', [this.implInitial, '0x'])
+      .then(proxy => this.implInitial.attach(proxy.target));
+
+    await expect(this.instance.upgradeToAndCall(otherInstance, '0x'))
+      .to.be.revertedWithCustomError(this.instance, 'ERC1967InvalidImplementation')
+      .withArgs(otherInstance);
+  });
+});