web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/test/utils/cryptography/ERC7739Utils.test.js

@@ -0,0 +1,203 @@
+const { expect } = require('chai');
+const { ethers } = require('hardhat');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { Permit } = require('../../helpers/eip712');
+const { ERC4337Utils, PersonalSign } = require('../../helpers/erc7739');
+
+const details = ERC4337Utils.getContentsDetail({ Permit });
+
+const fixture = async () => {
+  const mock = await ethers.deployContract('$ERC7739Utils');
+  const domain = {
+    name: 'SomeDomain',
+    version: '1',
+    chainId: await ethers.provider.getNetwork().then(({ chainId }) => chainId),
+    verifyingContract: '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512',
+  };
+  const otherDomain = {
+    name: 'SomeOtherDomain',
+    version: '2',
+    chainId: await ethers.provider.getNetwork().then(({ chainId }) => chainId),
+    verifyingContract: '0x92C32cadBc39A15212505B5530aA765c441F306f',
+  };
+  const permit = {
+    owner: '0x1ab5E417d9AF00f1ca9d159007e12c401337a4bb',
+    spender: '0xD68E96620804446c4B1faB3103A08C98d4A8F55f',
+    value: 1_000_000n,
+    nonce: 0n,
+    deadline: ethers.MaxUint256,
+  };
+  return { mock, domain, otherDomain, permit };
+};
+
+describe('ERC7739Utils', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('encodeTypedDataSig', function () {
+    it('wraps a typed data signature', async function () {
+      const signature = ethers.randomBytes(65);
+      const appSeparator = ethers.id('SomeApp');
+      const contentsHash = ethers.id('SomeData');
+      const contentsDescr = 'SomeType()';
+      const encoded = ethers.concat([
+        signature,
+        appSeparator,
+        contentsHash,
+        ethers.toUtf8Bytes(contentsDescr),
+        ethers.toBeHex(contentsDescr.length, 2),
+      ]);
+
+      await expect(
+        this.mock.$encodeTypedDataSig(signature, appSeparator, contentsHash, contentsDescr),
+      ).to.eventually.equal(encoded);
+    });
+  });
+
+  describe('decodeTypedDataSig', function () {
+    it('unwraps a typed data signature', async function () {
+      const signature = ethers.randomBytes(65);
+      const appSeparator = ethers.id('SomeApp');
+      const contentsHash = ethers.id('SomeData');
+      const contentsDescr = 'SomeType()';
+      const encoded = ethers.concat([
+        signature,
+        appSeparator,
+        contentsHash,
+        ethers.toUtf8Bytes(contentsDescr),
+        ethers.toBeHex(contentsDescr.length, 2),
+      ]);
+
+      await expect(this.mock.$decodeTypedDataSig(encoded)).to.eventually.deep.equal([
+        ethers.hexlify(signature),
+        appSeparator,
+        contentsHash,
+        contentsDescr,
+      ]);
+    });
+
+    it('returns default empty values if the signature is too short', async function () {
+      const encoded = ethers.randomBytes(65); // DOMAIN_SEPARATOR (32 bytes) + CONTENTS (32 bytes) + CONTENTS_TYPE_LENGTH (2 bytes) - 1
+      await expect(this.mock.$decodeTypedDataSig(encoded)).to.eventually.deep.equal([
+        '0x',
+        ethers.ZeroHash,
+        ethers.ZeroHash,
+        '',
+      ]);
+    });
+
+    it('returns default empty values if the length is invalid', async function () {
+      const encoded = ethers.concat([ethers.randomBytes(64), '0x3f']); // Can't be less than 64 bytes
+      await expect(this.mock.$decodeTypedDataSig(encoded)).to.eventually.deep.equal([
+        '0x',
+        ethers.ZeroHash,
+        ethers.ZeroHash,
+        '',
+      ]);
+    });
+  });
+
+  describe('personalSignStructhash', function () {
+    it('should produce a personal signature EIP-712 nested type', async function () {
+      const text = 'Hello, world!';
+
+      await expect(this.mock.$personalSignStructHash(ethers.hashMessage(text))).to.eventually.equal(
+        ethers.TypedDataEncoder.hashStruct('PersonalSign', { PersonalSign }, ERC4337Utils.preparePersonalSign(text)),
+      );
+    });
+  });
+
+  describe('typedDataSignStructHash', function () {
+    it('should match the typed data nested struct hash', async function () {
+      const message = ERC4337Utils.prepareSignTypedData(this.permit, this.domain);
+
+      const contentsHash = ethers.TypedDataEncoder.hashStruct('Permit', { Permit }, this.permit);
+      const hash = ethers.TypedDataEncoder.hashStruct('TypedDataSign', details.allTypes, message);
+
+      const domainBytes = ethers.AbiCoder.defaultAbiCoder().encode(
+        ['bytes32', 'bytes32', 'uint256', 'address', 'bytes32'],
+        [
+          ethers.id(this.domain.name),
+          ethers.id(this.domain.version),
+          this.domain.chainId,
+          this.domain.verifyingContract,
+          ethers.ZeroHash,
+        ],
+      );
+
+      await expect(
+        this.mock.$typedDataSignStructHash(
+          details.contentsTypeName,
+          ethers.Typed.string(details.contentsDescr),
+          contentsHash,
+          domainBytes,
+        ),
+      ).to.eventually.equal(hash);
+      await expect(
+        this.mock.$typedDataSignStructHash(details.contentsDescr, contentsHash, domainBytes),
+      ).to.eventually.equal(hash);
+    });
+  });
+
+  describe('typedDataSignTypehash', function () {
+    it('should match', async function () {
+      const typedDataSignType = ethers.TypedDataEncoder.from(details.allTypes).encodeType('TypedDataSign');
+
+      await expect(
+        this.mock.$typedDataSignTypehash(
+          details.contentsTypeName,
+          typedDataSignType.slice(typedDataSignType.indexOf(')') + 1),
+        ),
+      ).to.eventually.equal(ethers.keccak256(ethers.toUtf8Bytes(typedDataSignType)));
+    });
+  });
+
+  describe('decodeContentsDescr', function () {
+    const forbiddenChars = ', )\x00';
+
+    for (const { descr, contentsDescr, contentTypeName, contentType } of [].concat(
+      {
+        descr: 'should parse a valid descriptor (implicit)',
+        contentsDescr: 'SomeType(address foo,uint256 bar)',
+        contentTypeName: 'SomeType',
+      },
+      {
+        descr: 'should parse a valid descriptor (explicit)',
+        contentsDescr: 'A(C c)B(A a)C(uint256 v)B',
+        contentTypeName: 'B',
+        contentType: 'A(C c)B(A a)C(uint256 v)',
+      },
+      { descr: 'should return nothing for an empty descriptor', contentsDescr: '', contentTypeName: null },
+      { descr: 'should return nothing if no [(] is present', contentsDescr: 'SomeType', contentTypeName: null },
+      {
+        descr: 'should return nothing if starts with [(] (implicit)',
+        contentsDescr: '(SomeType(address foo,uint256 bar)',
+        contentTypeName: null,
+      },
+      {
+        descr: 'should return nothing if starts with [(] (explicit)',
+        contentsDescr: '(SomeType(address foo,uint256 bar)(SomeType',
+        contentTypeName: null,
+      },
+      forbiddenChars.split('').map(char => ({
+        descr: `should return nothing if contains [${char}] (implicit)`,
+        contentsDescr: `SomeType${char}(address foo,uint256 bar)`,
+        contentTypeName: null,
+      })),
+      forbiddenChars.split('').map(char => ({
+        descr: `should return nothing if contains [${char}] (explicit)`,
+        contentsDescr: `SomeType${char}(address foo,uint256 bar)SomeType${char}`,
+        contentTypeName: null,
+      })),
+    )) {
+      it(descr, async function () {
+        await expect(this.mock.$decodeContentsDescr(contentsDescr)).to.eventually.deep.equal([
+          contentTypeName ?? '',
+          contentTypeName ? (contentType ?? contentsDescr) : '',
+        ]);
+      });
+    }
+  });
+});

