Reorganize the repo structure (#2503)

Co-authored-by: Francisco Giordano <frangio.1@gmail.com>

test/utils/cryptography/ECDSA.test.js

@@ -0,0 +1,144 @@
+const { expectRevert } = require('@openzeppelin/test-helpers');
+const { toEthSignedMessageHash, fixSignature } = require('../../helpers/sign');
+
+const { expect } = require('chai');
+
+const ECDSAMock = artifacts.require('ECDSAMock');
+
+const TEST_MESSAGE = web3.utils.sha3('OpenZeppelin');
+const WRONG_MESSAGE = web3.utils.sha3('Nope');
+
+contract('ECDSA', function (accounts) {
+  const [ other ] = accounts;
+
+  beforeEach(async function () {
+    this.ecdsa = await ECDSAMock.new();
+  });
+
+  context('recover with invalid signature', function () {
+    it('with short signature', async function () {
+      await expectRevert(this.ecdsa.recover(TEST_MESSAGE, '0x1234'), 'ECDSA: invalid signature length');
+    });
+
+    it('with long signature', async function () {
+      await expectRevert(
+        // eslint-disable-next-line max-len
+        this.ecdsa.recover(TEST_MESSAGE, '0x01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789'),
+        'ECDSA: invalid signature length',
+      );
+    });
+  });
+
+  context('recover with valid signature', function () {
+    context('with v0 signature', function () {
+      // Signature generated outside ganache with method web3.eth.sign(signer, message)
+      const signer = '0x2cc1166f6212628A0deEf2B33BEFB2187D35b86c';
+      // eslint-disable-next-line max-len
+      const signatureWithoutVersion = '0x5d99b6f7f6d1f73d1a26497f2b1c89b24c0993913f86e9a2d02cd69887d9c94f3c880358579d811b21dd1b7fd9bb01c1d81d10e69f0384e675c32b39643be892';
+
+      context('with 00 as version value', function () {
+        it('reverts', async function () {
+          const version = '00';
+          const signature = signatureWithoutVersion + version;
+          await expectRevert(this.ecdsa.recover(TEST_MESSAGE, signature), 'ECDSA: invalid signature \'v\' value');
+        });
+      });
+
+      context('with 27 as version value', function () {
+        it('works', async function () {
+          const version = '1b'; // 27 = 1b.
+          const signature = signatureWithoutVersion + version;
+          expect(await this.ecdsa.recover(TEST_MESSAGE, signature)).to.equal(signer);
+        });
+      });
+
+      context('with wrong version', function () {
+        it('reverts', async function () {
+          // The last two hex digits are the signature version.
+          // The only valid values are 0, 1, 27 and 28.
+          const version = '02';
+          const signature = signatureWithoutVersion + version;
+          await expectRevert(this.ecdsa.recover(TEST_MESSAGE, signature), 'ECDSA: invalid signature \'v\' value');
+        });
+      });
+    });
+
+    context('with v1 signature', function () {
+      const signer = '0x1E318623aB09Fe6de3C9b8672098464Aeda9100E';
+      // eslint-disable-next-line max-len
+      const signatureWithoutVersion = '0x331fe75a821c982f9127538858900d87d3ec1f9f737338ad67cad133fa48feff48e6fa0c18abc62e42820f05943e47af3e9fbe306ce74d64094bdf1691ee53e0';
+
+      context('with 01 as version value', function () {
+        it('reverts', async function () {
+          const version = '01';
+          const signature = signatureWithoutVersion + version;
+          await expectRevert(this.ecdsa.recover(TEST_MESSAGE, signature), 'ECDSA: invalid signature \'v\' value');
+        });
+      });
+
+      context('with 28 as version value', function () {
+        it('works', async function () {
+          const version = '1c'; // 28 = 1c.
+          const signature = signatureWithoutVersion + version;
+          expect(await this.ecdsa.recover(TEST_MESSAGE, signature)).to.equal(signer);
+        });
+      });
+
+      context('with wrong version', function () {
+        it('reverts', async function () {
+          // The last two hex digits are the signature version.
+          // The only valid values are 0, 1, 27 and 28.
+          const version = '02';
+          const signature = signatureWithoutVersion + version;
+          await expectRevert(this.ecdsa.recover(TEST_MESSAGE, signature), 'ECDSA: invalid signature \'v\' value');
+        });
+      });
+    });
+
+    context('with high-s value signature', function () {
+      it('reverts', async function () {
+        const message = '0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9';
+        // eslint-disable-next-line max-len
+        const highSSignature = '0xe742ff452d41413616a5bf43fe15dd88294e983d3d36206c2712f39083d638bde0a0fc89be718fbc1033e1d30d78be1c68081562ed2e97af876f286f3453231d1b';
+
+        await expectRevert(this.ecdsa.recover(message, highSSignature), 'ECDSA: invalid signature \'s\' value');
+      });
+    });
+
+    context('using web3.eth.sign', function () {
+      context('with correct signature', function () {
+        it('returns signer address', async function () {
+          // Create the signature
+          const signature = fixSignature(await web3.eth.sign(TEST_MESSAGE, other));
+
+          // Recover the signer address from the generated message and signature.
+          expect(await this.ecdsa.recover(
+            toEthSignedMessageHash(TEST_MESSAGE),
+            signature,
+          )).to.equal(other);
+        });
+      });
+
+      context('with wrong message', function () {
+        it('returns a different address', async function () {
+          const signature = fixSignature(await web3.eth.sign(TEST_MESSAGE, other));
+          expect(await this.ecdsa.recover(WRONG_MESSAGE, signature)).to.not.equal(other);
+        });
+      });
+
+      context('with invalid signature', function () {
+        it('reverts', async function () {
+          // eslint-disable-next-line max-len
+          const signature = '0x332ce75a821c982f9127538858900d87d3ec1f9f737338ad67cad133fa48feff48e6fa0c18abc62e42820f05943e47af3e9fbe306ce74d64094bdf1691ee53e01c';
+          await expectRevert(this.ecdsa.recover(TEST_MESSAGE, signature), 'ECDSA: invalid signature');
+        });
+      });
+    });
+  });
+
+  context('toEthSignedMessage', function () {
+    it('should prefix hashes correctly', async function () {
+      expect(await this.ecdsa.toEthSignedMessageHash(TEST_MESSAGE)).to.equal(toEthSignedMessageHash(TEST_MESSAGE));
+    });
+  });
+});

test/utils/cryptography/MerkleProof.test.js

@@ -0,0 +1,59 @@
+require('@openzeppelin/test-helpers');
+
+const { MerkleTree } = require('../../helpers/merkleTree.js');
+const { keccakFromString, bufferToHex } = require('ethereumjs-util');
+
+const { expect } = require('chai');
+
+const MerkleProofWrapper = artifacts.require('MerkleProofWrapper');
+
+contract('MerkleProof', function (accounts) {
+  beforeEach(async function () {
+    this.merkleProof = await MerkleProofWrapper.new();
+  });
+
+  describe('verify', function () {
+    it('returns true for a valid Merkle proof', async function () {
+      const elements = ['a', 'b', 'c', 'd'];
+      const merkleTree = new MerkleTree(elements);
+
+      const root = merkleTree.getHexRoot();
+
+      const proof = merkleTree.getHexProof(elements[0]);
+
+      const leaf = bufferToHex(keccakFromString(elements[0]));
+
+      expect(await this.merkleProof.verify(proof, root, leaf)).to.equal(true);
+    });
+
+    it('returns false for an invalid Merkle proof', async function () {
+      const correctElements = ['a', 'b', 'c'];
+      const correctMerkleTree = new MerkleTree(correctElements);
+
+      const correctRoot = correctMerkleTree.getHexRoot();
+
+      const correctLeaf = bufferToHex(keccakFromString(correctElements[0]));
+
+      const badElements = ['d', 'e', 'f'];
+      const badMerkleTree = new MerkleTree(badElements);
+
+      const badProof = badMerkleTree.getHexProof(badElements[0]);
+
+      expect(await this.merkleProof.verify(badProof, correctRoot, correctLeaf)).to.equal(false);
+    });
+
+    it('returns false for a Merkle proof of invalid length', async function () {
+      const elements = ['a', 'b', 'c'];
+      const merkleTree = new MerkleTree(elements);
+
+      const root = merkleTree.getHexRoot();
+
+      const proof = merkleTree.getHexProof(elements[0]);
+      const badProof = proof.slice(0, proof.length - 5);
+
+      const leaf = bufferToHex(keccakFromString(elements[0]));
+
+      expect(await this.merkleProof.verify(badProof, root, leaf)).to.equal(false);
+    });
+  });
+});

test/utils/cryptography/draft-EIP712.test.js

@@ -0,0 +1,57 @@
+const ethSigUtil = require('eth-sig-util');
+const Wallet = require('ethereumjs-wallet').default;
+
+const { EIP712Domain, domainSeparator } = require('../../helpers/eip712');
+
+const EIP712 = artifacts.require('EIP712External');
+
+contract('EIP712', function (accounts) {
+  const [mailTo] = accounts;
+
+  const name = 'A Name';
+  const version = '1';
+
+  beforeEach('deploying', async function () {
+    this.eip712 = await EIP712.new(name, version);
+
+    // We get the chain id from the contract because Ganache (used for coverage) does not return the same chain id
+    // from within the EVM as from the JSON RPC interface.
+    // See https://github.com/trufflesuite/ganache-core/issues/515
+    this.chainId = await this.eip712.getChainId();
+  });
+
+  it('domain separator', async function () {
+    expect(
+      await this.eip712.domainSeparator(),
+    ).to.equal(
+      await domainSeparator(name, version, this.chainId, this.eip712.address),
+    );
+  });
+
+  it('digest', async function () {
+    const chainId = this.chainId;
+    const verifyingContract = this.eip712.address;
+    const message = {
+      to: mailTo,
+      contents: 'very interesting',
+    };
+
+    const data = {
+      types: {
+        EIP712Domain,
+        Mail: [
+          { name: 'to', type: 'address' },
+          { name: 'contents', type: 'string' },
+        ],
+      },
+      domain: { name, version, chainId, verifyingContract },
+      primaryType: 'Mail',
+      message,
+    };
+
+    const wallet = Wallet.generate();
+    const signature = ethSigUtil.signTypedMessage(wallet.getPrivateKey(), { data });
+
+    await this.eip712.verify(signature, wallet.getAddressString(), message.to, message.contents);
+  });
+});