web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/test/utils/StorageSlot.test.js

@@ -0,0 +1,73 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { generators } = require('../helpers/random');
+
+const slot = ethers.id('some.storage.slot');
+const otherSlot = ethers.id('some.other.storage.slot');
+
+const TYPES = [
+  { name: 'Boolean', type: 'bool', value: true, isValueType: true, zero: false },
+  { name: 'Address', type: 'address', value: generators.address(), isValueType: true, zero: generators.address.zero },
+  { name: 'Bytes32', type: 'bytes32', value: generators.bytes32(), isValueType: true, zero: generators.bytes32.zero },
+  { name: 'Uint256', type: 'uint256', value: generators.uint256(), isValueType: true, zero: generators.uint256.zero },
+  { name: 'Int256', type: 'int256', value: generators.int256(), isValueType: true, zero: generators.int256.zero },
+  { name: 'Bytes', type: 'bytes', value: generators.hexBytes(128), isValueType: false, zero: generators.hexBytes.zero },
+  { name: 'String', type: 'string', value: 'lorem ipsum', isValueType: false, zero: '' },
+];
+
+async function fixture() {
+  return { mock: await ethers.deployContract('StorageSlotMock') };
+}
+
+describe('StorageSlot', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  for (const { name, type, value, zero } of TYPES) {
+    describe(`${type} storage slot`, function () {
+      it('set', async function () {
+        await this.mock.getFunction(`set${name}Slot`)(slot, value);
+      });
+
+      describe('get', function () {
+        beforeEach(async function () {
+          await this.mock.getFunction(`set${name}Slot`)(slot, value);
+        });
+
+        it('from right slot', async function () {
+          expect(await this.mock.getFunction(`get${name}Slot`)(slot)).to.equal(value);
+        });
+
+        it('from other slot', async function () {
+          expect(await this.mock.getFunction(`get${name}Slot`)(otherSlot)).to.equal(zero);
+        });
+      });
+    });
+  }
+
+  for (const { name, type, value, zero } of TYPES.filter(type => !type.isValueType)) {
+    describe(`${type} storage pointer`, function () {
+      it('set', async function () {
+        await this.mock.getFunction(`set${name}Storage`)(slot, value);
+      });
+
+      describe('get', function () {
+        beforeEach(async function () {
+          await this.mock.getFunction(`set${name}Storage`)(slot, value);
+        });
+
+        it('from right slot', async function () {
+          expect(await this.mock.getFunction(`${type}Map`)(slot)).to.equal(value);
+          expect(await this.mock.getFunction(`get${name}Storage`)(slot)).to.equal(value);
+        });
+
+        it('from other slot', async function () {
+          expect(await this.mock.getFunction(`${type}Map`)(otherSlot)).to.equal(zero);
+          expect(await this.mock.getFunction(`get${name}Storage`)(otherSlot)).to.equal(zero);
+        });
+      });
+    });
+  }
+});

package/lib/openzeppelin-contracts/test/utils/Strings.t.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+
+contract StringsTest is Test {
+    using Strings for *;
+
+    function testParse(uint256 value) external pure {
+        assertEq(value, value.toString().parseUint());
+    }
+
+    function testParseSigned(int256 value) external pure {
+        assertEq(value, value.toStringSigned().parseInt());
+    }
+
+    function testParseHex(uint256 value) external pure {
+        assertEq(value, value.toHexString().parseHexUint());
+    }
+
+    function testParseChecksumHex(address value) external pure {
+        assertEq(value, value.toChecksumHexString().parseAddress());
+    }
+
+    function testTryParseHexUintExtendedEnd(string memory random) external pure {
+        uint256 length = bytes(random).length;
+        assembly ("memory-safe") {
+            mstore(add(add(random, 0x20), length), 0x3030303030303030303030303030303030303030303030303030303030303030)
+        }
+
+        (bool success, ) = random.tryParseHexUint(1, length + 1);
+        assertFalse(success);
+    }
+
+    function testTryParseAddressExtendedEnd(address random, uint256 begin) external pure {
+        begin = bound(begin, 3, 43);
+        string memory input = random.toHexString();
+        uint256 length = bytes(input).length;
+
+        assembly ("memory-safe") {
+            mstore(add(add(input, 0x20), length), 0x3030303030303030303030303030303030303030303030303030303030303030)
+        }
+
+        (bool success, ) = input.tryParseAddress(begin, begin + 40);
+        assertFalse(success);
+    }
+}

package/lib/openzeppelin-contracts/test/utils/Strings.test.js