package/lib/openzeppelin-contracts/test/utils/cryptography/MerkleProof.test.js

@@ -0,0 +1,216 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic');
+const { SimpleMerkleTree } = require('@openzeppelin/merkle-tree');
+
+// generate bytes32 leaves from a string
+const toLeaves = (str, separator = '') => str.split(separator).map(e => ethers.keccak256(ethers.toUtf8Bytes(e)));
+// internal node hashes
+const concatSorted = (...elements) => Buffer.concat(elements.map(ethers.getBytes).sort(Buffer.compare));
+const defaultHash = (a, b) => ethers.keccak256(concatSorted(a, b));
+const customHash = (a, b) => ethers.sha256(concatSorted(a, b));
+
+describe('MerkleProof', function () {
+  for (const { title, contractName, nodeHash } of [
+    { title: 'default hash', contractName: '$MerkleProof', nodeHash: defaultHash },
+    { title: 'custom hash', contractName: '$MerkleProofCustomHashMock', nodeHash: customHash },
+  ]) {
+    describe(title, function () {
+      // stateless: no need for a fixture, just use before
+      before(async function () {
+        this.mock = await ethers.deployContract(contractName);
+        this.makeTree = str => SimpleMerkleTree.of(toLeaves(str), { nodeHash });
+      });
+
+      describe('verify', function () {
+        it('returns true for a valid Merkle proof', async function () {
+          const merkleTree = this.makeTree('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=');
+
+          const root = merkleTree.root;
+          const hash = merkleTree.at(0);
+          const proof = merkleTree.getProof(0);
+
+          expect(await this.mock.$processProof(proof, hash)).to.equal(root);
+          expect(await this.mock.$processProofCalldata(proof, hash)).to.equal(root);
+          expect(await this.mock.$verify(proof, root, hash)).to.be.true;
+          expect(await this.mock.$verifyCalldata(proof, root, hash)).to.be.true;
+
+          // For demonstration, it is also possible to create valid proofs for certain 64-byte values *not* in elements:
+          const noSuchLeaf = nodeHash(hash, proof.at(0));
+
+          expect(await this.mock.$processProof(proof.slice(1), noSuchLeaf)).to.equal(root);
+          expect(await this.mock.$processProofCalldata(proof.slice(1), noSuchLeaf)).to.equal(root);
+          expect(await this.mock.$verify(proof.slice(1), root, noSuchLeaf)).to.be.true;
+          expect(await this.mock.$verifyCalldata(proof.slice(1), root, noSuchLeaf)).to.be.true;
+        });
+
+        it('returns false for an invalid Merkle proof', async function () {
+          const correctMerkleTree = this.makeTree('abc');
+          const otherMerkleTree = this.makeTree('def');
+
+          const root = correctMerkleTree.root;
+          const hash = correctMerkleTree.at(0);
+          const proof = otherMerkleTree.getProof(0);
+
+          expect(await this.mock.$processProof(proof, hash)).to.not.equal(root);
+          expect(await this.mock.$processProofCalldata(proof, hash)).to.not.equal(root);
+          expect(await this.mock.$verify(proof, root, hash)).to.be.false;
+          expect(await this.mock.$verifyCalldata(proof, root, hash)).to.be.false;
+        });
+
+        it('returns false for a Merkle proof of invalid length', async function () {
+          const merkleTree = this.makeTree('abc');
+
+          const root = merkleTree.root;
+          const hash = merkleTree.at(0);
+          const proof = merkleTree.getProof(0);
+          const badProof = proof.slice(0, -1);
+
+          expect(await this.mock.$processProof(badProof, hash)).to.not.equal(root);
+          expect(await this.mock.$processProofCalldata(badProof, hash)).to.not.equal(root);
+          expect(await this.mock.$verify(badProof, root, hash)).to.be.false;
+          expect(await this.mock.$verifyCalldata(badProof, root, hash)).to.be.false;
+        });
+      });
+
+      describe('multiProofVerify', function () {
+        it('returns true for a valid Merkle multi proof', async function () {
+          const merkleTree = this.makeTree('abcdef');
+
+          const root = merkleTree.root;
+          const { proof, proofFlags, leaves } = merkleTree.getMultiProof(toLeaves('bdf'));
+          const hashes = leaves.map(e => merkleTree.leafHash(e));
+
+          expect(await this.mock.$processMultiProof(proof, proofFlags, hashes)).to.equal(root);
+          expect(await this.mock.$processMultiProofCalldata(proof, proofFlags, hashes)).to.equal(root);
+          expect(await this.mock.$multiProofVerify(proof, proofFlags, root, hashes)).to.be.true;
+          expect(await this.mock.$multiProofVerifyCalldata(proof, proofFlags, root, hashes)).to.be.true;
+        });
+
+        it('returns false for an invalid Merkle multi proof', async function () {
+          const merkleTree = this.makeTree('abcdef');
+          const otherMerkleTree = this.makeTree('ghi');
+
+          const root = merkleTree.root;
+          const { proof, proofFlags, leaves } = otherMerkleTree.getMultiProof(toLeaves('ghi'));
+          const hashes = leaves.map(e => merkleTree.leafHash(e));
+
+          expect(await this.mock.$processMultiProof(proof, proofFlags, hashes)).to.not.equal(root);
+          expect(await this.mock.$processMultiProofCalldata(proof, proofFlags, hashes)).to.not.equal(root);
+          expect(await this.mock.$multiProofVerify(proof, proofFlags, root, hashes)).to.be.false;
+          expect(await this.mock.$multiProofVerifyCalldata(proof, proofFlags, root, hashes)).to.be.false;
+        });
+
+        it('revert with invalid multi proof #1', async function () {
+          const merkleTree = this.makeTree('abcd');
+
+          const root = merkleTree.root;
+          const hashA = merkleTree.at(0);
+          const hashB = merkleTree.at(1);
+          const hashCD = nodeHash(merkleTree.at(2), merkleTree.at(3));
+          const hashE = ethers.randomBytes(32); // incorrect (not part of the tree)
+          const fill = ethers.randomBytes(32);
+
+          await expect(
+            this.mock.$processMultiProof([hashB, fill, hashCD], [false, false, false], [hashA, hashE]),
+          ).to.be.revertedWithCustomError(this.mock, 'MerkleProofInvalidMultiproof');
+
+          await expect(
+            this.mock.$processMultiProofCalldata([hashB, fill, hashCD], [false, false, false], [hashA, hashE]),
+          ).to.be.revertedWithCustomError(this.mock, 'MerkleProofInvalidMultiproof');
+
+          await expect(
+            this.mock.$multiProofVerify([hashB, fill, hashCD], [false, false, false], root, [hashA, hashE]),
+          ).to.be.revertedWithCustomError(this.mock, 'MerkleProofInvalidMultiproof');
+
+          await expect(
+            this.mock.$multiProofVerifyCalldata([hashB, fill, hashCD], [false, false, false], root, [hashA, hashE]),
+          ).to.be.revertedWithCustomError(this.mock, 'MerkleProofInvalidMultiproof');
+        });
+
+        it('revert with invalid multi proof #2', async function () {
+          const merkleTree = this.makeTree('abcd');
+
+          const root = merkleTree.root;
+          const hashA = merkleTree.at(0);
+          const hashB = merkleTree.at(1);
+          const hashCD = nodeHash(merkleTree.at(2), merkleTree.at(3));
+          const hashE = ethers.randomBytes(32); // incorrect (not part of the tree)
+          const fill = ethers.randomBytes(32);
+
+          await expect(
+            this.mock.$processMultiProof([hashB, fill, hashCD], [false, false, false, false], [hashE, hashA]),
+          ).to.be.revertedWithPanic(PANIC_CODES.ARRAY_ACCESS_OUT_OF_BOUNDS);
+
+          await expect(
+            this.mock.$processMultiProofCalldata([hashB, fill, hashCD], [false, false, false, false], [hashE, hashA]),
+          ).to.be.revertedWithPanic(PANIC_CODES.ARRAY_ACCESS_OUT_OF_BOUNDS);
+
+          await expect(
+            this.mock.$multiProofVerify([hashB, fill, hashCD], [false, false, false, false], root, [hashE, hashA]),
+          ).to.be.revertedWithPanic(PANIC_CODES.ARRAY_ACCESS_OUT_OF_BOUNDS);
+
+          await expect(
+            this.mock.$multiProofVerifyCalldata([hashB, fill, hashCD], [false, false, false, false], root, [
+              hashE,
+              hashA,
+            ]),
+          ).to.be.revertedWithPanic(PANIC_CODES.ARRAY_ACCESS_OUT_OF_BOUNDS);
+        });
+
+        it('limit case: works for tree containing a single leaf', async function () {
+          const merkleTree = this.makeTree('a');
+
+          const root = merkleTree.root;
+          const { proof, proofFlags, leaves } = merkleTree.getMultiProof(toLeaves('a'));
+          const hashes = leaves.map(e => merkleTree.leafHash(e));
+
+          expect(await this.mock.$processMultiProof(proof, proofFlags, hashes)).to.equal(root);
+          expect(await this.mock.$processMultiProofCalldata(proof, proofFlags, hashes)).to.equal(root);
+          expect(await this.mock.$multiProofVerify(proof, proofFlags, root, hashes)).to.be.true;
+          expect(await this.mock.$multiProofVerifyCalldata(proof, proofFlags, root, hashes)).to.be.true;
+        });
+
+        it('limit case: can prove empty leaves', async function () {
+          const merkleTree = this.makeTree('abcd');
+
+          const root = merkleTree.root;
+          expect(await this.mock.$processMultiProof([root], [], [])).to.equal(root);
+          expect(await this.mock.$processMultiProofCalldata([root], [], [])).to.equal(root);
+          expect(await this.mock.$multiProofVerify([root], [], root, [])).to.be.true;
+          expect(await this.mock.$multiProofVerifyCalldata([root], [], root, [])).to.be.true;
+        });
+
+        it('reverts processing manipulated proofs with a zero-value node at depth 1', async function () {
+          // Create a merkle tree that contains a zero leaf at depth 1
+          const leave = ethers.id('real leaf');
+          const root = nodeHash(leave, ethers.ZeroHash);
+
+          // Now we can pass any **malicious** fake leaves as valid!
+          const maliciousLeaves = ['malicious', 'leaves']
+            .map(ethers.id)
+            .map(id => ethers.toBeArray(id))
+            .sort(Buffer.compare);
+          const maliciousProof = [leave, leave];
+          const maliciousProofFlags = [true, true, false];
+
+          await expect(
+            this.mock.$processMultiProof(maliciousProof, maliciousProofFlags, maliciousLeaves),
+          ).to.be.revertedWithCustomError(this.mock, 'MerkleProofInvalidMultiproof');
+
+          await expect(
+            this.mock.$processMultiProofCalldata(maliciousProof, maliciousProofFlags, maliciousLeaves),
+          ).to.be.revertedWithCustomError(this.mock, 'MerkleProofInvalidMultiproof');
+
+          await expect(
+            this.mock.$multiProofVerify(maliciousProof, maliciousProofFlags, root, maliciousLeaves),
+          ).to.be.revertedWithCustomError(this.mock, 'MerkleProofInvalidMultiproof');
+
+          await expect(
+            this.mock.$multiProofVerifyCalldata(maliciousProof, maliciousProofFlags, root, maliciousLeaves),
+          ).to.be.revertedWithCustomError(this.mock, 'MerkleProofInvalidMultiproof');
+        });
+      });
+    });
+  }
+});

