web3gbit-cli 1.0.0

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

@@ -0,0 +1,217 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { impersonate } = require('../helpers/account');
+
+async function fixture() {
+  const [admin, receiver, other] = await ethers.getSigners();
+
+  const mock = await ethers.deployContract('$RelayedCall');
+  const computeRelayerAddress = (salt = ethers.ZeroHash) =>
+    ethers.getCreate2Address(
+      mock.target,
+      salt,
+      ethers.keccak256(
+        ethers.concat([
+          '0x60475f8160095f39f373',
+          mock.target,
+          '0x331460133611166022575f5ffd5b6014360360145f375f5f601436035f345f3560601c5af13d5f5f3e5f3d91604557fd5bf3',
+        ]),
+      ),
+    );
+
+  const authority = await ethers.deployContract('$AccessManager', [admin]);
+  const target = await ethers.deployContract('$AccessManagedTarget', [authority]);
+
+  return { mock, target, receiver, other, computeRelayerAddress };
+}
+
+describe('RelayedCall', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('default (zero) salt', function () {
+    beforeEach(async function () {
+      this.relayer = await this.computeRelayerAddress();
+    });
+
+    it('automatic relayer deployment', async function () {
+      await expect(ethers.provider.getCode(this.relayer)).to.eventually.equal('0x');
+
+      // First call performs deployment
+      await expect(this.mock.$getRelayer()).to.emit(this.mock, 'return$getRelayer').withArgs(this.relayer);
+
+      await expect(ethers.provider.getCode(this.relayer)).to.eventually.not.equal('0x');
+
+      // Following calls use the same relayer
+      await expect(this.mock.$getRelayer()).to.emit(this.mock, 'return$getRelayer').withArgs(this.relayer);
+    });
+
+    describe('relayed call', function () {
+      it('target success', async function () {
+        const tx = this.mock.$relayCall(
+          ethers.Typed.address(this.target),
+          ethers.Typed.bytes(this.target.interface.encodeFunctionData('fnUnrestricted', [])),
+        );
+        await expect(tx)
+          .to.emit(this.target, 'CalledUnrestricted')
+          .withArgs(this.relayer)
+          .to.emit(this.mock, 'return$relayCall_address_bytes')
+          .withArgs(true, '0x');
+      });
+
+      it('target success (with value)', async function () {
+        const value = 42n;
+
+        const tx = this.mock.$relayCall(
+          ethers.Typed.address(this.receiver),
+          ethers.Typed.uint256(value),
+          ethers.Typed.bytes('0x'),
+          ethers.Typed.overrides({ value }),
+        );
+
+        await expect(tx).to.changeEtherBalances([this.mock, this.relayer, this.receiver], [0n, 0n, value]);
+        await expect(tx).to.emit(this.mock, 'return$relayCall_address_uint256_bytes').withArgs(true, '0x');
+      });
+
+      it('target revert', async function () {
+        const tx = this.mock.$relayCall(
+          ethers.Typed.address(this.target),
+          ethers.Typed.bytes(this.target.interface.encodeFunctionData('fnRestricted', [])),
+        );
+
+        await expect(tx)
+          .to.emit(this.mock, 'return$relayCall_address_bytes')
+          .withArgs(false, this.target.interface.encodeErrorResult('AccessManagedUnauthorized', [this.relayer]));
+      });
+    });
+
+    it('direct call to the relayer', async function () {
+      // deploy relayer
+      await this.mock.$getRelayer();
+
+      // unauthorized caller
+      await expect(
+        this.other.sendTransaction({ to: this.relayer, data: '0x7859821024E633C5dC8a4FcF86fC52e7720Ce525' }),
+      ).to.be.revertedWithoutReason();
+    });
+
+    it('input format', async function () {
+      // deploy relayer
+      await this.mock.$getRelayer();
+
+      // impersonate mock to pass caller checks
+      const mockAsWallet = await impersonate(this.mock.target);
+
+      // 20 bytes (address + empty data) - OK
+      await expect(
+        mockAsWallet.sendTransaction({ to: this.relayer, data: '0x7859821024E633C5dC8a4FcF86fC52e7720Ce525' }),
+      ).to.not.be.reverted;
+
+      // 19 bytes (not enough for an address) - REVERT
+      await expect(
+        mockAsWallet.sendTransaction({ to: this.relayer, data: '0x7859821024E633C5dC8a4FcF86fC52e7720Ce5' }),
+      ).to.be.revertedWithoutReason();
+
+      // 0 bytes (not enough for an address) - REVERT
+      await expect(mockAsWallet.sendTransaction({ to: this.relayer, data: '0x' })).to.be.revertedWithoutReason();
+    });
+  });
+
+  describe('random salt', function () {
+    beforeEach(async function () {
+      this.salt = ethers.hexlify(ethers.randomBytes(32));
+      this.relayer = await this.computeRelayerAddress(this.salt);
+    });
+
+    it('automatic relayer deployment', async function () {
+      await expect(ethers.provider.getCode(this.relayer)).to.eventually.equal('0x');
+
+      // First call performs deployment
+      await expect(this.mock.$getRelayer(ethers.Typed.bytes32(this.salt)))
+        .to.emit(this.mock, 'return$getRelayer_bytes32')
+        .withArgs(this.relayer);
+
+      await expect(ethers.provider.getCode(this.relayer)).to.eventually.not.equal('0x');
+
+      // Following calls use the same relayer
+      await expect(this.mock.$getRelayer(ethers.Typed.bytes32(this.salt)))
+        .to.emit(this.mock, 'return$getRelayer_bytes32')
+        .withArgs(this.relayer);
+    });
+
+    describe('relayed call', function () {
+      it('target success', async function () {
+        const tx = this.mock.$relayCall(
+          ethers.Typed.address(this.target),
+          ethers.Typed.bytes(this.target.interface.encodeFunctionData('fnUnrestricted', [])),
+          ethers.Typed.bytes32(this.salt),
+        );
+        await expect(tx)
+          .to.emit(this.target, 'CalledUnrestricted')
+          .withArgs(this.relayer)
+          .to.emit(this.mock, 'return$relayCall_address_bytes_bytes32')
+          .withArgs(true, '0x');
+      });
+
+      it('target success (with value)', async function () {
+        const value = 42n;
+
+        const tx = this.mock.$relayCall(
+          ethers.Typed.address(this.receiver),
+          ethers.Typed.uint256(value),
+          ethers.Typed.bytes('0x'),
+          ethers.Typed.bytes32(this.salt),
+          ethers.Typed.overrides({ value }),
+        );
+
+        await expect(tx).to.changeEtherBalances([this.mock, this.relayer, this.receiver], [0n, 0n, value]);
+        await expect(tx).to.emit(this.mock, 'return$relayCall_address_uint256_bytes_bytes32').withArgs(true, '0x');
+      });
+
+      it('target revert', async function () {
+        const tx = this.mock.$relayCall(
+          ethers.Typed.address(this.target),
+          ethers.Typed.bytes(this.target.interface.encodeFunctionData('fnRestricted', [])),
+          ethers.Typed.bytes32(this.salt),
+        );
+
+        await expect(tx)
+          .to.emit(this.mock, 'return$relayCall_address_bytes_bytes32')
+          .withArgs(false, this.target.interface.encodeErrorResult('AccessManagedUnauthorized', [this.relayer]));
+      });
+    });
+
+    it('direct call to the relayer', async function () {
+      // deploy relayer
+      await this.mock.$getRelayer(ethers.Typed.bytes32(this.salt));
+
+      // unauthorized caller
+      await expect(
+        this.other.sendTransaction({ to: this.relayer, data: '0x7859821024E633C5dC8a4FcF86fC52e7720Ce525' }),
+      ).to.be.revertedWithoutReason();
+    });
+
+    it('input format', async function () {
+      // deploy relayer
+      await this.mock.$getRelayer(ethers.Typed.bytes32(this.salt));
+
+      // impersonate mock to pass caller checks
+      const mockAsWallet = await impersonate(this.mock.target);
+
+      // 20 bytes (address + empty data) - OK
+      await expect(
+        mockAsWallet.sendTransaction({ to: this.relayer, data: '0x7859821024E633C5dC8a4FcF86fC52e7720Ce525' }),
+      ).to.not.be.reverted;
+
+      // 19 bytes (not enough for an address) - REVERT
+      await expect(
+        mockAsWallet.sendTransaction({ to: this.relayer, data: '0x7859821024E633C5dC8a4FcF86fC52e7720Ce5' }),
+      ).to.be.revertedWithoutReason();
+
+      // 0 bytes (not enough for an address) - REVERT
+      await expect(mockAsWallet.sendTransaction({ to: this.relayer, data: '0x' })).to.be.revertedWithoutReason();
+    });
+  });
+});

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

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {SymTest} from "halmos-cheatcodes/SymTest.sol";
+
+import {ShortStrings, ShortString} from "@openzeppelin/contracts/utils/ShortStrings.sol";
+
+contract ShortStringsTest is Test, SymTest {
+    string _fallback;
+
+    function testRoundtripShort(string memory input) external pure {
+        vm.assume(_isShort(input));
+        _assertRoundtripShort(input);
+    }
+
+    function symbolicRoundtripShort() external pure {
+        string memory input = svm.createString(31, "RoundtripShortInput");
+        _assertRoundtripShort(input);
+    }
+
+    function testRoundtripWithFallback(string memory input, string memory fallbackInitial) external {
+        _assertRoundtripWithFallback(input, fallbackInitial);
+    }
+
+    function symbolicRoundtripWithFallbackLong() external {
+        string memory input = svm.createString(256, "RoundtripWithFallbackInput");
+        string memory fallbackInitial = svm.createString(256, "RoundtripWithFallbackFallbackInitial");
+        _assertRoundtripWithFallback(input, fallbackInitial);
+    }
+
+    function symbolicRoundtripWithFallbackShort() external {
+        string memory input = svm.createString(31, "RoundtripWithFallbackInput");
+        string memory fallbackInitial = svm.createString(31, "RoundtripWithFallbackFallbackInitial");
+        _assertRoundtripWithFallback(input, fallbackInitial);
+    }
+
+    function testRevertLong(string memory input) external {
+        vm.assume(!_isShort(input));
+        _assertRevertLong(input);
+    }
+
+    function testLengthShort(string memory input) external pure {
+        vm.assume(_isShort(input));
+        _assertLengthShort(input);
+    }
+
+    function symbolicLengthShort() external pure {
+        string memory input = svm.createString(31, "LengthShortInput");
+        _assertLengthShort(input);
+    }
+
+    function testLengthWithFallback(string memory input, string memory fallbackInitial) external {
+        _fallback = fallbackInitial;
+        _assertLengthWithFallback(input);
+    }
+
+    function symbolicLengthWithFallback() external {
+        uint256 length = 256;
+        string memory input = svm.createString(length, "LengthWithFallbackInput");
+        string memory fallbackInitial = svm.createString(length, "LengthWithFallbackFallbackInitial");
+        _fallback = fallbackInitial;
+        _assertLengthWithFallback(input);
+    }
+
+    /// Assertions
+
+    function _assertRoundtripShort(string memory input) internal pure {
+        ShortString short = ShortStrings.toShortString(input);
+        string memory output = ShortStrings.toString(short);
+        assertEq(input, output);
+    }
+
+    function _assertRoundtripWithFallback(string memory input, string memory fallbackInitial) internal {
+        _fallback = fallbackInitial; // Make sure that the initial value has no effect
+        ShortString short = ShortStrings.toShortStringWithFallback(input, _fallback);
+        string memory output = ShortStrings.toStringWithFallback(short, _fallback);
+        assertEq(input, output);
+    }
+
+    function _assertRevertLong(string memory input) internal {
+        vm.expectRevert(abi.encodeWithSelector(ShortStrings.StringTooLong.selector, input));
+        this.toShortString(input);
+    }
+
+    function _assertLengthShort(string memory input) internal pure {
+        ShortString short = ShortStrings.toShortString(input);
+        uint256 shortLength = ShortStrings.byteLength(short);
+        uint256 inputLength = bytes(input).length;
+        assertEq(inputLength, shortLength);
+    }
+
+    function _assertLengthWithFallback(string memory input) internal {
+        uint256 inputLength = bytes(input).length;
+        ShortString short = ShortStrings.toShortStringWithFallback(input, _fallback);
+        uint256 shortLength = ShortStrings.byteLengthWithFallback(short, _fallback);
+        assertEq(inputLength, shortLength);
+    }
+
+    /// Helpers
+    function toShortString(string memory input) external pure returns (ShortString) {
+        return ShortStrings.toShortString(input);
+    }
+
+    function _isShort(string memory input) internal pure returns (bool) {
+        return bytes(input).length < 32;
+    }
+}

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