@@ -0,0 +1,360 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic');
+
+async function fixture() {
+  const mock = await ethers.deployContract('$Strings');
+  return { mock };
+}
+
+describe('Strings', function () {
+  before(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('toString', function () {
+    const values = [
+      0n,
+      7n,
+      10n,
+      99n,
+      100n,
+      101n,
+      123n,
+      4132n,
+      12345n,
+      1234567n,
+      1234567890n,
+      123456789012345n,
+      12345678901234567890n,
+      123456789012345678901234567890n,
+      1234567890123456789012345678901234567890n,
+      12345678901234567890123456789012345678901234567890n,
+      123456789012345678901234567890123456789012345678901234567890n,
+      1234567890123456789012345678901234567890123456789012345678901234567890n,
+    ];
+
+    describe('uint256', function () {
+      it('converts MAX_UINT256', async function () {
+        const value = ethers.MaxUint256;
+        expect(await this.mock.$toString(value)).to.equal(value.toString(10));
+        expect(await this.mock.$parseUint(value.toString(10))).to.equal(value);
+        expect(await this.mock.$tryParseUint(value.toString(10))).to.deep.equal([true, value]);
+      });
+
+      for (const value of values) {
+        it(`converts ${value}`, async function () {
+          expect(await this.mock.$toString(value)).to.equal(value.toString(10));
+          expect(await this.mock.$parseUint(value.toString(10))).to.equal(value);
+          expect(await this.mock.$tryParseUint(value.toString(10))).to.deep.equal([true, value]);
+        });
+      }
+    });
+
+    describe('int256', function () {
+      it('converts MAX_INT256', async function () {
+        const value = ethers.MaxInt256;
+        expect(await this.mock.$toStringSigned(value)).to.equal(value.toString(10));
+        expect(await this.mock.$parseInt(value.toString(10))).to.equal(value);
+        expect(await this.mock.$tryParseInt(value.toString(10))).to.deep.equal([true, value]);
+      });
+
+      it('converts MIN_INT256', async function () {
+        const value = ethers.MinInt256;
+        expect(await this.mock.$toStringSigned(value)).to.equal(value.toString(10));
+        expect(await this.mock.$parseInt(value.toString(10))).to.equal(value);
+        expect(await this.mock.$tryParseInt(value.toString(10))).to.deep.equal([true, value]);
+      });
+
+      for (const value of values) {
+        it(`convert ${value}`, async function () {
+          expect(await this.mock.$toStringSigned(value)).to.equal(value.toString(10));
+          expect(await this.mock.$parseInt(value.toString(10))).to.equal(value);
+          expect(await this.mock.$tryParseInt(value.toString(10))).to.deep.equal([true, value]);
+        });
+
+        it(`convert negative ${value}`, async function () {
+          const negated = -value;
+          expect(await this.mock.$toStringSigned(negated)).to.equal(negated.toString(10));
+          expect(await this.mock.$parseInt(negated.toString(10))).to.equal(negated);
+          expect(await this.mock.$tryParseInt(negated.toString(10))).to.deep.equal([true, negated]);
+        });
+      }
+    });
+  });
+
+  describe('toHexString', function () {
+    it('converts 0', async function () {
+      const value = 0n;
+      const string = ethers.toBeHex(value); // 0x00
+
+      expect(await this.mock.getFunction('$toHexString(uint256)')(value)).to.equal(string);
+      expect(await this.mock.$parseHexUint(string)).to.equal(value);
+      expect(await this.mock.$parseHexUint(string.replace(/0x/, ''))).to.equal(value);
+      expect(await this.mock.$tryParseHexUint(string)).to.deep.equal([true, value]);
+      expect(await this.mock.$tryParseHexUint(string.replace(/0x/, ''))).to.deep.equal([true, value]);
+    });
+
+    it('converts a positive number', async function () {
+      const value = 0x4132n;
+      const string = ethers.toBeHex(value);
+
+      expect(await this.mock.getFunction('$toHexString(uint256)')(value)).to.equal(string);
+      expect(await this.mock.$parseHexUint(string)).to.equal(value);
+      expect(await this.mock.$parseHexUint(string.replace(/0x/, ''))).to.equal(value);
+      expect(await this.mock.$tryParseHexUint(string)).to.deep.equal([true, value]);
+      expect(await this.mock.$tryParseHexUint(string.replace(/0x/, ''))).to.deep.equal([true, value]);
+    });
+
+    it('converts MAX_UINT256', async function () {
+      const value = ethers.MaxUint256;
+      const string = ethers.toBeHex(value);
+
+      expect(await this.mock.getFunction('$toHexString(uint256)')(value)).to.equal(string);
+      expect(await this.mock.$parseHexUint(string)).to.equal(value);
+      expect(await this.mock.$parseHexUint(string.replace(/0x/, ''))).to.equal(value);
+      expect(await this.mock.$tryParseHexUint(string)).to.deep.equal([true, value]);
+      expect(await this.mock.$tryParseHexUint(string.replace(/0x/, ''))).to.deep.equal([true, value]);
+    });
+  });
+
+  describe('toHexString fixed', function () {
+    it('converts a positive number (long)', async function () {
+      expect(await this.mock.getFunction('$toHexString(uint256,uint256)')(0x4132n, 32n)).to.equal(
+        '0x0000000000000000000000000000000000000000000000000000000000004132',
+      );
+    });
+
+    it('converts a positive number (short)', async function () {
+      const length = 1n;
+      await expect(this.mock.getFunction('$toHexString(uint256,uint256)')(0x4132n, length))
+        .to.be.revertedWithCustomError(this.mock, 'StringsInsufficientHexLength')
+        .withArgs(0x4132, length);
+    });
+
+    it('converts MAX_UINT256', async function () {
+      expect(await this.mock.getFunction('$toHexString(uint256,uint256)')(ethers.MaxUint256, 32n)).to.equal(
+        ethers.toBeHex(ethers.MaxUint256),
+      );
+    });
+  });
+
+  describe('addresses', function () {
+    const addresses = [
+      '0xa9036907dccae6a1e0033479b12e837e5cf5a02f', // Random address
+      '0x0000e0ca771e21bd00057f54a68c30d400000000', // Leading and trailing zeros
+      // EIP-55 reference
+      '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed',
+      '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
+      '0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB',
+      '0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb',
+      '0xfb6916095ca1df60bb79ce92ce3ea74c37c5d359',
+      '0x52908400098527886E0F7030069857D2E4169EE7',
+      '0x8617E340B3D01FA5F11F306F4090FD50E238070D',
+      '0xde709f2102306220921060314715629080e2fb77',
+      '0x27b1fdb04752bbc536007a920d24acb045561c26',
+      '0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed',
+      '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
+      '0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB',
+      '0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb',
+    ];
+
+    describe('toHexString', function () {
+      for (const addr of addresses) {
+        it(`converts ${addr}`, async function () {
+          expect(await this.mock.getFunction('$toHexString(address)')(addr)).to.equal(addr.toLowerCase());
+        });
+      }
+    });
+
+    describe('toChecksumHexString', function () {
+      for (const addr of addresses) {
+        it(`converts ${addr}`, async function () {
+          expect(await this.mock.$toChecksumHexString(addr)).to.equal(ethers.getAddress(addr));
+        });
+      }
+    });
+
+    describe('parseAddress', function () {
+      for (const addr of addresses) {
+        it(`converts ${addr}`, async function () {
+          expect(await this.mock.$parseAddress(addr)).to.equal(ethers.getAddress(addr));
+          expect(await this.mock.$tryParseAddress(addr)).to.deep.equal([true, ethers.getAddress(addr)]);
+        });
+      }
+    });
+  });
+
+  describe('bytes', function () {
+    describe('toHexString', function () {
+      for (const length of [0, 17, 20, 32, 42, 64, 512]) {
+        const input = ethers.hexlify(ethers.randomBytes(length));
+        it(`hexlify buffer of length ${length}`, async function () {
+          expect(await this.mock.getFunction('$toHexString(bytes)')(input)).to.equal(input);
+        });
+      }
+    });
+  });
+
+  describe('equal', function () {
+    it('compares two empty strings', async function () {
+      expect(await this.mock.$equal('', '')).to.be.true;
+    });
+
+    it('compares two equal strings', async function () {
+      expect(await this.mock.$equal('a', 'a')).to.be.true;
+    });
+
+    it('compares two different strings', async function () {
+      expect(await this.mock.$equal('a', 'b')).to.be.false;
+    });
+
+    it('compares two different strings of different lengths', async function () {
+      expect(await this.mock.$equal('a', 'aa')).to.be.false;
+      expect(await this.mock.$equal('aa', 'a')).to.be.false;
+    });
+
+    it('compares two different large strings', async function () {
+      const str1 = 'a'.repeat(201);
+      const str2 = 'a'.repeat(200) + 'b';
+      expect(await this.mock.$equal(str1, str2)).to.be.false;
+    });
+
+    it('compares two equal large strings', async function () {
+      const str1 = 'a'.repeat(201);
+      const str2 = 'a'.repeat(201);
+      expect(await this.mock.$equal(str1, str2)).to.be.true;
+    });
+  });
+
+  describe('Edge cases: invalid parsing', function () {
+    it('parseUint overflow', async function () {
+      await expect(this.mock.$parseUint((ethers.MaxUint256 + 1n).toString(10))).to.be.revertedWithPanic(
+        PANIC_CODES.ARITHMETIC_OVERFLOW,
+      );
+      await expect(this.mock.$tryParseUint((ethers.MaxUint256 + 1n).toString(10))).to.be.revertedWithPanic(
+        PANIC_CODES.ARITHMETIC_OVERFLOW,
+      );
+    });
+
+    it('parseUint invalid character', async function () {
+      await expect(this.mock.$parseUint('0x1')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseUint('1f')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseUint('-10')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseUint('1.0')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseUint('1 000')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      expect(await this.mock.$tryParseUint('0x1')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseUint('1f')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseUint('-10')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseUint('1.0')).deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseUint('1 000')).deep.equal([false, 0n]);
+    });
+
+    it('parseUint invalid range', async function () {
+      expect(this.mock.$parseUint('12', 3, 2)).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      expect(await this.mock.$tryParseUint('12', 3, 2)).to.deep.equal([false, 0n]);
+    });
+
+    it('parseInt overflow', async function () {
+      await expect(this.mock.$parseInt((ethers.MaxUint256 + 1n).toString(10))).to.be.revertedWithPanic(
+        PANIC_CODES.ARITHMETIC_OVERFLOW,
+      );
+      await expect(this.mock.$parseInt((-ethers.MaxUint256 - 1n).toString(10))).to.be.revertedWithPanic(
+        PANIC_CODES.ARITHMETIC_OVERFLOW,
+      );
+      await expect(this.mock.$tryParseInt((ethers.MaxUint256 + 1n).toString(10))).to.be.revertedWithPanic(
+        PANIC_CODES.ARITHMETIC_OVERFLOW,
+      );
+      await expect(this.mock.$tryParseInt((-ethers.MaxUint256 - 1n).toString(10))).to.be.revertedWithPanic(
+        PANIC_CODES.ARITHMETIC_OVERFLOW,
+      );
+      await expect(this.mock.$parseInt((ethers.MaxInt256 + 1n).toString(10))).to.be.revertedWithCustomError(
+        this.mock,
+        'StringsInvalidChar',
+      );
+      await expect(this.mock.$parseInt((ethers.MinInt256 - 1n).toString(10))).to.be.revertedWithCustomError(
+        this.mock,
+        'StringsInvalidChar',
+      );
+      expect(await this.mock.$tryParseInt((ethers.MaxInt256 + 1n).toString(10))).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseInt((ethers.MinInt256 - 1n).toString(10))).to.deep.equal([false, 0n]);
+    });
+
+    it('parseInt invalid character', async function () {
+      await expect(this.mock.$parseInt('0x1')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseInt('1f')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseInt('1.0')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseInt('1 000')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      expect(await this.mock.$tryParseInt('0x1')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseInt('1f')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseInt('1.0')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseInt('1 000')).to.deep.equal([false, 0n]);
+    });
+
+    it('parseInt invalid range', async function () {
+      expect(this.mock.$parseInt('-12', 3, 2)).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      expect(await this.mock.$tryParseInt('-12', 3, 2)).to.deep.equal([false, 0n]);
+    });
+
+    it('parseHexUint overflow', async function () {
+      await expect(this.mock.$parseHexUint((ethers.MaxUint256 + 1n).toString(16))).to.be.revertedWithPanic(
+        PANIC_CODES.ARITHMETIC_OVERFLOW,
+      );
+      await expect(this.mock.$tryParseHexUint((ethers.MaxUint256 + 1n).toString(16))).to.be.revertedWithPanic(
+        PANIC_CODES.ARITHMETIC_OVERFLOW,
+      );
+    });
+
+    it('parseHexUint invalid character', async function () {
+      await expect(this.mock.$parseHexUint('0123456789abcdefg')).to.be.revertedWithCustomError(
+        this.mock,
+        'StringsInvalidChar',
+      );
+      await expect(this.mock.$parseHexUint('-1')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseHexUint('-f')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseHexUint('-0xf')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseHexUint('1.0')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      await expect(this.mock.$parseHexUint('1 000')).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      expect(await this.mock.$tryParseHexUint('0123456789abcdefg')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseHexUint('-1')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseHexUint('-f')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseHexUint('-0xf')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseHexUint('1.0')).to.deep.equal([false, 0n]);
+      expect(await this.mock.$tryParseHexUint('1 000')).to.deep.equal([false, 0n]);
+    });
+
+    it('parseHexUint invalid begin and end', async function () {
+      expect(this.mock.$parseHexUint('0x', 3, 2)).to.be.revertedWithCustomError(this.mock, 'StringsInvalidChar');
+      expect(await this.mock.$tryParseHexUint('0x', 3, 2)).to.deep.equal([false, 0n]);
+    });
+
+    it('parseAddress invalid format', async function () {
+      for (const addr of [
+        '0x736a507fB2881d6bB62dcA54673CF5295dC07833', // valid
+        '0x736a507fB2881d6-B62dcA54673CF5295dC07833', // invalid char
+        '0x0736a507fB2881d6bB62dcA54673CF5295dC07833', // tooLong
+        '0x36a507fB2881d6bB62dcA54673CF5295dC07833', // tooShort
+        '736a507fB2881d6bB62dcA54673CF5295dC07833', // missingPrefix - supported
+      ]) {
+        if (ethers.isAddress(addr)) {
+          expect(await this.mock.$parseAddress(addr)).to.equal(ethers.getAddress(addr));
+          expect(await this.mock.$tryParseAddress(addr)).to.deep.equal([true, ethers.getAddress(addr)]);
+        } else {
+          await expect(this.mock.$parseAddress(addr)).to.be.revertedWithCustomError(
+            this.mock,
+            'StringsInvalidAddressFormat',
+          );
+          expect(await this.mock.$tryParseAddress(addr)).to.deep.equal([false, ethers.ZeroAddress]);
+        }
+      }
+    });
+  });
+
+  describe('Escape JSON string', function () {
+    for (const input of ['', 'a', '{"a":"b/c"}', 'a\tb\nc\\d"e\rf/g\fh\bi'])
+      it(`escape ${JSON.stringify(input)}`, async function () {
+        await expect(this.mock.$escapeJSON(input)).to.eventually.equal(JSON.stringify(input).slice(1, -1));
+      });
+  });
+});

package/lib/openzeppelin-contracts/test/utils/TransientSlot.test.js

@@ -0,0 +1,59 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { generators } = require('../helpers/random');
+
+const slot = ethers.id('some.storage.slot');
+const otherSlot = ethers.id('some.other.storage.slot');
+
+// Non-value types are not supported by the `TransientSlot` library.
+const TYPES = [
+  { name: 'Boolean', type: 'bool', value: true, zero: false },
+  { name: 'Address', type: 'address', value: generators.address(), zero: generators.address.zero },
+  { name: 'Bytes32', type: 'bytes32', value: generators.bytes32(), zero: generators.bytes32.zero },
+  { name: 'Uint256', type: 'uint256', value: generators.uint256(), zero: generators.uint256.zero },
+  { name: 'Int256', type: 'int256', value: generators.int256(), zero: generators.int256.zero },
+];
+
+async function fixture() {
+  return { mock: await ethers.deployContract('TransientSlotMock') };
+}
+
+describe('TransientSlot', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  for (const { name, type, value, zero } of TYPES) {
+    describe(`${type} transient slot`, function () {
+      const load = `tload${name}(bytes32)`;
+      const store = `tstore(bytes32,${type})`;
+      const event = `${name}Value`;
+
+      it('load', async function () {
+        await expect(this.mock[load](slot)).to.emit(this.mock, event).withArgs(slot, zero);
+      });
+
+      it('store and load (2 txs)', async function () {
+        await this.mock[store](slot, value);
+        await expect(this.mock[load](slot)).to.emit(this.mock, event).withArgs(slot, zero);
+      });
+
+      it('store and load (batched)', async function () {
+        await expect(
+          this.mock.multicall([
+            this.mock.interface.encodeFunctionData(store, [slot, value]),
+            this.mock.interface.encodeFunctionData(load, [slot]),
+            this.mock.interface.encodeFunctionData(load, [otherSlot]),
+          ]),
+        )
+          .to.emit(this.mock, event)
+          .withArgs(slot, value)
+          .to.emit(this.mock, event)
+          .withArgs(otherSlot, zero);
+
+        await expect(this.mock[load](slot)).to.emit(this.mock, event).withArgs(slot, zero);
+      });
+    });
+  }
+});