package/lib/openzeppelin-contracts/test/utils/cryptography/MessageHashUtils.t.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
+
+contract MessageHashUtilsTest is Test {
+    function testToDataWithIntendedValidatorHash(address validator, bytes memory data) external pure {
+        assertEq(
+            MessageHashUtils.toDataWithIntendedValidatorHash(validator, data),
+            MessageHashUtils.toDataWithIntendedValidatorHash(_dirty(validator), data)
+        );
+    }
+
+    function testToDataWithIntendedValidatorHash(address validator, bytes32 messageHash) external pure {
+        assertEq(
+            MessageHashUtils.toDataWithIntendedValidatorHash(validator, messageHash),
+            MessageHashUtils.toDataWithIntendedValidatorHash(_dirty(validator), messageHash)
+        );
+
+        assertEq(
+            MessageHashUtils.toDataWithIntendedValidatorHash(validator, messageHash),
+            MessageHashUtils.toDataWithIntendedValidatorHash(validator, abi.encodePacked(messageHash))
+        );
+    }
+
+    function _dirty(address input) private pure returns (address output) {
+        assembly ("memory-safe") {
+            output := or(input, shl(160, not(0)))
+        }
+    }
+}

package/lib/openzeppelin-contracts/test/utils/cryptography/MessageHashUtils.test.js