@@ -0,0 +1,64 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const FALLBACK_SENTINEL = ethers.zeroPadValue('0xFF', 32);
+
+const length = sstr => parseInt(sstr.slice(64), 16);
+const decode = sstr => ethers.toUtf8String(sstr).slice(0, length(sstr));
+const encode = str =>
+  str.length < 32
+    ? ethers.concat([
+        ethers.encodeBytes32String(str).slice(0, -2),
+        ethers.zeroPadValue(ethers.toBeArray(str.length), 1),
+      ])
+    : FALLBACK_SENTINEL;
+
+async function fixture() {
+  const mock = await ethers.deployContract('$ShortStrings');
+  return { mock };
+}
+
+describe('ShortStrings', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  for (const str of [0, 1, 16, 31, 32, 64, 1024].map(length => 'a'.repeat(length))) {
+    describe(`with string length ${str.length}`, function () {
+      it('encode / decode', async function () {
+        if (str.length < 32) {
+          const encoded = await this.mock.$toShortString(str);
+          expect(encoded).to.equal(encode(str));
+          expect(decode(encoded)).to.equal(str);
+
+          expect(await this.mock.$byteLength(encoded)).to.equal(str.length);
+          expect(await this.mock.$toString(encoded)).to.equal(str);
+        } else {
+          await expect(this.mock.$toShortString(str))
+            .to.be.revertedWithCustomError(this.mock, 'StringTooLong')
+            .withArgs(str);
+        }
+      });
+
+      it('set / get with fallback', async function () {
+        const short = await this.mock
+          .$toShortStringWithFallback(str, 0)
+          .then(tx => tx.wait())
+          .then(receipt => receipt.logs.find(ev => ev.fragment.name == 'return$toShortStringWithFallback').args[0]);
+
+        expect(short).to.equal(encode(str));
+
+        const promise = this.mock.$toString(short);
+        if (str.length < 32) {
+          expect(await promise).to.equal(str);
+        } else {
+          await expect(promise).to.be.revertedWithCustomError(this.mock, 'InvalidShortString');
+        }
+
+        expect(await this.mock.$byteLengthWithFallback(short, 0)).to.equal(str.length);
+        expect(await this.mock.$toStringWithFallback(short, 0)).to.equal(str);
+      });
+    });
+  }
+});

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

