Add eip1271 test

Author: danfinlay

contracts/ECRecovery.sol

@@ -0,0 +1,43 @@
+pragma solidity 0.8.19;
+
+// SPDX-License-Identifier: MIT
+
+contract ECRecovery {
+    /**
+     * @dev Recover signer address from a message by using their signature
+     * @param hash bytes32 message, the hash is the signed message. What is recovered is the signer address.
+     * @param sig bytes signature, the signature is generated using web3.eth.sign()
+     */
+    function recover(bytes32 hash, bytes memory sig)
+        internal
+        pure
+        returns (address)
+    {
+        bytes32 r;
+        bytes32 s;
+        uint8 v;
+
+        //Check the signature length
+        if (sig.length != 65) {
+            return (address(0));
+        }
+
+        // Divide the signature in r, s and v variables
+        assembly {
+            r := mload(add(sig, 32))
+            s := mload(add(sig, 64))
+            v := byte(0, mload(add(sig, 96)))
+        }
+        // Version of signature should be 27 or 28, but 0 and 1 are also possible versions
+        if (v < 27) {
+            v += 27;
+        }
+
+        // If the version is correct return the signer address
+        if (v != 27 && v != 28) {
+            return (address(0));
+        } else {
+            return ecrecover(hash, v, r, s);
+        }
+    }
+}

contracts/EIP1271.sol

@@ -0,0 +1,31 @@
+pragma solidity 0.8.19;
+import "./ECRecovery.sol";
+
+//SPDX-License-Identifier: MIT
+
+contract EIP1271 is ECRecovery {
+    mapping(address => bool) isOwner;
+
+    constructor() {
+        isOwner[msg.sender] = true;
+    }
+
+    function addOwner(address _owner) public {
+        isOwner[_owner] = true;
+    }
+
+    /**
+     * @notice Verifies that the signer is the owner of the signing contract.
+     */
+    function isValidSignature(bytes32 _hash, bytes calldata _signature)
+        external
+        view
+        returns (bytes4)
+    {
+        if (isOwner[recover(_hash, _signature)]) {
+            return 0x1626ba7e;
+        } else {
+            return 0xffffffff;
+        }
+    }
+}

contracts/MockEIP712Decoder.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.13;
+pragma solidity ^0.8.19;
 
 import "./EIP712Decoder.sol";
 

hardhat.config.js

@@ -1,5 +1,5 @@
 require("@nomiclabs/hardhat-ethers");
 
 module.exports = {
-  solidity: "0.8.13",
+  solidity: "0.8.19",
 };

test.js

@@ -139,6 +139,60 @@ describe('EIP712Decoder', function () {
   });
 });
 
+describe('EIP-1271', () => {
+  let contract, eip1271, owner, other, accounts, signer, typedData, eip712Decoder, privateKey, wallet;
+
+  beforeEach(async () => {
+    // Compile the contract using Hardhat
+    await hre.run('compile');
+
+    // Set up a ganache provider with the generated Solidity code
+    const ganacheProvider = ganache.provider({})
+    const provider = new ethers.providers.Web3Provider(ganacheProvider);
+    const mnemonic = ganacheProvider.options.mnemonic;
+    wallet = ethers.Wallet.fromMnemonic(mnemonic);
+    privateKey = wallet.privateKey;
+    accounts = await provider.listAccounts();
+    signer = provider.getSigner(accounts[0]);
+
+    // Load up the compiled contract artifact
+    const EIP712Decoder = await hre.artifacts.readArtifact('MockEIP712Decoder');
+
+    // Deploy the contract
+    const EIP712DecoderFactory = new ethers.ContractFactory(EIP712Decoder.abi, EIP712Decoder.bytecode, signer);
+    contract = await EIP712DecoderFactory.deploy([1]);
+    message.domain.verifyingContract = contract.address;
+    await contract.deployed();
+
+    // Create the typed data for testing
+    typedData = JSON.parse(JSON.stringify(message));
+    typedData.domain.verifyingContract = contract.address;
+
+    // Deploy the EIP-1271 contract
+    const EIP1271 = await hre.artifacts.readArtifact('EIP1271');
+    const EIP1271ContractFactory = new ethers.ContractFactory(EIP1271.abi, EIP1271.bytecode, signer);
+    const EIP1271Contract = await EIP1271ContractFactory.deploy([]);
+    eip1271 = await EIP1271Contract.deployed();
+    await eip1271.deployed();
+
+    await eip1271.addOwner(wallet.address);
+  });
+
+  describe('contract account signature recovery', () => {
+    it('should recover the correct signer', async () => {
+      // Sign the typed data using eth-sig-util
+      const signedPerson = signStruct(privateKey);
+      signedPerson.signer = eip1271.address;
+
+      // Call the verifySigned method with the EIP-1271 contract address as the signer
+      const result = await contract.verifySignedPerson(signedPerson);
+
+      // Verify that the returned address is equal to the EIP-1271 contract address
+      expect(result).to.equal(eip1271.address);
+    });
+  });
+});
+
 function signStruct (privateKey) {
   const signature = sigUtil.signTypedData({
     privateKey: fromHexString(privateKey.indexOf('0x') === 0 ? privateKey.substring(2) : privateKey),