@@ -0,0 +1,149 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { domainType, domainSeparator, hashTypedData } = require('../../helpers/eip712');
+const { generators } = require('../../helpers/random');
+
+async function fixture() {
+  const mock = await ethers.deployContract('$MessageHashUtils');
+  return { mock };
+}
+
+describe('MessageHashUtils', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('toEthSignedMessageHash', function () {
+    it('prefixes bytes32 data correctly', async function () {
+      const message = ethers.randomBytes(32);
+      const expectedHash = ethers.hashMessage(message);
+
+      await expect(this.mock.getFunction('$toEthSignedMessageHash(bytes32)')(message)).to.eventually.equal(
+        expectedHash,
+      );
+    });
+
+    it('prefixes dynamic length data correctly', async function () {
+      const message = ethers.randomBytes(128);
+      const expectedHash = ethers.hashMessage(message);
+
+      await expect(this.mock.getFunction('$toEthSignedMessageHash(bytes)')(message)).to.eventually.equal(expectedHash);
+    });
+
+    it('version match for bytes32', async function () {
+      const message = ethers.randomBytes(32);
+      const fixed = await this.mock.getFunction('$toEthSignedMessageHash(bytes32)')(message);
+      const dynamic = await this.mock.getFunction('$toEthSignedMessageHash(bytes)')(message);
+
+      expect(fixed).to.equal(dynamic);
+    });
+  });
+
+  describe('toDataWithIntendedValidatorHash', function () {
+    it('returns the digest of `bytes32 messageHash` correctly', async function () {
+      const verifier = ethers.Wallet.createRandom().address;
+      const message = ethers.randomBytes(32);
+      const expectedHash = ethers.solidityPackedKeccak256(
+        ['string', 'address', 'bytes32'],
+        ['\x19\x00', verifier, message],
+      );
+
+      await expect(
+        this.mock.getFunction('$toDataWithIntendedValidatorHash(address,bytes32)')(verifier, message),
+      ).to.eventually.equal(expectedHash);
+    });
+
+    it('returns the digest of `bytes memory message` correctly', async function () {
+      const verifier = ethers.Wallet.createRandom().address;
+      const message = ethers.randomBytes(128);
+      const expectedHash = ethers.solidityPackedKeccak256(
+        ['string', 'address', 'bytes'],
+        ['\x19\x00', verifier, message],
+      );
+
+      await expect(
+        this.mock.getFunction('$toDataWithIntendedValidatorHash(address,bytes)')(verifier, message),
+      ).to.eventually.equal(expectedHash);
+    });
+
+    it('version match for bytes32', async function () {
+      const verifier = ethers.Wallet.createRandom().address;
+      const message = ethers.randomBytes(32);
+      const fixed = await this.mock.getFunction('$toDataWithIntendedValidatorHash(address,bytes)')(verifier, message);
+      const dynamic = await this.mock.getFunction('$toDataWithIntendedValidatorHash(address,bytes32)')(
+        verifier,
+        message,
+      );
+
+      expect(fixed).to.equal(dynamic);
+    });
+  });
+
+  describe('toTypedDataHash', function () {
+    it('returns the digest correctly', async function () {
+      const domain = {
+        name: 'Test',
+        version: '1',
+        chainId: 1n,
+        verifyingContract: ethers.Wallet.createRandom().address,
+      };
+      const structhash = ethers.randomBytes(32);
+      const expectedHash = hashTypedData(domain, structhash);
+
+      await expect(this.mock.$toTypedDataHash(domainSeparator(domain), structhash)).to.eventually.equal(expectedHash);
+    });
+  });
+
+  describe('ERC-5267', function () {
+    const fullDomain = {
+      name: generators.string(),
+      version: generators.string(),
+      chainId: generators.uint256(),
+      verifyingContract: generators.address(),
+      salt: generators.bytes32(),
+    };
+
+    for (let fields = 0; fields < 1 << Object.keys(fullDomain).length; ++fields) {
+      const domain = Object.fromEntries(Object.entries(fullDomain).filter((_, i) => fields & (1 << i)));
+      const domainTypeName = new ethers.TypedDataEncoder({ EIP712Domain: domainType(domain) }).encodeType(
+        'EIP712Domain',
+      );
+
+      describe(domainTypeName, function () {
+        it('toDomainSeparator(bytes1,string,string,uint256,address,bytes32)', async function () {
+          await expect(
+            this.mock.$toDomainSeparator(
+              ethers.toBeHex(fields),
+              ethers.Typed.string(fullDomain.name),
+              ethers.Typed.string(fullDomain.version),
+              fullDomain.chainId,
+              fullDomain.verifyingContract,
+              fullDomain.salt,
+            ),
+          ).to.eventually.equal(domainSeparator(domain));
+        });
+
+        it('toDomainSeparator(bytes1,bytes32,bytes32,uint256,address,bytes32)', async function () {
+          await expect(
+            this.mock.$toDomainSeparator(
+              ethers.toBeHex(fields),
+              ethers.Typed.bytes32(ethers.id(fullDomain.name)),
+              ethers.Typed.bytes32(ethers.id(fullDomain.version)),
+              fullDomain.chainId,
+              fullDomain.verifyingContract,
+              fullDomain.salt,
+            ),
+          ).to.eventually.equal(domainSeparator(domain));
+        });
+
+        it('toDomainTypeHash', async function () {
+          await expect(this.mock.$toDomainTypeHash(ethers.toBeHex(fields))).to.eventually.equal(
+            ethers.id(domainTypeName),
+          );
+        });
+      });
+    }
+  });
+});