@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: MIT
+// This file was procedurally generated from scripts/generate/templates/SlotDerivation.t.js.
+
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {SymTest} from "halmos-cheatcodes/SymTest.sol";
+import {SlotDerivation} from "@openzeppelin/contracts/utils/SlotDerivation.sol";
+
+contract SlotDerivationTest is Test, SymTest {
+    using SlotDerivation for bytes32;
+
+    bytes[] private _array;
+
+    function symbolicDeriveArray(uint256 length, uint256 offset) public {
+        vm.assume(length > 0);
+        vm.assume(offset < length);
+        _assertDeriveArray(length, offset);
+    }
+
+    function testDeriveArray(uint256 length, uint256 offset) public {
+        length = bound(length, 1, type(uint256).max);
+        offset = bound(offset, 0, length - 1);
+        _assertDeriveArray(length, offset);
+    }
+
+    function _assertDeriveArray(uint256 length, uint256 offset) public {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _array.slot
+            sstore(baseSlot, length) // store length so solidity access does not revert
+        }
+
+        bytes storage derived = _array[offset];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveArray().offset(offset), derivedSlot);
+    }
+
+    mapping(address => bytes) private _addressMapping;
+
+    function testSymbolicDeriveMappingAddress(address key) public view {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _addressMapping.slot
+        }
+
+        bytes storage derived = _addressMapping[key];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    }
+
+    mapping(bool => bytes) private _boolMapping;
+
+    function testSymbolicDeriveMappingBoolean(bool key) public view {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _boolMapping.slot
+        }
+
+        bytes storage derived = _boolMapping[key];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    }
+
+    mapping(bytes32 => bytes) private _bytes32Mapping;
+
+    function testSymbolicDeriveMappingBytes32(bytes32 key) public view {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _bytes32Mapping.slot
+        }
+
+        bytes storage derived = _bytes32Mapping[key];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    }
+
+    mapping(bytes4 => bytes) private _bytes4Mapping;
+
+    function testSymbolicDeriveMappingBytes4(bytes4 key) public view {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _bytes4Mapping.slot
+        }
+
+        bytes storage derived = _bytes4Mapping[key];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    }
+
+    mapping(uint256 => bytes) private _uint256Mapping;
+
+    function testSymbolicDeriveMappingUint256(uint256 key) public view {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _uint256Mapping.slot
+        }
+
+        bytes storage derived = _uint256Mapping[key];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    }
+
+    mapping(uint32 => bytes) private _uint32Mapping;
+
+    function testSymbolicDeriveMappingUint32(uint32 key) public view {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _uint32Mapping.slot
+        }
+
+        bytes storage derived = _uint32Mapping[key];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    }
+
+    mapping(int256 => bytes) private _int256Mapping;
+
+    function testSymbolicDeriveMappingInt256(int256 key) public view {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _int256Mapping.slot
+        }
+
+        bytes storage derived = _int256Mapping[key];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    }
+
+    mapping(int32 => bytes) private _int32Mapping;
+
+    function testSymbolicDeriveMappingInt32(int32 key) public view {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _int32Mapping.slot
+        }
+
+        bytes storage derived = _int32Mapping[key];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    }
+
+    mapping(string => bytes) private _stringMapping;
+
+    function testDeriveMappingString(string memory key) public view {
+        _assertDeriveMappingString(key);
+    }
+
+    function symbolicDeriveMappingString() public view {
+        _assertDeriveMappingString(svm.createString(256, "DeriveMappingStringInput"));
+    }
+
+    function _assertDeriveMappingString(string memory key) internal view {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _stringMapping.slot
+        }
+
+        bytes storage derived = _stringMapping[key];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    }
+
+    mapping(bytes => bytes) private _bytesMapping;
+
+    function testDeriveMappingBytes(bytes memory key) public view {
+        _assertDeriveMappingBytes(key);
+    }
+
+    function symbolicDeriveMappingBytes() public view {
+        _assertDeriveMappingBytes(svm.createBytes(256, "DeriveMappingBytesInput"));
+    }
+
+    function _assertDeriveMappingBytes(bytes memory key) internal view {
+        bytes32 baseSlot;
+        assembly {
+            baseSlot := _bytesMapping.slot
+        }
+
+        bytes storage derived = _bytesMapping[key];
+        bytes32 derivedSlot;
+        assembly {
+            derivedSlot := derived.slot
+        }
+
+        assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    }
+
+    function testSymbolicDeriveMappingBooleanDirty(bytes32 dirtyKey) public view {
+        bool key;
+        assembly {
+            key := dirtyKey
+        }
+
+        // run the "normal" test using a potentially dirty value
+        testSymbolicDeriveMappingBoolean(key);
+    }
+
+    function testSymbolicDeriveMappingAddressDirty(bytes32 dirtyKey) public view {
+        address key;
+        assembly {
+            key := dirtyKey
+        }
+
+        // run the "normal" test using a potentially dirty value
+        testSymbolicDeriveMappingAddress(key);
+    }
+}

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

@@ -0,0 +1,58 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { erc7201Slot } = require('../helpers/storage');
+const { generators } = require('../helpers/random');
+
+async function fixture() {
+  const [account] = await ethers.getSigners();
+  const mock = await ethers.deployContract('$SlotDerivation');
+  return { mock, account };
+}
+
+describe('SlotDerivation', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('namespaces', function () {
+    const namespace = 'example.main';
+
+    it('erc-7201', async function () {
+      expect(await this.mock.$erc7201Slot(namespace)).to.equal(erc7201Slot(namespace));
+    });
+  });
+
+  describe('derivation', function () {
+    it('offset', async function () {
+      const base = generators.bytes32();
+      const offset = generators.uint256();
+      expect(await this.mock.$offset(base, offset)).to.equal((ethers.toBigInt(base) + offset) & ethers.MaxUint256);
+    });
+
+    it('array', async function () {
+      const base = generators.bytes32();
+      expect(await this.mock.$deriveArray(base)).to.equal(ethers.keccak256(base));
+    });
+
+    describe('mapping', function () {
+      for (const { type, key, isValueType } of [
+        { type: 'bool', key: true, isValueType: true },
+        { type: 'address', key: generators.address(), isValueType: true },
+        { type: 'bytes32', key: generators.bytes32(), isValueType: true },
+        { type: 'uint256', key: generators.uint256(), isValueType: true },
+        { type: 'int256', key: generators.int256(), isValueType: true },
+        { type: 'bytes', key: generators.hexBytes(128), isValueType: false },
+        { type: 'string', key: 'lorem ipsum', isValueType: false },
+      ]) {
+        it(type, async function () {
+          const base = generators.bytes32();
+          const expected = isValueType
+            ? ethers.keccak256(ethers.AbiCoder.defaultAbiCoder().encode([type, 'bytes32'], [key, base]))
+            : ethers.solidityPackedKeccak256([type, 'bytes32'], [key, base]);
+          expect(await this.mock[`$deriveMapping(bytes32,${type})`](base, key)).to.equal(expected);
+        });
+      }
+    });
+  });
+});