package/lib/openzeppelin-contracts/test/utils/cryptography/P256.t.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+
+import {P256} from "@openzeppelin/contracts/utils/cryptography/P256.sol";
+import {Errors} from "@openzeppelin/contracts/utils/Errors.sol";
+
+contract P256Test is Test {
+    /// forge-config: default.fuzz.runs = 512
+    function testVerify(bytes32 digest, uint256 seed) public view {
+        uint256 privateKey = _asPrivateKey(seed);
+
+        (uint256 x, uint256 y) = vm.publicKeyP256(privateKey);
+        (bytes32 r, bytes32 s) = vm.signP256(privateKey, digest);
+        s = _ensureLowerS(s);
+        assertTrue(P256.verify(digest, r, s, bytes32(x), bytes32(y)));
+        assertTrue(P256.verifyNative(digest, r, s, bytes32(x), bytes32(y)));
+        assertTrue(P256.verifySolidity(digest, r, s, bytes32(x), bytes32(y)));
+    }
+
+    /// forge-config: default.fuzz.runs = 512
+    function testRecover(bytes32 digest, uint256 seed) public view {
+        uint256 privateKey = _asPrivateKey(seed);
+
+        (uint256 x, uint256 y) = vm.publicKeyP256(privateKey);
+        (bytes32 r, bytes32 s) = vm.signP256(privateKey, digest);
+        s = _ensureLowerS(s);
+        (bytes32 qx0, bytes32 qy0) = P256.recovery(digest, 0, r, s);
+        (bytes32 qx1, bytes32 qy1) = P256.recovery(digest, 1, r, s);
+        assertTrue((qx0 == bytes32(x) && qy0 == bytes32(y)) || (qx1 == bytes32(x) && qy1 == bytes32(y)));
+    }
+
+    function _asPrivateKey(uint256 seed) private pure returns (uint256) {
+        return bound(seed, 1, P256.N - 1);
+    }
+
+    function _ensureLowerS(bytes32 s) private pure returns (bytes32) {
+        uint256 _s = uint256(s);
+        unchecked {
+            return _s > P256.N / 2 ? bytes32(P256.N - _s) : s;
+        }
+    }
+}